From a8ac8eeb9b9a0e1e1f009b480327724e521fe273 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 17:55:29 +0530 Subject: [PATCH 01/60] 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. --- docs/CURRENT-STATE.md | 23 + scripts/format-scope.json | 3 + scripts/package-boundaries.json | 2 + src/app/layers/earthquakeRipples.js | 381 ++++++++++++++ src/app/layers/earthquakeRipples.test.mjs | 420 +++++++++++++++ src/app/layers/earthquakes.js | 44 +- src/i18n/locales/ar.json | 11 + src/i18n/locales/de.json | 11 + src/i18n/locales/es.json | 11 + src/i18n/locales/fr.json | 11 + src/i18n/locales/he.json | 11 + src/i18n/locales/it.json | 11 + src/i18n/locales/ja.json | 11 + src/i18n/locales/pt.json | 11 + src/i18n/locales/ru.json | 11 + src/i18n/locales/sv.json | 11 + src/i18n/locales/uk.json | 11 + src/i18n/locales/zh-CN.json | 11 + src/i18n/locales/zh-Hant.json | 11 + src/layers/earthquakes/index.js | 397 ++++++++++++-- src/layers/earthquakes/model.js | 292 +++++++++++ src/layers/earthquakes/selection.test.mjs | 610 ++++++++++++++++++++++ src/navigationPolicy.js | 1 + src/worldFocus.js | 3 + src/worldFocus.test.mjs | 7 +- 25 files changed, 2292 insertions(+), 34 deletions(-) create mode 100644 src/app/layers/earthquakeRipples.js create mode 100644 src/app/layers/earthquakeRipples.test.mjs create mode 100644 src/layers/earthquakes/selection.test.mjs diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 811e2a1fd6..5a3af0a5b9 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1851,6 +1851,19 @@ feed's place, cut to 40 characters (`earthquakeMarkLabel` in `src/layers/earthquakes/model.js`: `M6.4 · 113 km SSE of Lata, Solomon Islands`, or `M6.4` with no place). +Clicking a quake's disc selects it; clicking its magnitude label (what a far +view can hit) also flies the camera there through the world-focus request +(`earthquake` framing in `src/worldFocus.js`). The selected quake shows a card +(`describeEarthquake`): magnitude and USGS class (`M5.5 · Moderate`), a +six-step class meter with the depth band, place, UTC time and source; with a +USGS event id the card opens that event's page. The selection is also the +shared context selection, so "what's selected" answers with it. Its disc is +painted with a gradient fading to the outer circle and wavy contour lines +(shaped by the quake's id, never crossing) under the labels. The package takes +clicks, picking, context, focus, the opener, the painter and the translator by +injection (`src/app/layers/earthquakes.js`); without input and picking it draws +and takes no clicks, and its labels stay non-interactive. + Air quality (`./layers/air-quality`) draws its station discs as one renderer draw set of ground-clamped fills and reads the view through the camera port; it no longer reaches Cesium, so a caller handing it a Cesium viewer, @@ -8165,6 +8178,16 @@ on it. per frame, it holds NO continuous-render hold — the governor stays idle with earthquakes on, and the manager's `layer-tick` / `layer-visibility` requests carry new data to the screen. Pinned in `src/data/earthquakes.test.mjs`. + The one animation is the selected quake's contour lines + (`src/app/layers/earthquakeRipples.js`), painted on the world overlay, not + the ground set: they ask for frames for `RIPPLE_ACTIVE_CYCLES` (3) runs out + to the disc's edge after a selection (about 14 s), only while the disc is on + screen, then rest as still contours and ask for none. A parked camera with a + quake selected therefore returns to idle. A feed refresh updates the + selected quake in place: it neither runs the contours again nor takes back + a shared selection made since; only a click or a label's activation does. + Selecting fades that one disc's flat fill once (an `upsert`, not per frame) + under the painted gradient. - **Geocode framing has an off-centre sanity gate.** A viewport that is both bigger than any city (>300 km diagonal) and not centred on its own geocoded location (anchor >15% of the diagonal from the centroid) is replaced by a diff --git a/scripts/format-scope.json b/scripts/format-scope.json index e474377e12..1069652db2 100644 --- a/scripts/format-scope.json +++ b/scripts/format-scope.json @@ -434,6 +434,9 @@ "src/layers/earthquakes/model.js", "src/layers/earthquakes/source.js", "src/layers/earthquakes/ownership.test.mjs", + "src/layers/earthquakes/selection.test.mjs", + "src/app/layers/earthquakeRipples.js", + "src/app/layers/earthquakeRipples.test.mjs", "src/layers/perimeters/index.js", "src/layers/perimeters/records.js", "src/layers/perimeters/source.js", diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index 4147d8f6cd..4b4d0e9776 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -4060,6 +4060,7 @@ "src/app/layers/bikeshare.js", "src/app/layers/cctv.js", "src/app/layers/cyclones.js", + "src/app/layers/earthquakeRipples.js", "src/app/layers/earthquakes.js", "src/app/layers/firms.js", "src/app/layers/flights.js", @@ -5466,6 +5467,7 @@ "src/app/layers/bikeshare.js", "src/app/layers/cctv.js", "src/app/layers/cyclones.js", + "src/app/layers/earthquakeRipples.js", "src/app/layers/earthquakes.js", "src/app/layers/firms.js", "src/app/layers/flights.js", diff --git a/src/app/layers/earthquakeRipples.js b/src/app/layers/earthquakeRipples.js new file mode 100644 index 0000000000..31f3557c44 --- /dev/null +++ b/src/app/layers/earthquakeRipples.js @@ -0,0 +1,381 @@ +import { registerWorldOverlayPaintLane } from '../../overlays/worldOverlay.js'; +import { fromDegrees } from '../../geo/ellipsoid.js'; +import { + earthquakeContourRings, + earthquakeContourScale, + earthquakeContourShape, + earthquakeRippleRings, + EARTHQUAKE_RIPPLE_PERIOD_MS, +} from '../../layers/earthquakes/model.js'; + +/** Points around each contour line: smooth at the largest disc on screen. */ +export const RIPPLE_RING_SEGMENTS = 96; +/** An index contour's width, and every other line's. */ +const INDEX_WIDTH_PX = 2; +const LINE_WIDTH_PX = 1.1; +/** + * The overlay lane the lines paint in: the magnitude labels' own. A lane's + * custom painters run before its entries, so the lines sit under the labels + * and under the selected quake's card. + */ +export const RIPPLE_PAINT_LANE = 'ambient-label'; +/** + * The selected disc's fill, [offset, alpha] from the epicentre (0) to its + * outer circle (1): strongest in the middle, fading out to nothing at the + * edge. + */ +export const DISC_FADE = Object.freeze([ + [0, 0.42], + [0.35, 0.26], + [0.75, 0.1], + [1, 0], +]); +/** + * Each contour wave's fill, out to its own line: clear inside, tinting + * toward the line; times the wave's own fade. + */ +export const WAVE_FADE = Object.freeze([ + [0, 0], + [0.55, 0], + [1, 0.2], +]); + +/** + * `rgb(r,g,b)` (or `rgba`) as a function of alpha, for gradient stops; any + * other colour keeps its own alpha. + */ +export function cssWithAlpha(color) { + const m = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(String(color)); + if (!m) return () => color; + const rgb = `${m[1]},${m[2]},${m[3]}`; + return (alpha) => `rgba(${rgb},${Math.max(0, Math.min(1, alpha))})`; +} + +/** + * How many times the lines run out to the edge after a quake is selected + * before they rest as still contours and stop asking for frames: earthquakes + * otherwise hold no render (docs/CURRENT-STATE.md, "Earthquake discs are + * STATIC geometry"), and a quake can stay selected for hours. + */ +export const RIPPLE_ACTIVE_CYCLES = 3; + +let reducedMotionQuery; +/** + * The viewer's reduced-motion setting, live: the media query is kept, so a + * change mid-session is read at the next paint and tick. + */ +const reducedMotion = () => { + try { + reducedMotionQuery ??= + globalThis.matchMedia?.('(prefers-reduced-motion: reduce)') ?? null; + return reducedMotionQuery?.matches === true; + } catch { + return false; + } +}; + +/** + * The selected earthquake's contour lines, painted on the world overlay: + * wavy closed lines, shaped by the quake's id (earthquakeContourShape), run + * from the marker out to the disc's edge and fade there, one after another, + * for RIPPLE_ACTIVE_CYCLES runs after a quake is selected and only while it + * is on screen, then rest as still contours. They never cross, and every third is + * a heavier index contour, as on a topographic map. Nothing is drawn, and no + * frame is asked for, while no quake is selected. With reduced motion the + * lines hold still. + * + * A line is drawn in the tangent plane at the epicentre: at the largest + * disc (M6, 64 km) it sits about 320 m above the curved ground at its edge + * (64² / 2R), about 1.5 px off the drawn disc at the 220 km, -45° framing a + * label click flies to (900 px tall, 35° field of view); less for smaller + * quakes, as the offset grows with the square of the radius. + * @param {object} [deps] + * @param {Function} [deps.registerLane] `registerWorldOverlayPaintLane`. + * @param {() => number} [deps.now] Steady clock, ms. + * @param {(cb: Function) => number} [deps.requestFrame] + * @param {(handle: number) => void} [deps.cancelFrame] + * @param {() => boolean} [deps.prefersReducedMotion] + * @returns {{show: Function, hide: Function, dispose: Function}} + */ +export function createEarthquakeRipples({ + registerLane = registerWorldOverlayPaintLane, + now = () => globalThis.performance?.now?.() ?? Date.now(), + requestFrame = (cb) => globalThis.requestAnimationFrame?.(cb) ?? null, + cancelFrame = (handle) => globalThis.cancelAnimationFrame?.(handle), + prefersReducedMotion = reducedMotion, +} = {}) { + let lane = null; + let target = null; + let frameHandle = null; + // When the running lines settle into still contours (the selection's + // bound), and whether the last paint found the quake on screen. + let startedAt = 0; + let settlesAt = 0; + let onScreen = false; + /** Whether the lines run now: in the window, and motion allowed. */ + const running = () => now() < settlesAt && !prefersReducedMotion(); + // Unit offsets around the line in the epicentre's tangent plane, packed + // x, y, z per point: north·cos + east·sin. + const offsets = new Float64Array((RIPPLE_RING_SEGMENTS + 1) * 3); + const angles = new Float64Array(RIPPLE_RING_SEGMENTS + 1); + for (let i = 0; i <= RIPPLE_RING_SEGMENTS; i++) + angles[i] = (2 * Math.PI * i) / RIPPLE_RING_SEGMENTS; + + // Screen points, reused every frame. + const at = { x: 0, y: 0 }; + const centerAt = { x: 0, y: 0 }; + const eastAt = { x: 0, y: 0 }; + const northAt = { x: 0, y: 0 }; + + /** Project an ECEF point to CSS pixels; false when it is behind the eye. */ + function project(frame, px, py, pz, out) { + const m = frame.viewProjectionMatrix; + const w = m[3] * px + m[7] * py + m[11] * pz + m[15]; + if (w <= 0) return false; + out.x = + ((m[0] * px + m[4] * py + m[8] * pz + m[12]) / w / 2 + 0.5) * frame.width; + out.y = + (0.5 - (m[1] * px + m[5] * py + m[9] * pz + m[13]) / w / 2) * + frame.height; + return true; + } + + /** + * Trace one closed line at `fraction` of the disc's radius (`shaped`: + * as a contour, else the disc's own circle). True when all of it is in + * front of the eye, so it can be filled. + */ + function trace(frame, fraction, shaped) { + const { ctx } = frame; + const center = target.center; + const reach = fraction * target.radiusM; + ctx.beginPath(); + let pen = false; + let whole = true; + for (let i = 0; i <= RIPPLE_RING_SEGMENTS; i++) { + // The last point repeats the first angle, so the line closes. + const r = shaped + ? reach * earthquakeContourScale(target.shape, angles[i], fraction) + : reach; + const visible = project( + frame, + center.x + offsets[i * 3] * r, + center.y + offsets[i * 3 + 1] * r, + center.z + offsets[i * 3 + 2] * r, + at, + ); + if (!visible) { + pen = false; + whole = false; + continue; + } + if (pen) ctx.lineTo(at.x, at.y); + else ctx.moveTo(at.x, at.y); + pen = true; + } + return whole; + } + + /** + * Fill the traced path with a radial gradient laid on the ground: the + * canvas places a path when it is traced and a gradient when it fills, so + * under the disc's ground-to-screen transform the gradient's circle + * becomes the disc's ellipse on screen while the path stays exact. + * @param {Array<[number, number]>} stops [offset, alpha], out to `reach`. + */ + function fillGround(ctx, reach, stops) { + ctx.save(); + ctx.transform( + eastAt.x - centerAt.x, + eastAt.y - centerAt.y, + northAt.x - centerAt.x, + northAt.y - centerAt.y, + centerAt.x, + centerAt.y, + ); + const gradient = ctx.createRadialGradient(0, 0, 0, 0, 0, reach); + for (const [offset, alpha] of stops) + gradient.addColorStop(offset, target.rgba(alpha)); + ctx.fillStyle = gradient; + ctx.globalAlpha = 1; + ctx.fill(); + ctx.restore(); + } + + /** + * Whether any of the disc is in the viewport: its centre's screen point, + * padded by its larger screen radius (or, seen edge-on, the centre alone). + */ + function discOnScreen(frame, c, e, n) { + if (!Number.isFinite(c.x) || !Number.isFinite(c.y)) return false; + const pad = Math.max( + Math.hypot(e.x - c.x, e.y - c.y) || 0, + Math.hypot(n.x - c.x, n.y - c.y) || 0, + ); + return ( + c.x + pad >= 0 && + c.x - pad <= frame.width && + c.y + pad >= 0 && + c.y - pad <= frame.height + ); + } + + function paint(frame) { + if (!target) return; + const { ctx } = frame; + const center = target.center; + onScreen = false; + if (frame.occluder?.isPointVisible?.(center) === false) return; + const R = target.radiusM; + // The disc's ground frame on screen: its centre, and a radius east and + // north. Seen edge-on (or partly behind the eye) it is not filled. + const centerOk = project(frame, center.x, center.y, center.z, centerAt); + const eastOk = project( + frame, + center.x + target.east.x * R, + center.y + target.east.y * R, + center.z + target.east.z * R, + eastAt, + ); + const northOk = project( + frame, + center.x + target.north.x * R, + center.y + target.north.y * R, + center.z + target.north.z * R, + northAt, + ); + let fills = centerOk && eastOk && northOk; + if (fills) { + const area = + (eastAt.x - centerAt.x) * (northAt.y - centerAt.y) - + (eastAt.y - centerAt.y) * (northAt.x - centerAt.x); + fills = Math.abs(area) > 1; + } + onScreen = + centerOk && + discOnScreen( + frame, + centerAt, + eastOk ? eastAt : centerAt, + northOk ? northAt : centerAt, + ); + // The disc: strongest at the epicentre, fading out to its outer circle. + if (fills && trace(frame, 1, false)) fillGround(ctx, 1, DISC_FADE); + const animate = running(); + const rings = animate + ? earthquakeRippleRings(now() - startedAt) + : earthquakeContourRings(); + // Brought back into view while the window lasts: run again. + if (animate && onScreen && frameHandle === null && lane) + frameHandle = requestFrame(tick); + ctx.strokeStyle = target.color; + ctx.lineJoin = 'round'; + for (const { fraction, alpha, index } of rings) { + if (!(alpha > 0.01)) continue; + const whole = trace(frame, fraction, true); + // Each wave: clear inside, tinting toward its own line, as it fades. + if (fills && whole) + fillGround( + ctx, + fraction, + WAVE_FADE.map(([offset, a]) => [offset, a * alpha]), + ); + ctx.lineWidth = index ? INDEX_WIDTH_PX : LINE_WIDTH_PX; + ctx.globalAlpha = alpha; + ctx.stroke(); + } + ctx.globalAlpha = 1; + } + + /** Ask for one more frame while the lines run (one request at a time). */ + function tick() { + frameHandle = null; + if (!target || !lane) return; + // Settled, or out of sight: one last paint draws the still contours + // (or nothing), and no more frames are asked for. A paint that finds it + // on screen again inside the window starts the frames again. + if (!running() || !onScreen) { + lane.requestPaint(); + return; + } + lane.requestPaint(); + frameHandle = requestFrame(tick); + } + + function stopFrames() { + if (frameHandle !== null) cancelFrame(frameHandle); + frameHandle = null; + } + + /** + * Run the contour lines around one quake, replacing any other. + * @param {{id: string, lon: number, lat: number, radiusM: number, color: string}} next + * @param {{restart?: boolean}} [options] `restart: false` updates the + * same quake in place (a feed refresh) without running it again. + */ + function show(next, { restart = true } = {}) { + if ( + !next || + !Number.isFinite(next.lon) || + !Number.isFinite(next.lat) || + !(next.radiusM > 0) + ) { + hide(); + return; + } + const sameQuake = target?.id === next.id; + const lon = (next.lon * Math.PI) / 180; + const lat = (next.lat * Math.PI) / 180; + const [sinLon, cosLon] = [Math.sin(lon), Math.cos(lon)]; + const [sinLat, cosLat] = [Math.sin(lat), Math.cos(lat)]; + for (let i = 0; i <= RIPPLE_RING_SEGMENTS; i++) { + const [c, s] = [Math.cos(angles[i]), Math.sin(angles[i])]; + offsets[i * 3] = c * -sinLat * cosLon + s * -sinLon; + offsets[i * 3 + 1] = c * -sinLat * sinLon + s * cosLon; + offsets[i * 3 + 2] = c * cosLat; + } + target = { + id: next.id, + center: fromDegrees(next.lon, next.lat), + radiusM: next.radiusM, + color: next.color || 'rgb(255,165,0)', + shape: earthquakeContourShape(next.id), + rgba: cssWithAlpha(next.color || 'rgb(255,165,0)'), + // Angle 0 is north and a quarter turn is east (see `offsets`). + north: { x: offsets[0], y: offsets[1], z: offsets[2] }, + east: { + x: offsets[(RIPPLE_RING_SEGMENTS / 4) * 3], + y: offsets[(RIPPLE_RING_SEGMENTS / 4) * 3 + 1], + z: offsets[(RIPPLE_RING_SEGMENTS / 4) * 3 + 2], + }, + }; + if (restart || !sameQuake) { + startedAt = now(); + settlesAt = + startedAt + RIPPLE_ACTIVE_CYCLES * EARTHQUAKE_RIPPLE_PERIOD_MS; + // Assume it is in view until a paint says otherwise. + onScreen = true; + } + lane ??= registerLane(RIPPLE_PAINT_LANE, paint, { + id: 'earthquake-ripples', + }); + lane.setActive(true); + lane.requestPaint(); + if (running() && frameHandle === null) frameHandle = requestFrame(tick); + } + + function hide() { + stopFrames(); + if (!target) return; + target = null; + lane?.setActive(false); + } + + function dispose() { + hide(); + lane?.unregister(); + lane = null; + } + + return { show, hide, dispose }; +} diff --git a/src/app/layers/earthquakeRipples.test.mjs b/src/app/layers/earthquakeRipples.test.mjs new file mode 100644 index 0000000000..e97b9f00a8 --- /dev/null +++ b/src/app/layers/earthquakeRipples.test.mjs @@ -0,0 +1,420 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { + DISC_FADE, + cssWithAlpha, + RIPPLE_ACTIVE_CYCLES, + RIPPLE_PAINT_LANE, + RIPPLE_RING_SEGMENTS, + createEarthquakeRipples, +} from './earthquakeRipples.js'; +import { + EARTHQUAKE_RIPPLE_PERIOD_MS, + EARTHQUAKE_RIPPLE_RINGS, +} from '../../layers/earthquakes/model.js'; +import { fromDegrees } from '../../geo/ellipsoid.js'; + +/** A paint lane, frame clock and canvas the test steps by hand. */ +function harness({ reducedMotion = false } = {}) { + let motionReduced = reducedMotion; + const lanes = []; + const frames = new Map(); + let nextFrame = 1; + let clock = 0; + const ripples = createEarthquakeRipples({ + registerLane(laneId, painter, options) { + const lane = { + laneId, + painter, + options, + active: false, + paints: 0, + unregistered: false, + setActive(next) { + lane.active = next; + }, + requestPaint() { + lane.paints++; + }, + unregister() { + lane.unregistered = true; + }, + }; + lanes.push(lane); + return lane; + }, + now: () => clock, + requestFrame(cb) { + const handle = nextFrame++; + frames.set(handle, cb); + return handle; + }, + cancelFrame: (handle) => frames.delete(handle), + prefersReducedMotion: () => motionReduced, + }); + const strokes = []; + const fills = []; + let path = null; + const ctx = { + globalAlpha: 1, + beginPath() { + path = { moves: 0, lines: 0 }; + }, + moveTo() { + path.moves++; + }, + lineTo() { + path.lines++; + }, + stroke() { + strokes.push({ + ...path, + alpha: ctx.globalAlpha, + color: ctx.strokeStyle, + width: ctx.lineWidth, + }); + }, + // Fills record their path, gradient and the transform they fill under. + saved: 0, + transformed: null, + save() { + ctx.saved++; + }, + restore() { + ctx.saved--; + ctx.transformed = null; + }, + transform(...args) { + ctx.transformed = args; + }, + createRadialGradient(...circles) { + const gradient = { circles, stops: [] }; + gradient.addColorStop = (offset, color) => + gradient.stops.push([offset, color]); + return gradient; + }, + fill() { + fills.push({ + ...path, + gradient: ctx.fillStyle, + transform: ctx.transformed, + }); + }, + }; + // w = 1 everywhere: every point is in front of the eye. + const matrix = new Float64Array(16); + matrix[0] = 1e-7; + matrix[5] = 1e-7; + matrix[15] = 1; + const frame = (visible = true) => ({ + ctx, + width: 800, + height: 600, + viewProjectionMatrix: matrix, + occluder: { isPointVisible: () => visible }, + }); + return { + ripples, + lanes, + frames, + strokes, + fills, + frame, + matrix, + setReducedMotion(next) { + motionReduced = next; + }, + advance(ms) { + clock += ms; + }, + /** Run the pending animation frames once. */ + step() { + const pending = [...frames.entries()]; + frames.clear(); + for (const [, cb] of pending) cb(); + }, + }; +} + +const target = { + id: 'ak1', + lon: -153.3, + lat: 60, + radiusM: 32000, + color: 'rgb(255,0,0)', +}; + +test('nothing is registered or animated until a quake is selected', () => { + const h = harness(); + assert.equal(h.lanes.length, 0); + assert.equal(h.frames.size, 0); + h.ripples.hide(); + assert.equal(h.frames.size, 0); +}); + +test('a selected quake animates one ring set, one frame request at a time', () => { + const h = harness(); + h.ripples.show(target); + const [lane] = h.lanes; + assert.equal(lane.laneId, RIPPLE_PAINT_LANE); + assert.equal(RIPPLE_PAINT_LANE, 'ambient-label', 'under the labels'); + assert.equal(lane.active, true); + assert.equal(h.frames.size, 1); + h.ripples.show({ ...target, id: 'ak2' }); + assert.equal(h.lanes.length, 1, 'the lane is reused'); + assert.equal(h.frames.size, 1, 'still one frame loop'); + const before = lane.paints; + h.step(); + h.step(); + assert.equal(lane.paints, before + 2, 'one repaint per frame'); + assert.equal(h.frames.size, 1); + + h.advance(600); + lane.painter(h.frame()); + // At 600 ms every line is between the marker and the edge, so all draw. + assert.equal(h.strokes.length, EARTHQUAKE_RIPPLE_RINGS); + assert.deepEqual( + h.strokes.map((stroke) => stroke.width), + [2, 1.1, 1.1, 2, 1.1, 1.1], + 'every third line is an index contour', + ); + for (const stroke of h.strokes) { + assert.equal(stroke.moves, 1, 'one unbroken ring'); + assert.equal(stroke.lines, RIPPLE_RING_SEGMENTS); + assert.equal(stroke.color, 'rgb(255,0,0)'); + assert.ok(stroke.alpha > 0 && stroke.alpha <= 1); + } + + h.ripples.hide(); + assert.equal(lane.active, false); + assert.equal(h.frames.size, 0, 'no frames asked for once hidden'); + h.strokes.length = 0; + lane.painter(h.frame()); + assert.equal(h.strokes.length, 0); +}); + +test('rings are skipped behind the globe and broken behind the eye', () => { + const h = harness(); + h.ripples.show(target); + h.advance(600); + const [lane] = h.lanes; + lane.painter(h.frame(false)); + assert.equal(h.strokes.length, 0, 'epicentre over the horizon'); + + // Points with negative x fall behind the eye: each ring breaks there. + const frame = h.frame(); + frame.viewProjectionMatrix[3] = 1e-6; + const center = fromDegrees(target.lon, target.lat); + frame.viewProjectionMatrix[15] = -1e-6 * center.x; + lane.painter(frame); + assert.equal(h.strokes.length, EARTHQUAKE_RIPPLE_RINGS); + for (const stroke of h.strokes) + assert.ok(stroke.lines < RIPPLE_RING_SEGMENTS, 'part of each ring hidden'); +}); + +test('reduced motion draws still contour rings and asks for no frames', () => { + const h = harness({ reducedMotion: true }); + h.ripples.show(target); + assert.equal(h.frames.size, 0); + assert.equal(h.lanes[0].paints, 1, 'painted once'); + h.lanes[0].painter(h.frame()); + assert.equal(h.strokes.length, EARTHQUAKE_RIPPLE_RINGS); + assert.ok(h.strokes.every((stroke) => stroke.alpha === 0.7)); +}); + +test('an unusable target hides the rings; dispose releases the lane', () => { + const h = harness(); + h.ripples.show(target); + h.ripples.show({ ...target, radiusM: 0 }); + assert.equal(h.lanes[0].active, false); + assert.equal(h.frames.size, 0); + h.ripples.dispose(); + assert.equal(h.lanes[0].unregistered, true); + // Shown again after dispose, it registers a fresh lane. + h.ripples.show(target); + assert.equal(h.lanes.length, 2); + h.ripples.dispose(); +}); + +test('contour lines are wavy, the same for a quake every time, and inside the disc', () => { + const h = harness(); + h.ripples.show(target); + h.advance(600); + // An identity-like projection: screen x, y follow ECEF y, z, so the + // distance from the projected epicentre measures each point's radius. + const frame = h.frame(); + const m = frame.viewProjectionMatrix; + m[0] = 0; + m[5] = 0; + m[4] = 1e-6; + m[9] = 1e-6; + const points = []; + const ctx = frame.ctx; + const record = (x, y) => points.at(-1).push([x, y]); + ctx.beginPath = () => points.push([]); + ctx.moveTo = record; + ctx.lineTo = record; + ctx.stroke = () => {}; + h.lanes[0].painter(frame); + const center = fromDegrees(target.lon, target.lat); + const cx = (center.y * 1e-6 * 0.5 + 0.5) * 800; + const cy = (0.5 - center.z * 1e-6 * 0.5) * 600; + const spread = (line) => { + const radii = line.map(([x, y]) => Math.hypot(x - cx, y - cy)); + return Math.max(...radii) / Math.min(...radii); + }; + // The disc's outer circle first (filled, not stroked), then each line. + assert.equal(points.length, EARTHQUAKE_RIPPLE_RINGS + 1); + points.shift(); + assert.ok( + points.every((line) => spread(line) > 1.05), + 'not circles: each line dents in and out', + ); + for (const line of points) { + const [first, last] = [line[0], line.at(-1)]; + assert.ok( + Math.hypot(first[0] - last[0], first[1] - last[1]) < 1e-6, + 'closed', + ); + } +}); + +test('the disc fades out to its outer circle; each wave fills with a fade', () => { + const h = harness(); + h.ripples.show(target); + h.advance(600); + // A projection where east and north span the screen: the disc is seen + // from above, so its ground frame can be filled. + const frame = h.frame(); + const m = frame.viewProjectionMatrix; + m[0] = 0; + m[5] = 0; + m[4] = 1e-6; + m[9] = 1e-6; + h.lanes[0].painter(frame); + assert.equal(h.fills.length, 1 + EARTHQUAKE_RIPPLE_RINGS); + const [disc, ...waves] = h.fills; + assert.equal(disc.lines, RIPPLE_RING_SEGMENTS, 'the whole outer circle'); + assert.deepEqual(disc.gradient.circles, [0, 0, 0, 0, 0, 1]); + assert.deepEqual( + disc.gradient.stops, + DISC_FADE.map(([offset, alpha]) => [offset, `rgba(255,0,0,${alpha})`]), + ); + assert.equal(disc.gradient.stops.at(-1)[1], 'rgba(255,0,0,0)', 'fades out'); + assert.ok(disc.transform, 'filled under the ground-to-screen transform'); + assert.equal(h.fills.length, waves.length + 1); + for (const wave of waves) { + const reach = wave.gradient.circles[5]; + assert.ok(reach > 0 && reach < 1, 'out to its own line'); + assert.equal(wave.gradient.stops[0][1], 'rgba(255,0,0,0)', 'clear inside'); + } + // The transforms were undone: nothing leaks into the labels' painting. + assert.equal(frame.ctx.saved, 0); + // Seen edge-on, the ground frame has no area: lines only, no fills. + h.fills.length = 0; + m[9] = 0; + m[5] = 0; + h.lanes[0].painter(frame); + assert.equal(h.fills.length, 0); +}); + +test('cssWithAlpha turns rgb into rgba stops', () => { + assert.equal(cssWithAlpha('rgb(255,165,0)')(0.25), 'rgba(255,165,0,0.25)'); + assert.equal(cssWithAlpha('rgba(1, 2, 3, 0.5)')(2), 'rgba(1,2,3,1)'); + assert.equal(cssWithAlpha('red')(0.3), 'red'); +}); + +test('the lines run a bounded time after a selection, then rest without frames', () => { + const h = harness(); + h.ripples.show(target); + const [lane] = h.lanes; + const window = RIPPLE_ACTIVE_CYCLES * EARTHQUAKE_RIPPLE_PERIOD_MS; + assert.ok(window <= 15_000, 'about a quarter of a minute at most'); + let frames = 0; + for (let t = 0; t < window * 3; t += 16) { + if (!h.frames.size) break; + lane.painter(h.frame()); + h.advance(16); + h.step(); + frames++; + } + assert.equal(h.frames.size, 0, 'no frame asked for once settled'); + assert.ok(frames <= Math.ceil(window / 16) + 2, `bounded: ${frames} frames`); + // At rest the lines hold still as readable contours. + h.strokes.length = 0; + lane.painter(h.frame()); + assert.equal(h.strokes.length, EARTHQUAKE_RIPPLE_RINGS); + assert.ok(h.strokes.every((stroke) => stroke.alpha === 0.7)); + // A parked camera repainting the overlay does not start them again. + lane.painter(h.frame()); + assert.equal(h.frames.size, 0); + // A new selection runs again. + h.ripples.show({ ...target, id: 'ak2' }); + assert.equal(h.frames.size, 1); + h.ripples.dispose(); +}); + +test('off screen the frames stop; back in view inside the window they resume', () => { + const h = harness(); + h.ripples.show(target); + const [lane] = h.lanes; + // Behind the globe. + lane.painter(h.frame(false)); + const paints = lane.paints; + h.step(); + assert.equal(h.frames.size, 0, 'stopped while out of sight'); + assert.equal(lane.paints, paints + 1, 'one last paint, then none'); + h.step(); + assert.equal(lane.paints, paints + 1); + // Panned away: the disc is far off the viewport. + h.ripples.show(target); + const away = h.frame(); + away.viewProjectionMatrix[12] = 50; + lane.painter(away); + h.step(); + assert.equal(h.frames.size, 0); + // The camera brings it back while the window lasts. + away.viewProjectionMatrix[12] = 0; + lane.painter(h.frame()); + assert.equal(h.frames.size, 1, 'resumed'); + h.ripples.dispose(); +}); + +test('turning reduced motion on mid-run stills the lines and stops the frames', () => { + const h = harness(); + h.ripples.show(target); + const [lane] = h.lanes; + lane.painter(h.frame()); + h.setReducedMotion(true); + h.step(); + assert.equal(h.frames.size, 0); + h.strokes.length = 0; + lane.painter(h.frame()); + assert.ok( + h.strokes.every((stroke) => stroke.alpha === 0.7), + 'still', + ); + // Turned off again within the window: the next paint runs them again. + h.setReducedMotion(false); + lane.painter(h.frame()); + assert.equal(h.frames.size, 1); + h.ripples.dispose(); +}); + +test('a refresh of the same quake does not run a settled selection again', () => { + const h = harness(); + h.ripples.show(target); + const [lane] = h.lanes; + h.advance(RIPPLE_ACTIVE_CYCLES * EARTHQUAKE_RIPPLE_PERIOD_MS + 1); + lane.painter(h.frame()); + h.step(); + assert.equal(h.frames.size, 0, 'settled'); + h.ripples.show({ ...target, radiusM: 40000 }, { restart: false }); + assert.equal(h.frames.size, 0, 'a refresh keeps it at rest'); + lane.painter(h.frame()); + assert.equal(h.frames.size, 0); + // A different quake, or a user's restart, runs again. + h.ripples.show({ ...target, id: 'other' }, { restart: false }); + assert.equal(h.frames.size, 1); + h.ripples.dispose(); +}); diff --git a/src/app/layers/earthquakes.js b/src/app/layers/earthquakes.js index ae6bc1b63a..dc56448d35 100644 --- a/src/app/layers/earthquakes.js +++ b/src/app/layers/earthquakes.js @@ -1,6 +1,46 @@ import { createEarthquakesLayer } from '../../layers/earthquakes/index.js'; import { overlayHost } from './overlayHost.js'; -/** Wire earthquake observations to the application overlay host. */ +import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; +import { inputFor } from '../../input/dispatcher.js'; +import * as picking from '../../data/pickRegistry.js'; +import * as context from '../../data/contextStore.js'; +import { isPointerFree } from '../../data/inputOwnership.js'; +import { requestWorldFocus } from '../../worldFocus.js'; +import { createEarthquakeRipples } from './earthquakeRipples.js'; +import { formatDate, formatNumber, t } from '../../i18n/index.js'; + +const EVENT_TIME = Object.freeze({ + day: 'numeric', + month: 'short', + year: 'numeric', + hour: '2-digit', + minute: '2-digit', + timeZone: 'UTC', + timeZoneName: 'short', +}); + +/** The clicked quake's card text, in the page's language. */ +export const earthquakeCardText = Object.freeze({ + t, + formatTime: (time) => formatDate(time, EVENT_TIME), + formatDepth: (km) => formatNumber(km, { maximumFractionDigits: 1 }), +}); + +/** + * Wire earthquake observations to the application overlay host, and its + * discs to the globe's clicks: a clicked quake shows its detail card. + */ export function createApplicationEarthquakes(options) { - return createEarthquakesLayer({ overlayHost, ...options }); + return createEarthquakesLayer({ + overlayHost: { ...overlayHost, hitTest: hitTestWorldOverlay }, + input: (viewer) => inputFor(viewer), + picking, + context, + pointer: { isPointerFree }, + openExternal: (url) => window.open(url, '_blank', 'noopener,noreferrer'), + focus: { requestWorldFocus }, + ripples: createEarthquakeRipples(), + text: earthquakeCardText, + ...options, + }); } diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json index 15b8414c54..246a9d36fc 100644 --- a/src/i18n/locales/ar.json +++ b/src/i18n/locales/ar.json @@ -647,6 +647,16 @@ "UNAVAILABLE": "غير متاح", "Live Flights": "تتبّع الرحلات المباشر", "Earthquakes (24h)": "الزلازل (24 ساعة)", + "earthquake|Minor": "طفيف", + "earthquake|Light": "خفيف", + "earthquake|Moderate": "معتدل", + "earthquake|Strong": "قوي", + "earthquake|Major": "كبير", + "earthquake|Great": "هائل", + "earthquake|Shallow": "ضحل", + "earthquake|Intermediate": "متوسط العمق", + "earthquake|Deep": "عميق", + "{km} km deep": "على عمق {km} كم", "No selected data layers": "لا توجد طبقات بيانات محددة", "Cleared {count} data layers": { "zero": "لم تُمسح أي طبقة بيانات ({count})", @@ -2154,6 +2164,7 @@ "Exit cockpit to fly to a target": "اخرج من القمرة للانتقال إلى هدف", "Exit cockpit to fly to a vessel": "اخرج من القمرة للانتقال إلى سفينة", "Exit cockpit to fly to a fire": "اخرج من القمرة للانتقال إلى حريق", + "Exit cockpit to fly to an earthquake": "اخرج من القمرة للانتقال إلى زلزال", "Exit cockpit to fly to a route": "اخرج من القمرة للانتقال إلى مسار", "Exit cockpit to fly to a file": "اخرج من القمرة للانتقال إلى ملف", "Exit cockpit to fly to a scene": "اخرج من القمرة للانتقال إلى مشهد", diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json index 3d1caeab42..d7900f7789 100644 --- a/src/i18n/locales/de.json +++ b/src/i18n/locales/de.json @@ -634,6 +634,16 @@ "Live Flights": "Live-Flüge", "Military Flights": "Militärflüge", "Earthquakes (24h)": "Erdbeben (24 h)", + "earthquake|Minor": "Schwach", + "earthquake|Light": "Leicht", + "earthquake|Moderate": "Mittel", + "earthquake|Strong": "Stark", + "earthquake|Major": "Schwer", + "earthquake|Great": "Gewaltig", + "earthquake|Shallow": "Flach", + "earthquake|Intermediate": "Mitteltief", + "earthquake|Deep": "Tief", + "{km} km deep": "{km} km tief", "Satellites": "Satelliten", "Place names": "Ortsnamen", "Space Missions (30d)": "Raummissionen (30 T)", @@ -2058,6 +2068,7 @@ "Exit cockpit to fly to a target": "Cockpit verlassen, um zu einem Ziel zu fliegen", "Exit cockpit to fly to a vessel": "Cockpit verlassen, um zu einem Schiff zu fliegen", "Exit cockpit to fly to a fire": "Cockpit verlassen, um zu einem Brand zu fliegen", + "Exit cockpit to fly to an earthquake": "Cockpit verlassen, um zu einem Erdbeben zu fliegen", "Exit cockpit to fly to a route": "Cockpit verlassen, um zu einer Route zu fliegen", "Exit cockpit to fly to a file": "Cockpit verlassen, um zu einer Datei zu fliegen", "Exit cockpit to fly to a scene": "Cockpit verlassen, um zu einer Szene zu fliegen", diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json index 729e19c280..124e4288cf 100644 --- a/src/i18n/locales/es.json +++ b/src/i18n/locales/es.json @@ -526,6 +526,16 @@ "UNAVAILABLE": "NO DISPONIBLE", "Live Flights": "Vuelos en vivo", "Earthquakes (24h)": "Terremotos (24 h)", + "earthquake|Minor": "Menor", + "earthquake|Light": "Ligero", + "earthquake|Moderate": "Moderado", + "earthquake|Strong": "Fuerte", + "earthquake|Major": "Mayor", + "earthquake|Great": "Gran", + "earthquake|Shallow": "Superficial", + "earthquake|Intermediate": "Intermedio", + "earthquake|Deep": "Profundo", + "{km} km deep": "{km} km de profundidad", "No selected data layers": "No hay capas de datos seleccionadas", "Cleared {count} data layers": { "one": "Se limpió {count} capa de datos", @@ -2599,6 +2609,7 @@ "Exit cockpit to fly to a target": "Sal de la cabina para volar a un objetivo", "Exit cockpit to fly to a vessel": "Sal de la cabina para volar a un buque", "Exit cockpit to fly to a fire": "Sal de la cabina para volar a un incendio", + "Exit cockpit to fly to an earthquake": "Sal de la cabina para volar a un terremoto", "Exit cockpit to fly to a route": "Sal de la cabina para volar a una ruta", "Exit cockpit to fly to a file": "Sal de la cabina para volar a un archivo", "Exit cockpit to fly to a scene": "Sal de la cabina para volar a una escena", diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json index 8e0ce68982..0edb2993d9 100644 --- a/src/i18n/locales/fr.json +++ b/src/i18n/locales/fr.json @@ -1479,6 +1479,7 @@ "Exit cockpit to fly to a target": "Quittez le cockpit pour rejoindre une cible", "Exit cockpit to fly to a vessel": "Quittez le cockpit pour rejoindre un navire", "Exit cockpit to fly to a fire": "Quittez le cockpit pour rejoindre un incendie", + "Exit cockpit to fly to an earthquake": "Quittez le cockpit pour rejoindre un séisme", "Exit cockpit to fly to a route": "Quittez le cockpit pour rejoindre un itinéraire", "Exit cockpit to fly to a file": "Quittez le cockpit pour rejoindre un fichier", "Exit cockpit to fly to a scene": "Quittez le cockpit pour rejoindre une scène", @@ -1937,6 +1938,16 @@ "Live Flights": "Vols en direct", "Military Flights": "Vols militaires", "Earthquakes (24h)": "Séismes (24 h)", + "earthquake|Minor": "Mineur", + "earthquake|Light": "Léger", + "earthquake|Moderate": "Modéré", + "earthquake|Strong": "Fort", + "earthquake|Major": "Majeur", + "earthquake|Great": "Exceptionnel", + "earthquake|Shallow": "Superficiel", + "earthquake|Intermediate": "Intermédiaire", + "earthquake|Deep": "Profond", + "{km} km deep": "{km} km de profondeur", "Satellites": "Satellites", "Place names": "Noms de lieux", "Space Missions (30d)": "Missions spatiales (30 j)", diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json index a7b5f29e03..3f8afe847f 100644 --- a/src/i18n/locales/he.json +++ b/src/i18n/locales/he.json @@ -1373,6 +1373,7 @@ "Exit cockpit to fly to a target": "צא מתא הטייס כדי לטוס אל מטרה", "Exit cockpit to fly to a vessel": "צא מתא הטייס כדי לטוס אל אונייה", "Exit cockpit to fly to a fire": "צא מתא הטייס כדי לטוס אל שריפה", + "Exit cockpit to fly to an earthquake": "צא מתא הטייס כדי לטוס אל רעידת אדמה", "Exit cockpit to fly to a sighting": "צא מתא הטייס כדי לטוס אל תצפית", "Exit cockpit to fly to a sighting area": "צא מתא הטייס כדי לטוס אל אזור תצפית", "Exit cockpit to fly to a route": "צא מתא הטייס כדי לטוס אל מסלול", @@ -1789,6 +1790,16 @@ "Live Flights": "טיסות חיות", "Military Flights": "טיסות צבאיות", "Earthquakes (24h)": "רעידות אדמה (24 שע׳)", + "earthquake|Minor": "קל מאוד", + "earthquake|Light": "קל", + "earthquake|Moderate": "בינוני", + "earthquake|Strong": "חזק", + "earthquake|Major": "חזק מאוד", + "earthquake|Great": "עצום", + "earthquake|Shallow": "רדוד", + "earthquake|Intermediate": "עומק בינוני", + "earthquake|Deep": "עמוק", + "{km} km deep": "בעומק {km} ק״מ", "Satellites": "לוויינים", "Space Missions (30d)": "משימות חלל (30 יום)", "Street Traffic": "תנועה ברחובות", diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json index 00338746f1..a94460c494 100644 --- a/src/i18n/locales/it.json +++ b/src/i18n/locales/it.json @@ -1479,6 +1479,7 @@ "Exit cockpit to fly to a target": "Esci dal cockpit per volare a un obiettivo", "Exit cockpit to fly to a vessel": "Esci dal cockpit per volare a una nave", "Exit cockpit to fly to a fire": "Esci dal cockpit per volare a un incendio", + "Exit cockpit to fly to an earthquake": "Esci dal cockpit per volare a un terremoto", "Exit cockpit to fly to a route": "Esci dal cockpit per volare a un percorso", "Exit cockpit to fly to a file": "Esci dal cockpit per volare a un file", "Exit cockpit to fly to a scene": "Esci dal cockpit per volare a una scena", @@ -1937,6 +1938,16 @@ "Live Flights": "Voli live", "Military Flights": "Voli militari", "Earthquakes (24h)": "Terremoti (24 h)", + "earthquake|Minor": "Minore", + "earthquake|Light": "Leggero", + "earthquake|Moderate": "Moderato", + "earthquake|Strong": "Forte", + "earthquake|Major": "Maggiore", + "earthquake|Great": "Grande", + "earthquake|Shallow": "Superficiale", + "earthquake|Intermediate": "Intermedio", + "earthquake|Deep": "Profondo", + "{km} km deep": "{km} km di profondità", "Satellites": "Satelliti", "Place names": "Nomi dei luoghi", "Space Missions (30d)": "Missioni spaziali (30 g)", diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json index 4dfdd5f213..05e31a9414 100644 --- a/src/i18n/locales/ja.json +++ b/src/i18n/locales/ja.json @@ -1441,6 +1441,7 @@ "Exit cockpit to fly to a target": "ターゲットへ移動するにはコックピットを終了してください", "Exit cockpit to fly to a vessel": "船舶へ移動するにはコックピットを終了してください", "Exit cockpit to fly to a fire": "火災へ移動するにはコックピットを終了してください", + "Exit cockpit to fly to an earthquake": "地震へ移動するにはコックピットを終了してください", "Exit cockpit to fly to a route": "ルートへ移動するにはコックピットを終了してください", "Exit cockpit to fly to a file": "ファイルの位置へ移動するにはコックピットを終了してください", "Exit cockpit to fly to a scene": "シーンへ移動するにはコックピットを終了してください", @@ -1869,6 +1870,16 @@ "Live Flights": "ライブフライト", "Military Flights": "軍用機", "Earthquakes (24h)": "地震(24時間)", + "earthquake|Minor": "微小", + "earthquake|Light": "軽微", + "earthquake|Moderate": "中規模", + "earthquake|Strong": "強い", + "earthquake|Major": "大規模", + "earthquake|Great": "巨大", + "earthquake|Shallow": "浅発", + "earthquake|Intermediate": "やや深発", + "earthquake|Deep": "深発", + "{km} km deep": "深さ {km} km", "Satellites": "衛星", "Place names": "地名", "Space Missions (30d)": "宇宙ミッション(30日)", diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json index ae3ec81c4f..79e2b34045 100644 --- a/src/i18n/locales/pt.json +++ b/src/i18n/locales/pt.json @@ -1479,6 +1479,7 @@ "Exit cockpit to fly to a target": "Saia da cabine para voar até um alvo", "Exit cockpit to fly to a vessel": "Saia da cabine para voar até uma embarcação", "Exit cockpit to fly to a fire": "Saia da cabine para voar até um incêndio", + "Exit cockpit to fly to an earthquake": "Saia da cabine para voar até um terremoto", "Exit cockpit to fly to a route": "Saia da cabine para voar até uma rota", "Exit cockpit to fly to a file": "Saia da cabine para voar até um arquivo", "Exit cockpit to fly to a scene": "Saia da cabine para voar até uma cena", @@ -1937,6 +1938,16 @@ "Live Flights": "Voos ao vivo", "Military Flights": "Voos militares", "Earthquakes (24h)": "Terremotos (24 h)", + "earthquake|Minor": "Menor", + "earthquake|Light": "Leve", + "earthquake|Moderate": "Moderado", + "earthquake|Strong": "Forte", + "earthquake|Major": "Maior", + "earthquake|Great": "Grande", + "earthquake|Shallow": "Raso", + "earthquake|Intermediate": "Intermediário", + "earthquake|Deep": "Profundo", + "{km} km deep": "{km} km de profundidade", "Satellites": "Satélites", "Place names": "Nomes de lugares", "Space Missions (30d)": "Missões espaciais (30 d)", diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json index 36c3a20571..9261174229 100644 --- a/src/i18n/locales/ru.json +++ b/src/i18n/locales/ru.json @@ -631,6 +631,16 @@ "Live Flights": "Рейсы онлайн", "Military Flights": "Военные рейсы", "Earthquakes (24h)": "Землетрясения (24 ч)", + "earthquake|Minor": "Слабое", + "earthquake|Light": "Лёгкое", + "earthquake|Moderate": "Умеренное", + "earthquake|Strong": "Сильное", + "earthquake|Major": "Мощное", + "earthquake|Great": "Катастрофическое", + "earthquake|Shallow": "Мелкофокусное", + "earthquake|Intermediate": "Среднефокусное", + "earthquake|Deep": "Глубокофокусное", + "{km} km deep": "глубина {km} км", "Satellites": "Спутники", "Place names": "Названия мест", "Space Missions (30d)": "Космические миссии (30 дн.)", @@ -2645,6 +2655,7 @@ "Exit cockpit to fly to a target": "Выйдите из кабины, чтобы перелететь к цели", "Exit cockpit to fly to a vessel": "Выйдите из кабины, чтобы перелететь к судну", "Exit cockpit to fly to a fire": "Выйдите из кабины, чтобы перелететь к пожару", + "Exit cockpit to fly to an earthquake": "Выйдите из кабины, чтобы перелететь к землетрясению", "Exit cockpit to fly to a route": "Выйдите из кабины, чтобы перелететь к маршруту", "Exit cockpit to fly to a file": "Выйдите из кабины, чтобы перелететь к файлу", "Exit cockpit to fly to a scene": "Выйдите из кабины, чтобы перелететь к сцене", diff --git a/src/i18n/locales/sv.json b/src/i18n/locales/sv.json index 60ad8724ec..f7d6f81964 100644 --- a/src/i18n/locales/sv.json +++ b/src/i18n/locales/sv.json @@ -591,6 +591,16 @@ "Live Flights": "Liveflyg", "Military Flights": "Militärflyg", "Earthquakes (24h)": "Jordbävningar (24 h)", + "earthquake|Minor": "Mindre", + "earthquake|Light": "Lätt", + "earthquake|Moderate": "Måttlig", + "earthquake|Strong": "Kraftig", + "earthquake|Major": "Stor", + "earthquake|Great": "Mycket stor", + "earthquake|Shallow": "Grund", + "earthquake|Intermediate": "Medeldjup", + "earthquake|Deep": "Djup", + "{km} km deep": "{km} km djup", "Satellites": "Satelliter", "Space Missions (30d)": "Rymduppdrag (30 d)", "Street Traffic": "Gatutrafik", @@ -1980,6 +1990,7 @@ "Exit cockpit to fly to a target": "Lämna cockpiten för att flyga till ett mål", "Exit cockpit to fly to a vessel": "Lämna cockpiten för att flyga till ett fartyg", "Exit cockpit to fly to a fire": "Lämna cockpiten för att flyga till en brand", + "Exit cockpit to fly to an earthquake": "Lämna cockpiten för att flyga till en jordbävning", "Exit cockpit to fly to a route": "Lämna cockpiten för att flyga till en rutt", "Exit cockpit to fly to a file": "Lämna cockpiten för att flyga till en fil", "Exit cockpit to fly to a scene": "Lämna cockpiten för att flyga till en scen", diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json index 3231f3322a..8e6d2bfaf3 100644 --- a/src/i18n/locales/uk.json +++ b/src/i18n/locales/uk.json @@ -1497,6 +1497,7 @@ "Exit cockpit to fly to a target": "Вийдіть із кабіни, щоб перелетіти до цілі", "Exit cockpit to fly to a vessel": "Вийдіть із кабіни, щоб перелетіти до судна", "Exit cockpit to fly to a fire": "Вийдіть із кабіни, щоб перелетіти до пожежі", + "Exit cockpit to fly to an earthquake": "Вийдіть із кабіни, щоб перелетіти до землетрусу", "Exit cockpit to fly to a route": "Вийдіть із кабіни, щоб перелетіти до маршруту", "Exit cockpit to fly to a file": "Вийдіть із кабіни, щоб перелетіти до файлу", "Exit cockpit to fly to a scene": "Вийдіть із кабіни, щоб перелетіти до сцени", @@ -1970,6 +1971,16 @@ "Live Flights": "Рейси онлайн", "Military Flights": "Військові рейси", "Earthquakes (24h)": "Землетруси (24 год)", + "earthquake|Minor": "Слабкий", + "earthquake|Light": "Легкий", + "earthquake|Moderate": "Помірний", + "earthquake|Strong": "Сильний", + "earthquake|Major": "Потужний", + "earthquake|Great": "Катастрофічний", + "earthquake|Shallow": "Мілкофокусний", + "earthquake|Intermediate": "Середньофокусний", + "earthquake|Deep": "Глибокофокусний", + "{km} km deep": "глибина {km} км", "Satellites": "Супутники", "Place names": "Назви місць", "Space Missions (30d)": "Космічні місії (30 дн)", diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json index 1851c62306..8ea38dc97d 100644 --- a/src/i18n/locales/zh-CN.json +++ b/src/i18n/locales/zh-CN.json @@ -1415,6 +1415,7 @@ "Exit cockpit to fly to a target": "请先退出座舱,再飞往目标", "Exit cockpit to fly to a vessel": "请先退出座舱,再飞往船舶", "Exit cockpit to fly to a fire": "请先退出座舱,再飞往火点", + "Exit cockpit to fly to an earthquake": "请先退出座舱,再飞往地震", "Exit cockpit to fly to a route": "请先退出座舱,再飞往路线", "Exit cockpit to fly to a file": "请先退出座舱,再飞往文件位置", "Exit cockpit to fly to a scene": "请先退出座舱,再飞往场景", @@ -1844,6 +1845,16 @@ "Live Flights": "实时航班", "Military Flights": "军用航班", "Earthquakes (24h)": "地震(24 小时)", + "earthquake|Minor": "微弱", + "earthquake|Light": "轻微", + "earthquake|Moderate": "中等", + "earthquake|Strong": "强烈", + "earthquake|Major": "重大", + "earthquake|Great": "巨大", + "earthquake|Shallow": "浅源", + "earthquake|Intermediate": "中源", + "earthquake|Deep": "深源", + "{km} km deep": "震源深度 {km} km", "Satellites": "卫星", "Place names": "地名", "Space Missions (30d)": "太空任务(30 天)", diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json index 88e759c66e..81999dbadb 100644 --- a/src/i18n/locales/zh-Hant.json +++ b/src/i18n/locales/zh-Hant.json @@ -1410,6 +1410,7 @@ "Exit cockpit to fly to a target": "請先退出座艙,再飛往目標", "Exit cockpit to fly to a vessel": "請先退出座艙,再飛往船舶", "Exit cockpit to fly to a fire": "請先退出座艙,再飛往火點", + "Exit cockpit to fly to an earthquake": "請先退出座艙,再飛往地震", "Exit cockpit to fly to a route": "請先退出座艙,再飛往路線", "Exit cockpit to fly to a file": "請先退出座艙,再飛往文件位置", "Exit cockpit to fly to a scene": "請先退出座艙,再飛往場景", @@ -1836,6 +1837,16 @@ "Live Flights": "實時航班", "Military Flights": "軍用航班", "Earthquakes (24h)": "地震(24 小時)", + "earthquake|Minor": "微弱", + "earthquake|Light": "輕微", + "earthquake|Moderate": "中等", + "earthquake|Strong": "強烈", + "earthquake|Major": "重大", + "earthquake|Great": "巨大", + "earthquake|Shallow": "淺源", + "earthquake|Intermediate": "中源", + "earthquake|Deep": "深源", + "{km} km deep": "震源深度 {km} km", "Satellites": "衛星", "Place names": "地名", "Space Missions (30d)": "太空任務(30 天)", diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 90d70e9a90..37cd2e8cae 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -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; diff --git a/src/layers/earthquakes/model.js b/src/layers/earthquakes/model.js index 25570e7243..228758c011 100644 --- a/src/layers/earthquakes/model.js +++ b/src/layers/earthquakes/model.js @@ -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} 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, diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs new file mode 100644 index 0000000000..568d6cc4e1 --- /dev/null +++ b/src/layers/earthquakes/selection.test.mjs @@ -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 · {"context":"earthquake"}'); + assert.deepEqual(card.details, [ + '■□□□□□ {"context":"earthquake"} · <{km} km deep>{"km":"~112.4"}', + 'far away', + 'TIME', + '{"value":"USGS"}', + '{}', + ]); + 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(); + } +}); diff --git a/src/navigationPolicy.js b/src/navigationPolicy.js index d9e0e1757d..077cfb8d45 100644 --- a/src/navigationPolicy.js +++ b/src/navigationPolicy.js @@ -24,6 +24,7 @@ const COCKPIT_REFUSALS = Object.freeze({ target: msg('Exit cockpit to fly to a target'), vessel: msg('Exit cockpit to fly to a vessel'), fire: msg('Exit cockpit to fly to a fire'), + earthquake: msg('Exit cockpit to fly to an earthquake'), sighting: msg('Exit cockpit to fly to a sighting'), 'sighting-area': msg('Exit cockpit to fly to a sighting area'), train: msg('Exit cockpit to fly to a train'), diff --git a/src/worldFocus.js b/src/worldFocus.js index af50b2f30b..cf9e2fb90f 100644 --- a/src/worldFocus.js +++ b/src/worldFocus.js @@ -18,6 +18,9 @@ export const WORLD_FOCUS_FRAMING = Object.freeze({ // A stopped train's one fly-to, and the frame a moving train is followed // in (src/layers/rail/follow.js): the train and the track either side. train: Object.freeze({ radiusM: 200, rangeM: 2500, pitchDeg: -35 }), + // A clicked quake's magnitude label: its disc (2^M km across, so about + // 11 km at M2.5 and 128 km at M6) and the ground around it. + earthquake: Object.freeze({ radiusM: 20000, rangeM: 220000, pitchDeg: -45 }), 'sighting-area': Object.freeze({ radiusM: 11000, rangeM: 60000, diff --git a/src/worldFocus.test.mjs b/src/worldFocus.test.mjs index 2f90c5b6f9..8512a969d4 100644 --- a/src/worldFocus.test.mjs +++ b/src/worldFocus.test.mjs @@ -209,6 +209,7 @@ test('fires frame wider than vessels — a fire is read by its surroundings', () test('every framing is a real oblique standoff, not a nadir or an inside-out sphere', () => { const kinds = Object.keys(WORLD_FOCUS_FRAMING); assert.deepEqual(kinds.sort(), [ + 'earthquake', 'fire', 'sighting', 'sighting-area', @@ -232,8 +233,10 @@ test('every framing is a real oblique standoff, not a nadir or an inside-out sph framing.rangeM > framing.radiusM, `${kind}: range ${framing.rangeM} must stand off outside radius ${framing.radiusM}`, ); - // An obscured sighting frames its entire 0.2° privacy cell. - const maximumRange = kind === 'sighting-area' ? 60000 : 10000; + // An obscured sighting frames its entire 0.2° privacy cell, and a quake + // its disc, up to 128 km across at M6. + const maximumRange = + { 'sighting-area': 60000, earthquake: 250000 }[kind] ?? 10000; assert.ok( framing.rangeM <= maximumRange, `${kind}: range must fit its surface extent, got ${framing.rangeM}`, From 0a8899d4393a821a75cb723e4dedcf06df937e93 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 19:47:06 +0530 Subject: [PATCH 02/60] test(camera): compare recorded camera traces within platform roundoff The camera golden test compared the recorded traces byte for byte, so it failed on arm64, where trigonometry differs from the committed traces in the last bits (at most 2.1e-9 m on a height, 33 of 1,530 numbers). Compare structure, keys, array lengths, counters and the viewport exactly, and other numbers within 1e-8 m for positions and heights and 1e-14 otherwise; a self-test rejects larger errors, NaN, null, strings and missing or extra keys. The pose test compares pitch by its sine within 1e-12, as the conformance suite does, and checks the canonical range. The golden file and production camera code are unchanged. --- src/render/cesium/cameraGoldens.test.mjs | 73 +++++++++++++++++++++--- src/render/cesium/cameraPort.test.mjs | 11 +++- 2 files changed, 75 insertions(+), 9 deletions(-) diff --git a/src/render/cesium/cameraGoldens.test.mjs b/src/render/cesium/cameraGoldens.test.mjs index 774b0a0114..91ca593516 100644 --- a/src/render/cesium/cameraGoldens.test.mjs +++ b/src/render/cesium/cameraGoldens.test.mjs @@ -2,15 +2,72 @@ import { test } from 'node:test'; import assert from 'node:assert/strict'; import { readFileSync } from 'node:fs'; import { recordCameraGoldens } from './cameraGoldens.js'; +import { near } from '../conformance/expect.js'; + +// The recorder is deterministic, but platforms can differ in the last bits +// of trigonometric arithmetic. Keep structure and discrete values exact. +function compareTrace(actual, expected, path = []) { + const label = path.join('.'); + if (typeof expected === 'number') { + const key = path.at(-1); + if (['step', 'frames', 'count'].includes(key) || path[0] === 'viewport') { + assert.equal(actual, expected, label); + return; + } + const metres = + path.at(-2) === 'position' || + key === 'height' || + (path.at(-2) === 'view' && Number(key) >= 12 && Number(key) <= 14); + near(actual, expected, metres ? 1e-8 : 1e-14, label); + return; + } + if (expected !== null && typeof expected === 'object') { + assert.ok(actual !== null && typeof actual === 'object', label); + assert.equal(Array.isArray(actual), Array.isArray(expected), label); + assert.deepEqual(Object.keys(actual), Object.keys(expected), label); + if (Array.isArray(expected)) + assert.equal(actual.length, expected.length, label); + for (const key of Object.keys(expected)) + compareTrace(actual[key], expected[key], [...path, key]); + return; + } + assert.equal(actual, expected, label); +} test('the committed camera traces are what the installed Cesium records', async () => { - const committed = readFileSync( - new URL('../conformance/goldens/camera.json', import.meta.url), - 'utf8', - ); - const recorded = `${JSON.stringify(await recordCameraGoldens(), null, 2)}\n`; - assert.ok( - recorded === committed, - 'goldens/camera.json is out of date: run node scripts/record-camera-goldens.mjs and review the diff', + const committed = JSON.parse( + readFileSync( + new URL('../conformance/goldens/camera.json', import.meta.url), + 'utf8', + ), ); + compareTrace(await recordCameraGoldens(), committed); +}); + +test('trace comparison tolerates only numeric roundoff, preserving structure and counters', () => { + const expected = { + position: { x: 1000 }, + pitch: 0.3, + frames: 2, + values: [1], + label: 'pose', + }; + compareTrace( + { ...expected, position: { x: 1000 + 2e-9 }, pitch: 0.3 + 1e-16 }, + expected, + ); + for (const actual of [ + { ...expected, extra: true }, + { ...expected, values: [] }, + { ...expected, position: { x: 1000 + 2e-8 } }, + { ...expected, pitch: 0.3 + 2e-14 }, + { ...expected, frames: 2 + 1e-15 }, + { ...expected, pitch: NaN }, + { ...expected, pitch: null }, + { ...expected, pitch: '0.3' }, + { ...expected, label: 'other' }, + ]) + assert.throws(() => compareTrace(actual, expected)); + const { label, ...missing } = expected; + assert.throws(() => compareTrace(missing, expected)); }); diff --git a/src/render/cesium/cameraPort.test.mjs b/src/render/cesium/cameraPort.test.mjs index 967ff1f761..9d81e928fa 100644 --- a/src/render/cesium/cameraPort.test.mjs +++ b/src/render/cesium/cameraPort.test.mjs @@ -416,7 +416,16 @@ test('a pose measures heading, pitch and roll as Cesium does, and leaves the cam const pitch = camera.pitch; const roll = camera.roll; assert.equal(pose.heading, heading, `heading ${k}`); - assert.ok(Math.abs(pose.pitch - pitch) < 1e-12, `pitch ${k}`); + assert.ok( + pose.pitch >= -Math.PI / 2 && pose.pitch <= Math.PI / 2, + `canonical pitch ${k}`, + ); + // Near vertical, acos amplifies last-bit direction differences. Match + // the conformance suite's well-conditioned pitch comparison. + assert.ok( + Math.abs(Math.sin(pose.pitch) - Math.sin(pitch)) < 1e-12, + `pitch ${k}`, + ); const turn = Math.abs(pose.roll - roll); assert.ok(Math.min(turn, 2 * Math.PI - turn) < 1e-12, `roll ${k}`); } From 9f698779be6644c2b626c30290d5542bf3ae04f7 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 19:47:15 +0530 Subject: [PATCH 03/60] test(track): follow the shared 3D toggle and draw-port trails The tracked aircraft now takes its model under the same 3D toggle as the fleet, and trails are drawn through draw-port line sets rather than viewer entities, so the tracking regression read a contract that no longer exists. Arm the toggle in the model scenarios and observe the trail head through the draw port. A trail check with too few frames now fails instead of skipping, and a missing tracked model before the exit check is an error. --- scripts/track-regression.mjs | 88 +++++++++++++++++++++++------------- 1 file changed, 57 insertions(+), 31 deletions(-) diff --git a/scripts/track-regression.mjs b/scripts/track-regression.mjs index 4e163cd398..3e8e6f62d1 100644 --- a/scripts/track-regression.mjs +++ b/scripts/track-regression.mjs @@ -1619,19 +1619,48 @@ async function main() { // The fixture planes repeat one position, so the icon holds and draws no // head. Fly the tracked one east for this check; the display runs 30 s // behind, so give it time to reach the moving reports. - await evalPage((icao) => { + await evalPage(async (icao) => { + const { rendererOf } = await import(`${window.__gevQaSourceBase || '/src'}/render/rendererOf.js`); + const app = window.__godsEyeView; + const fl = app.dataManager.layers.get('flights').module; + // Observe this selection's actual draw-port submissions: trails no + // longer live in viewer.entities. Disabling destroys the reused trail + // set, so this selection creates one the probe can identify. + await app.dataManager.setEnabled('flights', false); + const draw = rendererOf(app.viewer).draw; + const createLines = draw.lines; + let head = null; + let trail = null; + draw.lines = function (spec) { + const set = createLines.call(this, spec); + if (!spec.id.startsWith('trail:')) return set; + draw.lines = createLines; + trail = set; + const upsert = set.upsert; + set.upsert = function (items) { + const result = upsert.call(this, items); + for (const item of items) + if (/^gev-trail:\d+:head$/.test(item.id)) head = item; + return result; + }; + const clear = set.clear; + set.clear = function () { head = null; return clear.call(this); }; + const dispose = set.dispose; + set.dispose = function () { head = null; trail = null; return dispose.call(this); }; + return set; + }; + window.__qaTrailHead = () => trail?.show && head?.show !== false ? head?.positions : null; + window.__qaRestoreTrailProbe = () => { draw.lines = createLines; }; + await app.dataManager.setEnabled('flights', true); + if (!fl.trackById(icao)) throw new Error('trail fixture could not reselect its aircraft'); const f = window.__SYNTH.flights.find((p) => p.icao === icao); f.moveFromMs = Date.now(); }, trackedIcao); await sleep(55_000); const headSamples = await sampleFrames(page, 40, (icao) => { - const viewer = window.__godsEyeView.viewer; const fl = window.__godsEyeView.dataManager.layers.get('flights').module; - const ent = viewer.trackedEntity; - const time = viewer.clock.currentTime; - const head = viewer.entities.values.find((e) => String(e.id).startsWith('gev-trail:fl-head-')); - const line = head?.polyline?.positions?.getValue(time); - const drawn = ent?.position?.getValue(time); + const line = window.__qaTrailHead(); + const drawn = window.__qaFollowed()?.position?.(); if (!line?.length || !drawn) return null; const end = line[line.length - 1]; const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z); @@ -1677,10 +1706,8 @@ async function main() { for (let i = 0; i < 8; i++) { await sleep(600); betweenFrames.push(await evalPage((icao) => { - const viewer = window.__godsEyeView.viewer; - const head = viewer.entities.values.find((e) => String(e.id).startsWith('gev-trail:fl-head-')); - const line = head?.polyline?.positions?.getValue(viewer.clock.currentTime); - const drawn = viewer.trackedEntity?.position?.getValue(viewer.clock.currentTime); + const line = window.__qaTrailHead(); + const drawn = window.__qaFollowed()?.position?.(); if (!line?.length || !drawn) return null; const end = line[line.length - 1]; return Math.hypot(end.x - drawn.x, end.y - drawn.y, end.z - drawn.z); @@ -1694,10 +1721,11 @@ async function main() { f.lon += (f.vel * (Date.now() - f.moveFromMs)) / 1000 / (111320 * Math.cos((f.lat * Math.PI) / 180)); delete f.moveFromMs; + window.__qaRestoreTrailProbe(); }, trackedIcao); const headUsable = headSamples.values.filter((v) => v != null); if (headUsable.length < 10) { - skip('trail head: ends at the drawn icon on every frame', + record('trail head: ends at the drawn icon on every frame', false, `only ${headUsable.length} frames with a drawn head (timedOut=${headSamples.timedOut})`); } else { const worst = Math.max(...headUsable.map((v) => v.end)); @@ -3661,6 +3689,9 @@ async function main() { } while (Date.now() < fleetClampDeadline && (!Number.isFinite(fleetH) || fleetH < seeded + 1)); if (!fl.trackById('aaa097')) return { error: 'trackById(aaa097) failed' }; + // The tracked contact obeys the same 3D toggle as the fleet. Arm it + // before testing the cold-ground gate and the warm model handoff. + fl.setParams({ models3d: true }); await window.__dfSettle(1500); // Read the tracked entity's rendered height plus the floor under it and // the sensor value the data APIs report, at whatever regime the camera @@ -3750,6 +3781,7 @@ async function main() { }; const trackedEntity = window.__qaFollowed(); const trackedModel = findOwnModel(); + if (!trackedModel) return { error: 'tracked model absent before exit' }; const achievedOut = await window.__dfZoomAbove(window.__dfRegime.exit + 5000); const zoomedOut = await window.__dfObserveTrackedExit({ scene: v.scene, trackedEntity, trackedModel, getTrackedModel: findOwnModel, @@ -3888,10 +3920,8 @@ async function main() { // the tracked billboard becomes the visual again. Gating the clamp on // model EXISTENCE put the burial straight back in exactly that state. // - // This scenario also pins the toggle contract itself. The DISPLAY-rail - // "3D" toggle stays OFF for the whole block on purpose: it governs the - // FLEET's draw-call budget only, and the tracked contact must still take - // its model on zoom without the operator arming anything. + // The tracked contact obeys the shared 3D toggle. Keep it enabled + // while zoom alone hands the visual between model and billboard. const dfRetained = await evalPage(async () => { const v = window.__godsEyeView.viewer; const Cesium = await import('/node_modules/cesium/Build/Cesium/index.js'); @@ -3904,13 +3934,13 @@ async function main() { // and there would otherwise hand an open skin to the seeded scenarios // that follow; closing an already-closed skin is inert. try { - // Toggle OFF throughout — the tracked model must not need it. - fl.setParams({ models3d: false }); - const toggleOff = fl.getParams().models3d === false; + // Arm the shared toggle so the zoom regime can retain a hidden model. + fl.setParams({ models3d: true }); + const toggleOn = fl.getParams().models3d === true; if (!fl.trackById('aaa097')) return { error: 'trackById(aaa097) failed' }; await window.__dfSettle(600); // Below the ENTER ceiling (trackById re-frames to the close follow - // range): the tracked model arrives on zoom alone, toggle still off. + // range): the tracked model arrives on zoom alone, 3D enabled. const belowH = await window.__dfZoomBelow(window.__dfRegime.enter - 20000); const withModel = await window.__dfAwaitTrackedModel('aaa097', 20000); // Same split as the regime scenario: a browser with no usable GLB @@ -3960,7 +3990,7 @@ async function main() { const ent2 = window.__qaFollowed()?.position?.(); const c2 = ent2 ? window.__dfCarto(ent2) : null; const out = { - toggleOff, + toggleOn, enter: window.__dfRegime.enter, exit: window.__dfRegime.exit, belowH, @@ -3995,23 +4025,19 @@ async function main() { record('display-floor/T7: while the tracked MODEL is the visual, the clamp stands aside', !dfRetained.error && dfRetained.modelsRenderingBelow > 0, dfRetained.error - || `${dfRetained.modelsRenderingBelow} aaa097 model(s) rendering at ${(dfRetained.belowH / 1000).toFixed(0)} km with the 3D toggle OFF; entity at ${Number(dfRetained.withModelH).toFixed(1)} m (ground-snap owns it)`); + || `${dfRetained.modelsRenderingBelow} aaa097 model(s) rendering at ${(dfRetained.belowH / 1000).toFixed(0)} km with the 3D toggle ON; entity at ${Number(dfRetained.withModelH).toFixed(1)} m (ground-snap owns it)`); - // The toggle contract after auto-3D (2026-08-20): the DISPLAY-rail "3D" - // switch owns the FLEET only. The tracked contact's model is default-on - // and decided purely by camera distance, so with the toggle OFF it is - // SHOWN below the enter ceiling and handed back above the exit ceiling — - // and handed back by HIDING, not destroying, which is the retained state - // the floor pin below depends on. - record('display-floor/regime: the 3D toggle governs the FLEET only — the tracked model follows the zoom', - !dfRetained.error && dfRetained.toggleOff === true + // With 3D enabled, zooming out hides rather than destroys the + // tracked model: the retained state the floor check depends on. + record('display-floor/regime: with 3D enabled the tracked model follows the zoom', + !dfRetained.error && dfRetained.toggleOn === true && dfRetained.modelsRenderingBelow > 0 && dfRetained.belowH < dfRetained.enter && dfRetained.shownModelsAbove === 0 && dfRetained.hiddenModelsAbove > 0 && dfRetained.aboveH > dfRetained.exit, dfRetained.error - || `toggle OFF throughout: at ${(dfRetained.belowH / 1000).toFixed(0)} km (< ${(dfRetained.enter / 1000).toFixed(0)} km enter) ${dfRetained.modelsRenderingBelow} aaa097 model(s) rendering; at ${(dfRetained.aboveH / 1000).toFixed(0)} km (> ${(dfRetained.exit / 1000).toFixed(1)} km exit) ${dfRetained.shownModelsAbove} shown / ${dfRetained.hiddenModelsAbove} retained-hidden`); + || `toggle ON throughout: at ${(dfRetained.belowH / 1000).toFixed(0)} km (< ${(dfRetained.enter / 1000).toFixed(0)} km enter) ${dfRetained.modelsRenderingBelow} aaa097 model(s) rendering; at ${(dfRetained.aboveH / 1000).toFixed(0)} km (> ${(dfRetained.exit / 1000).toFixed(1)} km exit) ${dfRetained.shownModelsAbove} shown / ${dfRetained.hiddenModelsAbove} retained-hidden`); record('display-floor: a retained-but-hidden tracked model does NOT suppress the floor', Number.isFinite(dfRetained.afterSeedH) From b2bc15e763d3aa3ce6aaea14f9be1353ea74459c Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 19:47:30 +0530 Subject: [PATCH 04/60] fix(earthquakes): keep quake discs out of pick ownership Registering quake discs as pick owners changed how other layers read a click anywhere over a quake: sibling layers yield to owned picks before their own card hit-tests and treat an owned pick as not empty space. A fire card drawn over a large quake could not be clicked and the quake beneath was selected, radio near-miss taps found nothing, and a followed aircraft kept its camera while the quake took the shared selection. Leave the discs unregistered, as drone airspace and fire perimeters do, so a disc reads as empty space to other layers. The quake handler finds its own discs by draw set, reads the click's resolved hit, and yields when another layer's card or label is the topmost overlay entry. Another layer's object under the quake card or a label takes the click before either is read, so a click on the card over an aircraft does not also open the USGS page. A feed refresh inside the contour window no longer asks for a frame while the disc is off screen. --- docs/CURRENT-STATE.md | 6 ++ src/app/layers/earthquakeRipples.js | 5 +- src/layers/earthquakes/index.js | 41 +++++--- src/layers/earthquakes/selection.test.mjs | 117 ++++++++++++++++++++-- 4 files changed, 144 insertions(+), 25 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 5a3af0a5b9..07f2e8f891 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1863,6 +1863,12 @@ painted with a gradient fading to the outer circle and wavy contour lines clicks, picking, context, focus, the opener, the painter and the translator by injection (`src/app/layers/earthquakes.js`); without input and picking it draws and takes no clicks, and its labels stay non-interactive. +Quake discs are deliberately not registered in the pick-ownership registry, +like drone airspace and fire perimeters: sibling layers read a disc as empty +space, so their cards, near-miss taps and deselection work over a quake as +before. When another layer's card or label is painted over a disc (a fire card +on a large quake), the quake handler yields to it rather than selecting the +quake beneath. Air quality (`./layers/air-quality`) draws its station discs as one renderer draw set of ground-clamped fills and reads the view through the camera port; it diff --git a/src/app/layers/earthquakeRipples.js b/src/app/layers/earthquakeRipples.js index 31f3557c44..c761eee0fe 100644 --- a/src/app/layers/earthquakeRipples.js +++ b/src/app/layers/earthquakeRipples.js @@ -361,7 +361,10 @@ export function createEarthquakeRipples({ }); lane.setActive(true); lane.requestPaint(); - if (running() && frameHandle === null) frameHandle = requestFrame(tick); + // A refresh while the disc is out of sight asks for no frame; a paint + // that finds it on screen again starts them (a restart sets onScreen). + if (running() && onScreen && frameHandle === null) + frameHandle = requestFrame(tick); } function hide() { diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 37cd2e8cae..cd4b0ca1c3 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -60,8 +60,7 @@ let instances = 0; * 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 {{resolvePickId: Function, isOwnedByOtherLayer: Function}} [options.picking] * @param {{registerEntityContext: Function, selectEntityContext: Function, * clearSelectedEntityContextForLayer: Function, * getContextStore: Function}} [options.context] Shared selection store. @@ -306,10 +305,12 @@ export function createEarthquakesLayer({ function installClickHandler() { if (!canSelect() || _clickHandler || !_viewer) return; - picking.registerPickOwner?.( - EARTHQUAKES_LAYER_ID, - (pickedId) => _enabled && eventOfPickId(pickedId) !== null, - ); + // Deliberately NOT registered in the pick-ownership registry, like drone + // airspace and fire perimeters: siblings yield to owned picks before + // their own card hit-tests and treat an owned pick as not empty space, + // so claiming these large discs would make their cards inert and their + // selections stick anywhere over a quake. Unowned, a disc reads as + // empty space to them; this handler finds its own discs by draw set. // A viewer with no renderer input bound takes no clicks. let clicks = null; try { @@ -321,6 +322,23 @@ export function createEarthquakesLayer({ _clickHandler = clicks.onClick((click) => { if (!_enabled || (pointer && !pointer.isPointerFree())) return; const at = click.screenPosition; + // Another layer's card or label painted on top (a fire's card over a + // quake disc) is that layer's click: the disc under it is background. + const topEntry = overlayHost.hitTest?.(at?.x, at?.y); + if ( + topEntry && + topEntry.sourceId !== EARTHQUAKE_CARD_SOURCE_ID && + topEntry.sourceId !== EARTHQUAKE_OVERLAY_SOURCE_ID + ) + return; + // Another layer's pick (an aircraft, a camera) is not this layer's, + // even under this layer's card or a magnitude label: that layer acts + // on the click itself, and this card stays. Checked before the card + // and the labels, as the fire layer does. + const hit = click.hit; + const pickId = picking.resolvePickId(hit); + if (pickId && picking.isOwnedByOtherLayer(EARTHQUAKES_LAYER_ID, pickId)) + return; const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID, }); @@ -328,14 +346,6 @@ export function createEarthquakesLayer({ 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, { @@ -345,7 +355,7 @@ export function createEarthquakesLayer({ selectAndFocus(labelHit.entryId); return; } - const event = pickedEvent(click.drawHit ?? click.topHit); + const event = pickedEvent(hit); if (event) { _selectedId = event.stableId; publishCard({ user: true }); @@ -373,7 +383,6 @@ export function createEarthquakesLayer({ function removeClickHandler() { _clickHandler?.(); _clickHandler = null; - picking?.unregisterPickOwner?.(EARTHQUAKES_LAYER_ID); } const layer = { diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index 568d6cc4e1..4a5e70412a 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -42,6 +42,8 @@ function harness(rows, { context = null, ripples = null } = {}) { const focused = []; // What the overlay hit test finds under the click, per source. const overlayHits = new Map(); + // Another layer's interactive entry painted on top, if any. + let foreignTop = null; const viewer = {}; const { draw } = bindFakeDraw(viewer); const layer = createEarthquakesLayer({ @@ -54,7 +56,15 @@ function harness(rows, { context = null, ripples = null } = {}) { 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 }) { + hitTest(_x, _y, { sourceId } = {}) { + // Unfiltered, as the host answers: another layer's entry on top + // first, else this layer's own. + if (!sourceId) + return ( + foreignTop ?? + this.hitTest(_x, _y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID }) ?? + this.hitTest(_x, _y, { sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID }) + ); const hit = overlayHits.get(sourceId); const painted = sourceId === EARTHQUAKE_CARD_SOURCE_ID ? cards.at(-1) : labels.at(-1); @@ -99,11 +109,12 @@ function harness(rows, { context = null, ripples = null } = {}) { snapshot = next; }, /** Click a quake's disc (by stable id), something else, or the map. */ - click(hit) { + click(hit, resolvedHit = hit) { for (const { callback } of live()) callback({ screenPosition: { x: 10, y: 10 }, topHit: hit, + hit: resolvedHit, drawHit: hit && !hit.surface ? hit : null, }); }, @@ -120,10 +131,16 @@ function harness(rows, { context = null, ripples = null } = {}) { 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 }); + /** Click another layer's card painted on top, with `hit` under it. */ + clickForeignCard(sourceId, entryId, hit) { + foreignTop = { sourceId, entryId }; this.click(hit); + foreignTop = null; + }, + /** Click an overlay entry with `hit` drawn under the same pixel. */ + clickOverlayWith(sourceId, entryId, hit, resolvedHit = hit) { + overlayHits.set(sourceId, { sourceId, entryId }); + this.click(hit, resolvedHit); overlayHits.delete(sourceId); }, lastCard: () => cards.at(-1), @@ -188,12 +205,15 @@ test('a quake with no USGS id gets a card with no link', async () => { h.layer.destroy(); }); -test("another layer's pick leaves the card; its own pick ids are claimed", async () => { +test("another layer's pick leaves the card; discs stay unowned, as area layers do", 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); + // Like drone airspace and fire perimeters, the discs are not registered: + // siblings read a disc as empty space, so their cards and deselection + // work over a quake (a fire card, a radio near-miss, a followed plane). + assert.equal(picking.findPickOwner('earthquake:ak1'), null); + assert.equal(picking.isOwnedByOtherLayer('firms', 'earthquake:ak1'), false); picking.registerPickOwner('test-other', (id) => id === 'plane-1'); try { h.clickDisc('ak1'); @@ -608,3 +628,84 @@ test("another layer's object over a magnitude label takes the click", async () = h.layer.destroy(); } }); + +test('a touch-expanded quake hit selects its disc without flying', async () => { + const h = harness([quake('ak1')]); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + h.click(null, { set: h.discs().spec.id, id: 'earthquake:ak1' }); + assert.equal(h.lastCard()?.[0]?.id, 'earthquake-card:ak1'); + assert.equal(h.focused.length, 0); + } finally { + h.layer.destroy(); + } +}); + +test('a touch-expanded sibling hit takes precedence over a quake label', async () => { + const h = harness([quake('ak1'), quake('ak2')]); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + h.clickDisc('ak1'); + picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); + h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', null, { + set: 'flights:1', + id: 'plane-9', + }); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1'); + assert.equal(h.focused.length, 0); + } finally { + picking.unregisterPickOwner('test-plane'); + h.layer.destroy(); + } +}); + +test("another layer's card over a quake disc takes the click, and the disc yields", async () => { + const h = harness([quake('ak1', { mag: 6 })]); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + // A fire's card painted over the disc: the disc is what the scene picks. + h.clickForeignCard('firms', 'fire:x', { + set: h.discs().spec.id, + id: 'earthquake:ak1', + }); + assert.equal(h.cards.length, 0, 'the quake is not selected'); + assert.equal(h.focused.length, 0); + // The same disc with nothing painted over it selects the quake. + h.clickDisc('ak1'); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1'); + } finally { + h.layer.destroy(); + } +}); + +test("another layer's object under the quake card takes the click", async () => { + const h = harness([quake('ak1')]); + picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + h.clickDisc('ak1'); + const card = h.lastCard()[0]; + // The card is painted over a plane: the flight layer acts on the click, + // so the card neither opens its link nor changes. + overlayHitCard(h, card.id, { set: 'flights:1', id: 'plane-9' }); + assert.deepEqual(h.opened, []); + assert.equal(h.lastCard()[0].id, card.id, 'the card stays'); + // Over open ground the card opens the USGS page. + h.clickCard(card.id); + assert.deepEqual(h.opened, [ + 'https://earthquake.usgs.gov/earthquakes/eventpage/ak1', + ]); + } finally { + picking.unregisterPickOwner('test-plane'); + h.layer.destroy(); + } +}); + +/** Click this layer's card with `hit` (another layer's object) under it. */ +function overlayHitCard(h, entryId, hit) { + h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, entryId, hit); +} From f6314884f7ebe03295d0a72f5f65555c042ffcfd Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 21:13:32 +0530 Subject: [PATCH 05/60] fix(overlays): keep painted hit rectangles until the next paint Every overlay change cleared the world overlay's hit rectangles at once, and only the next paint rebuilt them. When one click subscriber published its selection card, every later subscriber in the same click saw no overlay at all, so the outcome of a click depended on listener order: a card or label painted over another layer's item could lose to that item, or both acted. Hit rectangles now stay what is painted on screen until the next paint rebuilds them, so every subscriber reads the overlay the user clicked, and a paint that draws nothing clears them. --- src/overlays/worldOverlay.js | 11 ++++++----- src/overlays/worldOverlay.test.mjs | 19 +++++++++++++++++++ 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js index 39a3f626cc..bb0d2d33f1 100644 --- a/src/overlays/worldOverlay.js +++ b/src/overlays/worldOverlay.js @@ -884,7 +884,9 @@ function invalidateHost({ solve = true, layout = false } = {}) { if (layout) _occludersDirty = true; _canvasNeedsClear = true; _paintRectCount = 0; - _hitRectCount = 0; + // Hit rectangles stay what is painted on screen until the next paint + // rebuilds them: every click subscriber reads the same overlay, even after + // an earlier one republishes entries in that click (a selection card). _paintRectByKey.clear(); requestOverlayRender(); } @@ -2783,10 +2785,9 @@ function drawWorldOverlay() { resetFrameDiagnostics(); _solveDirty = false; if (_canvasNeedsClear || _detectionSurfaceNeedsClear) clearCanvas(); - if (_accessibilitySignature) { - _hitRectCount = 0; - syncAccessibleActions(); - } + // Nothing is painted now, so nothing can be hit. + _hitRectCount = 0; + if (_accessibilitySignature) syncAccessibleActions(); syncPaintVisibility(false); return; } diff --git a/src/overlays/worldOverlay.test.mjs b/src/overlays/worldOverlay.test.mjs index 4b27e73aeb..d64d065978 100644 --- a/src/overlays/worldOverlay.test.mjs +++ b/src/overlays/worldOverlay.test.mjs @@ -1936,6 +1936,25 @@ test('paint rectangles publish from a pool and topmost interactive lookup wins', env.cleanup(); }); +test('hit rectangles stay what is painted until the next paint, through a republish in the same click', () => { + const env = installMockEnvironment(); + initWorldOverlay(env.viewer); + setOverlayEntries('cards', [selectedEntry('card', { interactive: true })]); + env.postRender.raise(); + assert.equal(hitTestWorldOverlay(200, 120)?.entryId, 'card'); + // An earlier click subscriber publishes its own selection card: later + // subscribers in the same click still see what the user clicked on. + setOverlayEntries('other', [selectedEntry('elsewhere', { interactive: true })]); + clearOverlaySource('cards'); + assert.equal(hitTestWorldOverlay(200, 120)?.entryId, 'card'); + assert.equal(hitTestWorldOverlay(200, 120, { sourceId: 'cards' })?.entryId, 'card'); + // The next paint shows the change, and the hit test follows it. + env.postRender.raise(); + assert.equal(hitTestWorldOverlay(200, 120, { sourceId: 'cards' }), null); + assert.equal(hitTestWorldOverlay(200, 120)?.entryId, 'elsewhere'); + env.cleanup(); +}); + test('CCTV stable frame slots gate ambient chrome and wire the exact host hit rectangle', () => { const env = installMockEnvironment({ width: 500, height: 400, dpr: 1 }); initWorldOverlay(env.viewer); From 959698cff94bc08530f6dc0b6f4aeea5a84a02a3 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 21:13:42 +0530 Subject: [PATCH 06/60] fix(drone-airspace, perimeters): yield area clicks to cards painted on top Drone airspace and fire perimeters select a zone or incident from any shape hit, so a quake card or magnitude label painted over one made both layers act on a single click: the quake opened its USGS page or flew to the quake while the area was selected too. Fire and vessel cards over an area did the same. The areas now stand aside when another layer's card or label is the topmost overlay entry, the rule the quake handler already follows for cards painted over its discs. Deselection and every other path are unchanged. Items of layers that never act on clicks no longer matter: the quake card and labels keep working over air-quality stations, traffic lines and OSM places. --- docs/CURRENT-STATE.md | 12 +- src/layers/droneAirspace/index.js | 9 ++ src/layers/droneAirspace/ownership.test.mjs | 37 +++++ src/layers/earthquakes/selection.test.mjs | 169 ++++++++++++++++++++ src/layers/perimeters/index.js | 9 ++ src/layers/perimeters/ownership.test.mjs | 37 +++++ 6 files changed, 272 insertions(+), 1 deletion(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 07f2e8f891..f68d179b8b 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1868,7 +1868,17 @@ like drone airspace and fire perimeters: sibling layers read a disc as empty space, so their cards, near-miss taps and deselection work over a quake as before. When another layer's card or label is painted over a disc (a fire card on a large quake), the quake handler yields to it rather than selecting the -quake beneath. +quake beneath. The same rule holds the other way: drone airspace and fire +perimeters do not select a zone or incident from a shape hit while another +layer's card or label is the topmost overlay entry, so a quake card or +magnitude label over one of them acts once, as the quake's. Items of layers +that never act on clicks (air-quality stations, traffic lines, OSM places) do +not block the quake card or labels. A bare area click with nothing painted on +top still selects the area and clears the quake selection. These rules hold in any +listener order because world-overlay hit rectangles are what is painted on +screen until the next paint: an overlay change (a click subscriber publishing +its selection card) no longer clears them mid-click, and a paint that draws +nothing clears them (`src/overlays/worldOverlay.js`). Air quality (`./layers/air-quality`) draws its station discs as one renderer draw set of ground-clamped fills and reads the view through the camera port; it diff --git a/src/layers/droneAirspace/index.js b/src/layers/droneAirspace/index.js index 8bb8b72423..2e64bafd37 100644 --- a/src/layers/droneAirspace/index.js +++ b/src/layers/droneAirspace/index.js @@ -139,6 +139,15 @@ export function createDroneAirspaceLayer({ const picked = event.topHit; const zoneId = picked ? pickedZoneId(event.drawHit) : null; if (zoneId) { + // Another layer's card or label painted over the zone (a quake's + // card or magnitude label, a fire card) is that layer's click: under + // it the zone is background, as it is to siblings, so it stays as is. + const top = overlayHost.hitTest?.( + event.screenPosition?.x, + event.screenPosition?.y, + {}, + ); + if (top && top.sourceId !== DRONE_AIRSPACE_OVERLAY_SOURCE_ID) return; _selectedId = zoneId; publishSelectedCard(); return; diff --git a/src/layers/droneAirspace/ownership.test.mjs b/src/layers/droneAirspace/ownership.test.mjs index 3dbb16a583..b6e4cbdcb2 100644 --- a/src/layers/droneAirspace/ownership.test.mjs +++ b/src/layers/droneAirspace/ownership.test.mjs @@ -143,6 +143,43 @@ test('clicking a zone publishes its card; empty space clears it', async () => { assert.equal(h.overlay.entries.get('drone-airspace')?.length ?? 0, 0); }); +// Another layer's card or label painted over the area (a quake's card or +// magnitude label) is that layer's click: the area under it stands aside. +test("another layer's overlay on top keeps a click off the area", async () => { + let pickResult = null; + let foreignOnTop = false; + const h = harness( + { getSnapshot: async () => [row] }, + { + pick: () => pickResult, + // Unfiltered: the topmost entry of any source. + cardHit: (_x, _y, options) => + foreignOnTop && !options?.sourceId + ? { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' } + : null, + }, + ); + await h.layer.update(h.viewer); + pickResult = zonePick('drone-airspace:310:0'); + foreignOnTop = true; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal(h.overlay.entries.get('drone-airspace')?.length ?? 0, 0); + // With nothing painted over it, the same click selects the area. + foreignOnTop = false; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal( + h.overlay.entries.get('drone-airspace')[0].id, + 'drone-airspace-card:310', + ); + // An overlay on top never clears an existing selection either. + foreignOnTop = true; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal( + h.overlay.entries.get('drone-airspace')[0].id, + 'drone-airspace-card:310', + ); +}); + test('late refresh cannot publish after disable or destroy', async () => { for (const action of ['disable', 'destroy']) { let resolve, signal; diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index 4a5e70412a..ad8765b05d 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -2,6 +2,8 @@ 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 { fakeInput } from '../../input/testDoubles.mjs'; +import { createDroneAirspaceLayer } from '../droneAirspace/index.js'; import { EARTHQUAKE_CARD_SOURCE_ID, EARTHQUAKE_OVERLAY_SOURCE_ID, @@ -709,3 +711,170 @@ test("another layer's object under the quake card takes the click", async () => function overlayHitCard(h, entryId, hit) { h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, entryId, hit); } + +for (const kind of ['card', 'label']) { + for (const areaFirst of [false, true]) { + test(`quake ${kind} over an unowned area takes the click once (${areaFirst ? 'area' : 'quake'} handler first)`, async () => { + let sceneHit = null; + let painted = null; + const viewer = { + scene: { pick: () => (sceneHit ? { id: sceneHit } : null) }, + }; + const { draw, unbind } = bindFakeDraw(viewer); + const input = fakeInput(viewer); + const entries = new Map(); + const opened = []; + const focused = []; + // As the real host does, hits are what was last painted: a card a + // subscriber publishes during a click changes nothing for the others + // until the next paint, so the outcome cannot depend on their order. + let screen = new Map(); + const paint = () => { + screen = new Map(entries); + }; + const host = { + setEntries: (source, rows) => entries.set(source, rows), + setVisible() {}, + clearSource: (source) => entries.delete(source), + hitTest(_x, _y, { sourceId } = {}) { + if (!painted || (sourceId && sourceId !== painted.sourceId)) + return null; + const entry = screen + .get(painted.sourceId) + ?.find((e) => e.id === painted.entryId); + return entry?.interactive ? { ...painted, entry } : null; + }, + }; + const click = () => { + paint(); + input.click(); + }; + const q = createEarthquakesLayer({ + source: { getSnapshot: async () => [quake('ak1')] }, + overlayHost: host, + input: () => input.input, + picking, + openExternal: (url) => opened.push(url), + focus: { requestWorldFocus: (detail) => focused.push(detail) }, + }); + const area = createDroneAirspaceLayer({ + source: { + getSnapshot: async () => [ + { + stableId: '310', + name: 'Fixture area', + typeCode: 'P', + type: 'Prohibited', + lowerAltitude: 'SFC', + upperAltitude: '18000', + polygons: [ + [ + [ + [-153.4, 59.9], + [-153.2, 59.9], + [-153.2, 60.1], + [-153.4, 59.9], + ], + ], + ], + }, + ], + }, + overlayHost: host, + inputFor: () => input.input, + picking, + }); + const layers = areaFirst ? [area, q] : [q, area]; + try { + for (const layer of layers) { + layer.init(viewer); + layer.enable(viewer); + await layer.update(viewer); + } + const ownHit = { + set: draw.find('earthquakes:').spec.id, + id: 'earthquake:ak1', + }; + const areaSet = [...draw.sets.values()].find( + (set) => + set.spec.id.startsWith('drone-airspace:') && + set.spec.id.endsWith(':fills'), + ); + const areaHit = { set: areaSet.spec.id, id: 'drone-airspace:310:0' }; + assert.equal(picking.findPickOwner(areaHit.id), null); + sceneHit = ownHit; + click(); + assert.equal( + entries.get('earthquake-card')[0].id, + 'earthquake-card:ak1', + ); + assert.equal(entries.get('drone-airspace')?.length ?? 0, 0); + painted = { + sourceId: + kind === 'card' + ? EARTHQUAKE_CARD_SOURCE_ID + : EARTHQUAKE_OVERLAY_SOURCE_ID, + entryId: kind === 'card' ? 'earthquake-card:ak1' : 'ak1', + }; + sceneHit = areaHit; + click(); + // The quake's card or label painted on top takes the click; the + // zone under it is background and stands aside: one action. + assert.equal( + entries.get('drone-airspace')?.length ?? 0, + 0, + 'the area under the overlay is not selected', + ); + assert.equal( + entries.get('earthquake-card')[0].id, + 'earthquake-card:ak1', + 'the quake card stays', + ); + assert.equal(opened.length, kind === 'card' ? 1 : 0); + assert.equal(focused.length, kind === 'label' ? 1 : 0); + // The same painted action works over its own disc and over open ground. + for (const hit of [ownHit, null]) { + sceneHit = hit; + click(); + } + assert.equal(opened.length, kind === 'card' ? 3 : 0); + assert.equal(focused.length, kind === 'label' ? 3 : 0); + // With no overlay the area is selected and the quake deselects. + painted = null; + sceneHit = areaHit; + click(); + assert.equal(entries.get('drone-airspace')?.length, 1); + assert.equal(entries.get('earthquake-card')?.length ?? 0, 0); + } finally { + for (const layer of layers) layer.destroy(); + input.destroy(); + unbind(); + } + }); + } +} + +// Layers that never act on clicks still draw pickable items (air quality +// stations, traffic heat lines, OSM places). They are not a click target, so +// the quake card and labels painted over them keep working. +test('quake card and label work over pickable items no layer acts on', async () => { + const h = harness([quake('ak1'), quake('ak2', { mag: 4 })]); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + h.clickDisc('ak1'); + const decorative = [ + { set: 'air-quality-markers:1', id: 'aq:station-1' }, + { set: 'traffic:1:heat', id: 'traffic:segment-9' }, + { set: 'osm-places:1:points', id: 'osm:node-3' }, + ]; + for (const hit of decorative) { + h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, 'earthquake-card:ak1', hit); + } + assert.equal(h.opened.length, decorative.length, 'the card opens USGS'); + h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', decorative[1]); + assert.equal(h.focused.at(-1)?.id, 'earthquake:ak2', 'the label flies'); + } finally { + h.layer.destroy(); + } +}); diff --git a/src/layers/perimeters/index.js b/src/layers/perimeters/index.js index 3a5a180c48..017e7ab46c 100644 --- a/src/layers/perimeters/index.js +++ b/src/layers/perimeters/index.js @@ -230,6 +230,15 @@ export function createFirePerimetersLayer({ const picked = event.topHit; const incidentId = picked ? pickedIncidentId(event.drawHit) : null; if (incidentId) { + // Another layer's card or label painted over the perimeter (a + // quake's card or magnitude label, a fire card) is that layer's + // click: under it the perimeter is background, so it stays as is. + const top = overlayHost.hitTest?.( + event.screenPosition?.x, + event.screenPosition?.y, + {}, + ); + if (top && top.sourceId !== PERIMETER_OVERLAY_SOURCE_ID) return; abortLinkVerification(); _selectedId = incidentId; publishSelectedCard(); diff --git a/src/layers/perimeters/ownership.test.mjs b/src/layers/perimeters/ownership.test.mjs index 61cfde2bbf..9f11d5b177 100644 --- a/src/layers/perimeters/ownership.test.mjs +++ b/src/layers/perimeters/ownership.test.mjs @@ -243,6 +243,43 @@ test('clicking a perimeter publishes its incident card; empty space clears it', assert.equal(h.overlay.entries.get('fire-perimeters')?.length ?? 0, 0); }); +// Another layer's card or label painted over the area (a quake's card or +// magnitude label) is that layer's click: the area under it stands aside. +test("another layer's overlay on top keeps a click off the area", async () => { + let pickResult = null; + let foreignOnTop = false; + const h = harness( + { getSnapshot: async () => [row] }, + { + pick: () => pickResult, + // Unfiltered: the topmost entry of any source. + cardHit: (_x, _y, options) => + foreignOnTop && !options?.sourceId + ? { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' } + : null, + }, + ); + await h.layer.update(h.viewer); + pickResult = perimeterPick('fire-perimeter:2026-NMGNF-000123:0'); + foreignOnTop = true; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal(h.overlay.entries.get('fire-perimeters')?.length ?? 0, 0); + // With nothing painted over it, the same click selects the area. + foreignOnTop = false; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal( + h.overlay.entries.get('fire-perimeters')[0].id, + 'fire-perimeter-card:2026-NMGNF-000123', + ); + // An overlay on top never clears an existing selection either. + foreignOnTop = true; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal( + h.overlay.entries.get('fire-perimeters')[0].id, + 'fire-perimeter-card:2026-NMGNF-000123', + ); +}); + test('disable removes the click handler, pick ownership, and any card', async () => { const h = harness( { getSnapshot: async () => [row] }, From 836daf82b3797632b9beb66586dec27cb88cf16c Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Tue, 17 Nov 2026 01:32:47 +0530 Subject: [PATCH 07/60] fix(overlays): let only the topmost painted card act on a click Card handlers hit-tested only their own source, so a card buried under another layer's card still acted, and a click on a selected quake card over a vessel or fire card made both layers act. Vessels, FIRMS, wildlife, news, ghost maps and shipwrecks now read the unfiltered topmost painted entry: their own card acts only when it is on top, and a click on another layer's card is that layer's, so it neither acts here nor clears a selection. A top news or wildlife card still acts over another layer's scene item, so it never goes dead over a flight trail or a directions route; a registered marker under a foreign card is still its layer's to select. --- src/data/aisLiveVessels.test.mjs | 32 +++++++++- src/data/firmsInteraction.test.mjs | 45 +++++++++++++- src/layers/firms/selection.js | 4 +- src/layers/ghostMaps/index.js | 10 ++- src/layers/ghostMaps/lifecycle.test.mjs | 51 ++++++++++++++++ src/layers/news/index.js | 10 +-- src/layers/news/layer.test.mjs | 61 ++++++++++++++++++- src/layers/shipwrecks/index.js | 13 ++-- src/layers/shipwrecks/index.test.mjs | 46 +++++++++++++- src/layers/vessels/selection.js | 10 ++- .../wildlifeSightings/ownership.test.mjs | 5 +- src/layers/wildlifeSightings/selection.js | 17 ++---- .../wildlifeSightings/selection.test.mjs | 43 ++++++++++++- src/ui/wildlifeSightingCard.test.mjs | 6 +- 14 files changed, 310 insertions(+), 43 deletions(-) diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs index 1b091ec4f7..b2ea95ceb1 100644 --- a/src/data/aisLiveVessels.test.mjs +++ b/src/data/aisLiveVessels.test.mjs @@ -1847,12 +1847,17 @@ test('vessel interaction wire: a vessel with an id and no MMSI is selected by cl * only publishes rects for `interactive` entries, so a stub returning a hit is * the same contract a painted, actionable card presents. */ -function hostWithCardHit(entryId) { +function hostWithCardHit(entryId, topHit) { return { setEntries() {}, setVisible() {}, clearSource() {}, - hitTest: () => (entryId ? { sourceId: 'ais-live-vessels', entryId } : null), + hitTest: (_x, _y, { sourceId } = {}) => + !sourceId && topHit + ? topHit + : entryId + ? { sourceId: 'ais-live-vessels', entryId } + : null, }; } @@ -1914,6 +1919,29 @@ test('vessel interaction wire: clicking the selected vessel card refocuses exact } }); +test('vessel interaction wire: a covered card yields while a real vessel pick still focuses', () => { + for (const ownPick of [false, true]) { + const harness = installWireHarness(ownPick ? { id: makeRecord().mmsi } : null); + const requests = []; + harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => + requests.push(event.detail), + ); + _setVesselOverlayHostForTest( + hostWithCardHit(`vessel:${harness.record.mmsi}`, { + sourceId: 'earthquakes', entryId: 'quake:cover', + }), + ); + try { + harness.handler.click({ position: { x: 10, y: 20 } }); + assert.equal(requests.length, ownPick ? 1 : 0); + assert.equal(aisLiveVesselsLayer.getSelectedInfo()?.mmsi, harness.record.mmsi); + } finally { + _setVesselOverlayHostForTest(null); + harness.cleanup(); + } + } +}); + test('vessel interaction wire: an unknown card id preserves selection and never flies', () => { const harness = installWireHarness({ primitive: {}, diff --git a/src/data/firmsInteraction.test.mjs b/src/data/firmsInteraction.test.mjs index ddd5f9b034..55413c1d85 100644 --- a/src/data/firmsInteraction.test.mjs +++ b/src/data/firmsInteraction.test.mjs @@ -58,6 +58,7 @@ function harness({ fires = [makeFire()], picked = null, cardHit = null, + topCard = null, cameraPosition = null, withDataSource = false, withGlobe = false, @@ -85,7 +86,12 @@ function harness({ setEntries: (sourceId, entries) => published.push(...entries), setVisible() {}, clearSource() {}, - hitTest: () => (cardHit ? { sourceId: 'firms', entryId: cardHit } : null), + hitTest: (_x, _y, { sourceId } = {}) => + !sourceId && topCard + ? topCard + : cardHit + ? { sourceId: 'firms', entryId: cardHit } + : null, }, }); @@ -153,6 +159,9 @@ function harness({ (record) => record.kind === 'icons' && !record.disposed, ), click: () => input.click({ x: 400, y: 300 }), + cover: (hit) => { + topCard = hit; + }, cleanup() { Cesium.SceneTransforms.worldToWindowCoordinates = priorProjection; if (hadWindow) globalThis.window = priorWindow; @@ -308,7 +317,11 @@ test('far-side detections cannot consume the bounded ambient-card cohort', () => test('clicking a fire sprite selects it and requests the camera transfer', () => { const fire = makeFire(); - const h = harness({ fires: [fire], picked: glowPick('firms-7') }); + const h = harness({ + fires: [fire], + picked: glowPick('firms-7'), + topCard: { sourceId: 'earthquakes', entryId: 'quake:cover' }, + }); try { h.click(); assert.equal(h.requests.length, 1); @@ -355,6 +368,34 @@ test('clicking a fire CARD behaves exactly like clicking its sprite', () => { } }); +test('a covered fire card does not act, and keeps an existing selection', () => { + const fire = makeFire(); + const h = harness({ + fires: [fire], + cardHit: `fire:${fireDetectionKey(fire)}`, + }); + try { + // Covered by another layer's card from the start: nothing selects or flies. + h.cover({ sourceId: 'earthquakes', entryId: 'quake:cover' }); + h.click(); + assert.equal(h.requests.length, 0); + assert.equal(h.layer.getSelectedInfo(), null); + // Uncovered, the card selects; covered again, the click is the other + // layer's and leaves that selection alone. + h.cover(null); + h.click(); + assert.equal(h.requests.length, 1); + const selected = h.layer.getSelectedInfo(); + assert.ok(selected); + h.cover({ sourceId: 'earthquakes', entryId: 'quake:cover' }); + h.click(); + assert.equal(h.requests.length, 1); + assert.deepEqual(h.layer.getSelectedInfo(), selected); + } finally { + h.cleanup(); + } +}); + // The voice model reads these labels as data (track_entity, get_entity_context, // pointer_context); the voice card translates them where it shows them. test('fire labels stay English data in a translated interface', () => { diff --git a/src/layers/firms/selection.js b/src/layers/firms/selection.js index db80cef722..edbae6734b 100644 --- a/src/layers/firms/selection.js +++ b/src/layers/firms/selection.js @@ -49,11 +49,9 @@ export function createSelection({ const cardHit = overlayHost.hitTest?.( event.screenPosition?.x, event.screenPosition?.y, - { - sourceId: FIRMS_OVERLAY_SOURCE_ID, - }, ); if (cardHit) { + if (cardHit.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; const carded = layerState._fireByCardId.get(cardHit.entryId); if (carded) selectAndFocusFire(carded); return; diff --git a/src/layers/ghostMaps/index.js b/src/layers/ghostMaps/index.js index 9332622411..d2378de613 100644 --- a/src/layers/ghostMaps/index.js +++ b/src/layers/ghostMaps/index.js @@ -710,9 +710,11 @@ export function createGhostMapsLayer({ const cardHit = overlayHost.hitTest?.( event.screenPosition?.x, event.screenPosition?.y, - { sourceId: GHOSTMAPS_OVERLAY_SOURCE_ID }, ); - if (cardHit && cardHit.entryId === _selectedCardId) { + if ( + cardHit?.sourceId === GHOSTMAPS_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId + ) { if (_selectedLink && openExternal) openExternal(_selectedLink); return; } @@ -729,6 +731,10 @@ export function createGhostMapsLayer({ if (pickId && picking.isOwnedByOtherLayer(GHOSTMAPS_LAYER_ID, pickId)) return; } + // A covered card must neither open its source nor clear the selection. + // A marker of ours under that card was already selected by the pick + // check before this one. + if (cardHit) return; if (_selectedKey) { clearSelection(); render(); diff --git a/src/layers/ghostMaps/lifecycle.test.mjs b/src/layers/ghostMaps/lifecycle.test.mjs index 7bba31645d..ea4f99bed7 100644 --- a/src/layers/ghostMaps/lifecycle.test.mjs +++ b/src/layers/ghostMaps/lifecycle.test.mjs @@ -642,3 +642,54 @@ test('narrowing to a window the loaded data covers clears a failed wider reload' assert.equal(layer.getStats().error, null); assert.equal(layer.getStats().count, 1); }); + +test('a covered selected card yields while genuine GhostMaps markers still select', async (t) => { + const cards = []; + const opened = []; + let painted = []; + const { layer, viewer, click } = fixture(t, { + reports: [ + { + name: 'First', + description: 'Source', + }, + { + name: 'Second', + description: 'Source', + }, + ], + controls: { + overlayHost: { + setEntries: (_id, entries) => cards.push(entries), + hitTest: (_x, _y, { sourceId } = {}) => + painted.find((hit) => !sourceId || hit.sourceId === sourceId) ?? null, + }, + picking: { resolvePickId: (picked) => picked }, + openExternal: (url) => opened.push(url), + }, + }); + await layer.update(viewer); + click('ghostmaps:cip:0:0'); + const first = cards.at(-1)[0]; + const foreign = { + sourceId: 'earthquake-card', + entryId: 'earthquake-card:ak1', + }; + painted = [foreign, { sourceId: 's2-ghostmaps', entryId: first.id }]; + click(null); + assert.deepEqual(opened, []); + assert.equal(cards.at(-1)[0].id, first.id); + click('ghostmaps:cip:1:0'); + const second = cards.at(-1)[0]; + assert.notEqual( + second.id, + first.id, + 'an actual marker still selects beneath the foreign card', + ); + painted = [{ sourceId: 's2-ghostmaps', entryId: second.id }]; + click(null); + assert.deepEqual(opened, ['https://example.com/second']); + painted = []; + click(null); + assert.deepEqual(cards.at(-1), [], 'bare map still clears the selection'); +}); diff --git a/src/layers/news/index.js b/src/layers/news/index.js index 4ad5826c27..7e5e9a7eae 100644 --- a/src/layers/news/index.js +++ b/src/layers/news/index.js @@ -1348,10 +1348,10 @@ export function createNewsLayer({ clickOff = inputFor(viewer).onClick((event) => { const at = event?.screenPosition; if (!enabled || destroyed || !isPointerFree() || !at) return; - const card = hitTestOverlay(at.x, at.y, { - sourceId: NEWS_OVERLAY_SOURCE_ID, - }); - if (card?.entry?.activate) { + // The topmost painted entry decides: our own card acts; one covered by + // another layer's card does not. + const card = hitTestOverlay(at.x, at.y); + if (card?.sourceId === NEWS_OVERLAY_SOURCE_ID && card.entry?.activate) { card.entry.activate(); return; } @@ -1408,6 +1408,8 @@ export function createNewsLayer({ return; } if (id && isOwnedByOtherLayer(NEWS_LAYER_ID, id)) return; + // Another layer's card on top is that layer's click, not empty map. + if (card) return; if (selectedId && !picked?.id) layer.setParams({ clear: true }); }); } diff --git a/src/layers/news/layer.test.mjs b/src/layers/news/layer.test.mjs index 9804011d77..0070b6b773 100644 --- a/src/layers/news/layer.test.mjs +++ b/src/layers/news/layer.test.mjs @@ -5,6 +5,13 @@ import { fromDegrees } from '../../geo/ellipsoid.js'; import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; import { NEWS_KEY_PROVIDERS, createNewsLayer } from './index.js'; +import { + findPickOwner, + registerPickOwner, + unregisterPickOwner, +} from '../../data/pickRegistry.js'; +// Registers the shared `gev-trail:` no-op owner, as the app does. +import '../../data/trailRenderer.js'; import { getSelectedEntityContext } from '../../data/contextStore.js'; const NOW = Date.parse('2026-10-28T10:00:00Z'); @@ -51,6 +58,7 @@ function fixture( now = () => NOW, quality, pictureCards, + hitTestOverlay = () => null, } = {}, ) { const calls = { feed: [], hotspots: 0, outline: 0 }; @@ -141,7 +149,7 @@ function fixture( source, overlayHost, inputFor: () => input, - hitTestOverlay: () => null, + hitTestOverlay, now, matchMedia: () => ({ matches: reduced }), getViewCentre: () => centre(), @@ -1285,6 +1293,57 @@ test('a click on a marker selects its report, on a beacon chooses its hotspot, o assert.equal(clickHandlers.size, 0); }); +test('a covered news card yields; the top news card acts over a flight trail', async (t) => { + let hits = []; + const { layer, items, entries, click, flights } = fixture(t, { + height: 500_000, + hitTestOverlay: (_x, _y, { sourceId } = {}) => + hits.find((hit) => !sourceId || hit.sourceId === sourceId) || null, + }); + layer.enable(); + await layer.update(); + await flush(); + const marker = [...items('points'), ...items('icons')].find((item) => + String(item.id).startsWith('news:report:major~'), + ); + click({ set: 'news:1:points', id: marker.id, surface: false }); + const card = entries.flat().find((entry) => entry.activate); + assert.ok(card, 'an actionable news card was published'); + let activations = 0; + const activate = card.activate; + card.activate = () => { + activations++; + return activate(); + }; + hits = [ + { sourceId: 'earthquakes', entryId: 'quake:cover' }, + { sourceId: 'news', entry: card }, + ]; + const before = layer.getRowControls().feed; + const flightCount = flights.length; + click(null); + assert.equal(activations, 0, 'a covered news card does not activate'); + assert.equal(layer.getRowControls().feed.selected.id, 'major'); + assert.deepEqual(layer.getRowControls().feed.filters, before.filters); + assert.equal(flights.length, flightCount); + layer.setParams({ clear: true }); + click({ set: 'news:1:points', id: marker.id, surface: false }); + assert.equal(layer.getRowControls().feed.selected.id, 'major'); + hits.shift(); + click(null); + assert.equal(activations, 1, 'the unobscured news card acts once'); + // A flight trail is registered so every layer reads a click on it as a + // no-op (src/data/trailRenderer.js). Under the top news card it must not + // make the card dead. + assert.equal(findPickOwner('gev-trail:fl-a1b2c3:head'), 'trails'); + click({ + set: 'trail:1:lines', + id: 'gev-trail:fl-a1b2c3:head', + surface: false, + }); + assert.equal(activations, 2, 'the news card acts over a flight trail'); +}); + test('zoomed out, a hotspot is one beacon; off, nothing draws; destroyed, the sets go', async (t) => { const { layer, items } = fixture(t); assert.deepEqual(items('points'), []); diff --git a/src/layers/shipwrecks/index.js b/src/layers/shipwrecks/index.js index c2c2db2814..c8eff42cb7 100644 --- a/src/layers/shipwrecks/index.js +++ b/src/layers/shipwrecks/index.js @@ -278,10 +278,11 @@ export function createShipwrecksLayer({ _clickHandler = clicks.onClick((click) => { if (pointer && !pointer.isPointerFree()) return; const at = click.screenPosition; - const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { - sourceId: SHIPWRECKS_OVERLAY_SOURCE_ID, - }); - if (cardHit && cardHit.entryId === _selectedCardId) { + const cardHit = overlayHost.hitTest?.(at?.x, at?.y); + if ( + cardHit?.sourceId === SHIPWRECKS_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId + ) { if (_selectedLink) openExternal(_selectedLink); return; } @@ -299,6 +300,10 @@ export function createShipwrecksLayer({ } if (pickId && picking.isOwnedByOtherLayer(SHIPWRECKS_LAYER_ID, pickId)) return; + // A covered card must neither open its source nor clear the selection. + // A marker of ours under that card was already selected by the pick + // check before this one. + if (cardHit) return; if (_selectedId) { clearSelection(); render(); diff --git a/src/layers/shipwrecks/index.test.mjs b/src/layers/shipwrecks/index.test.mjs index 7d69f2b457..6209129caa 100644 --- a/src/layers/shipwrecks/index.test.mjs +++ b/src/layers/shipwrecks/index.test.mjs @@ -36,7 +36,7 @@ function deferred() { return { promise, resolve }; } -function harness({ snapshots, now = () => 1 } = {}) { +function harness({ snapshots, now = () => 1, cardHit = () => null } = {}) { const cards = []; const handlers = []; const opened = []; @@ -59,7 +59,7 @@ function harness({ snapshots, now = () => 1 } = {}) { overlayHost: { setEntries: (_source, entries) => cards.push(entries), setVisible() {}, - hitTest: () => null, + hitTest: cardHit, }, // The globe's clicks: one listener per click handler installed. input: () => ({ @@ -393,3 +393,45 @@ test('the page deadline subtracts the newest available source age from the limit ); assert.equal(snapshotDeadline({ sources: both }, 0), 7 * DAY, 'defaults'); }); + +test('a covered selected card yields while genuine wreck markers still select', async () => { + let painted = []; + const h = harness({ + snapshots: [ + snapshot([ + wreck('a', { url: 'https://example.com/a' }), + wreck('b', { url: 'https://example.com/b' }), + ]), + ], + cardHit: (_x, _y, { sourceId } = {}) => + painted.find((hit) => !sourceId || hit.sourceId === sourceId) ?? null, + }); + try { + h.layer.enable(); + await h.layer.update(); + const click = () => h.handlers[0].click({ screenPosition: { x: 1, y: 1 } }); + h.pick('a'); + click(); + const first = h.lastCard()[0]; + painted = [ + { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }, + { sourceId: 'shipwrecks', entryId: first.id }, + ]; + h.pick(null); + click(); + assert.deepEqual(h.opened, []); + assert.equal(h.lastCard()[0].id, first.id); + h.pick('b'); + click(); + assert.equal(h.lastCard()[0].id, 'shipwreck-card:b'); + painted = [{ sourceId: 'shipwrecks', entryId: 'shipwreck-card:b' }]; + h.pick(null); + click(); + assert.deepEqual(h.opened, ['https://example.com/b']); + painted = []; + click(); + assert.deepEqual(h.lastCard(), [], 'bare map still clears the selection'); + } finally { + h.layer.destroy(); + } +}); diff --git a/src/layers/vessels/selection.js b/src/layers/vessels/selection.js index 7f8ddab832..f236aebf7e 100644 --- a/src/layers/vessels/selection.js +++ b/src/layers/vessels/selection.js @@ -68,14 +68,12 @@ export function createSelection({ ? vesselState._vesselOverlayHost.hitTest?.( event.screenPosition?.x, event.screenPosition?.y, - { - ...(cycloneBackground - ? {} - : { sourceId: VESSEL_OVERLAY_SOURCE_ID }), - }, ) : null; - if (cycloneBackground && cardHit?.sourceId !== VESSEL_OVERLAY_SOURCE_ID) + if ( + (cardHit && cardHit.sourceId !== VESSEL_OVERLAY_SOURCE_ID) || + (cycloneBackground && !cardHit) + ) return; if (!record && cardHit) { const id = String(cardHit.entryId || '').startsWith('vessel:') diff --git a/src/layers/wildlifeSightings/ownership.test.mjs b/src/layers/wildlifeSightings/ownership.test.mjs index 057c805196..ebe4b75e58 100644 --- a/src/layers/wildlifeSightings/ownership.test.mjs +++ b/src/layers/wildlifeSightings/ownership.test.mjs @@ -196,8 +196,9 @@ function harness( }, setVisible: (id, value) => overlay.visible.set(id, value), clearSource: (id) => overlay.entries.delete(id), - hitTest: (_x, _y, { sourceId }) => - cardHit?.sourceId === sourceId ? cardHit : null, + // As the host does: unfiltered, the topmost entry. + hitTest: (_x, _y, { sourceId } = {}) => + !sourceId || cardHit?.sourceId === sourceId ? cardHit : null, }, input: () => ({ onClick(fn) { diff --git a/src/layers/wildlifeSightings/selection.js b/src/layers/wildlifeSightings/selection.js index dc0b7c126c..368497c539 100644 --- a/src/layers/wildlifeSightings/selection.js +++ b/src/layers/wildlifeSightings/selection.js @@ -483,17 +483,10 @@ export function createSelection({ state, services, parts }) { if (!state.enabled || services.pointer?.isPointerFree?.() === false) return; const at = click.screenPosition; - const hit = - overlay?.hitTest?.(at?.x, at?.y, { - sourceId: WILDLIFE_SELECTED_SOURCE_ID, - }) || - overlay?.hitTest?.(at?.x, at?.y, { - sourceId: WILDLIFE_OVERLAY_SOURCE_ID, - }) || - overlay?.hitTest?.(at?.x, at?.y, { - sourceId: WILDLIFE_LABEL_SOURCE_ID, - }); - if (hit) { + // The topmost painted entry decides: our own card or label acts; one + // covered by another layer's card does not. + const hit = overlay?.hitTest?.(at?.x, at?.y); + if (hit && sourceIds.includes(hit.sourceId)) { hit.entry?.activate?.(); return; } @@ -516,6 +509,8 @@ export function createSelection({ state, services, parts }) { services.picking?.isOwnedByOtherLayer?.('wildlife-sightings', id) ) return; + // Another layer's card on top is that layer's click, not empty map. + if (hit) return; clearAndRebuild(); }); } diff --git a/src/layers/wildlifeSightings/selection.test.mjs b/src/layers/wildlifeSightings/selection.test.mjs index bf623526bb..f7da089369 100644 --- a/src/layers/wildlifeSightings/selection.test.mjs +++ b/src/layers/wildlifeSightings/selection.test.mjs @@ -21,6 +21,7 @@ function fixture(sighting = row, extraServices = {}) { const seen = []; const painted = new Set(); let hit = null; + let coveringHit = null; let projections = 0; let click; const state = { @@ -49,8 +50,12 @@ function fixture(sighting = row, extraServices = {}) { setEntries: (id, value) => entries.set(id, value), clearSource: (id) => entries.delete(id), setVisible() {}, - hitTest: (_x, _y, { sourceId }) => - hit?.sourceId === sourceId ? hit : null, + hitTest: (_x, _y, { sourceId } = {}) => + sourceId + ? hit?.sourceId === sourceId + ? hit + : null + : coveringHit || hit, }, now: () => row.observedAt + 60_000, project: (_scene, anchor) => { @@ -94,6 +99,9 @@ function fixture(sighting = row, extraServices = {}) { ?.find((entry) => entry.id === entryId); hit = entry ? { sourceId, entryId, entry } : null; }, + cover(value) { + coveringHit = value; + }, paint(ids) { painted.clear(); for (const id of ids) painted.add(id); @@ -179,6 +187,37 @@ test('selected photo and name cards use the selected lane, select on click and n } }); +test('a covered sighting label yields; the top label acts over trails and other scene items', () => { + const f = fixture(row, { + // Registered owners, as the app has them: an aircraft, and the flight + // trails every layer reads as a no-op (src/data/trailRenderer.js). + picking: { + isOwnedByOtherLayer: (_layer, id) => + id === 'other:aircraft' || String(id).startsWith('gev-trail:'), + }, + }); + f.selection.install(); + f.selection.refreshAmbient(); + f.hit('wildlife-sightings-labels', 'wildlife-sightings-label:inat:123'); + f.click(null); + assert.equal(f.flights.length, 1); + f.cover({ sourceId: 'earthquakes', entryId: 'quake:cover' }); + f.click(null); + assert.equal(f.flights.length, 1); + assert.equal(f.state.selectedRow, row); + f.click(); + assert.equal(f.flights.length, 2, 'an actual sighting remains selectable'); + f.cover(null); + // The top label acts over a flight trail: never a dead click. + f.click('gev-trail:fl-a1b2c3:head'); + assert.equal(f.flights.length, 3, 'the label acts over a flight trail'); + // And over another layer's scene item, as on main. + f.click('other:aircraft'); + assert.equal(f.flights.length, 4, 'the top label acts'); + assert.equal(f.state.selectedRow, row); + f.selection.remove(); +}); + test('nearby duplicate display names yield to painted cards and higher-ranked labels using cached screens', () => { const low = { ...row, diff --git a/src/ui/wildlifeSightingCard.test.mjs b/src/ui/wildlifeSightingCard.test.mjs index 731897a6a2..96f9d06c33 100644 --- a/src/ui/wildlifeSightingCard.test.mjs +++ b/src/ui/wildlifeSightingCard.test.mjs @@ -128,8 +128,10 @@ function fixture( now: () => NOW, overlayHost: { setEntries: (id, entries) => overlays.set(id, entries), - hitTest: (_x, _y, { sourceId }) => - hit?.sourceId === sourceId ? hit : null, + // As the host does: unfiltered, the topmost entry; filtered, only + // an entry of that source. + hitTest: (_x, _y, { sourceId } = {}) => + hit && (!sourceId || hit.sourceId === sourceId) ? hit : null, }, input: () => ({ onClick(fn) { From 133d022b29b9a7b6cf8ca636a0bfcb22a1424906 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Tue, 17 Nov 2026 01:33:06 +0530 Subject: [PATCH 08/60] fix(picking): arbitrate card clicks over passive and background shapes Flight trails register their ids so every layer reads a trail click as a no-op, and the directions route claims its line and markers though it acts only on its maneuver steps. The quake card and magnitude labels yielded to any registered owner, so over a trail or a route they did nothing. Pick owners can now name the picks they never act on (registerPickOwner(..., { passive })); isActedOnByOtherLayer leaves those out while isOwnedByOtherLayer is unchanged, so they are still not empty space. Submarine cables and rocket launches acted on any scene pick, so a card or label over a cable or a launch marker made both layers act. Both now stand aside when a world-overlay entry is under the click, as drone airspace and fire perimeters do through the top-entry check. Each of these layers, and the quake discs, registers its shapes with registerCardBackground. CCTV asks isCardBackground instead of matching other layers' set and id formats, so a live top CCTV card acts once over any of them, while unknown identified objects and registered owners still block it. --- docs/CURRENT-STATE.md | 26 +++- scripts/format-scope.json | 2 + src/app/layers/rocketLaunches.js | 3 +- src/app/layers/submarineCables.js | 6 +- src/data/cctv.test.mjs | 11 +- src/data/directions.test.mjs | 41 ++++++ src/data/pickRegistry.js | 87 +++++++++++- src/data/pickRegistry.test.mjs | 109 +++++++++++++-- src/data/trailRenderer.js | 8 +- src/layers/cctv/lifecycle.js | 48 ++++--- src/layers/cctv/lifecycle.test.mjs | 131 ++++++++++++++++++ src/layers/directions/index.js | 3 + src/layers/droneAirspace/index.js | 22 +-- src/layers/droneAirspace/ownership.test.mjs | 34 ++++- src/layers/earthquakes/index.js | 33 ++++- src/layers/earthquakes/selection.test.mjs | 55 +++++++- src/layers/launches/clickYield.test.mjs | 77 ++++++++++ src/layers/launches/lifecycle.js | 24 ++++ src/layers/perimeters/index.js | 21 +-- src/layers/perimeters/ownership.test.mjs | 41 +++++- src/layers/submarineCables/index.js | 3 + src/layers/submarineCables/interaction.js | 29 +++- .../submarineCables/interaction.test.mjs | 89 ++++++++++++ 23 files changed, 825 insertions(+), 78 deletions(-) create mode 100644 src/layers/launches/clickYield.test.mjs create mode 100644 src/layers/submarineCables/interaction.test.mjs diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index f68d179b8b..fff1716a8f 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1874,11 +1874,33 @@ layer's card or label is the topmost overlay entry, so a quake card or magnitude label over one of them acts once, as the quake's. Items of layers that never act on clicks (air-quality stations, traffic lines, OSM places) do not block the quake card or labels. A bare area click with nothing painted on -top still selects the area and clears the quake selection. These rules hold in any -listener order because world-overlay hit rectangles are what is painted on +top still selects the area and clears the quake selection. These rules hold in +any listener order because world-overlay hit rectangles are what is painted on screen until the next paint: an overlay change (a click subscriber publishing its selection card) no longer clears them mid-click, and a paint that draws nothing clears them (`src/overlays/worldOverlay.js`). +Card consumers resolve the unfiltered top painted entry before acting, so a +covered vessel, fire, wildlife, news, CCTV, perimeter, ghost-map or shipwreck +card does not act alongside the card above it; drone-airspace shapes use the +same top-entry check (their cards are not interactive). A top news or wildlife +card still acts over another layer's scene item, as before, so a card over a +flight trail (registered as a no-op for every layer) or a directions route is +never a dead click. A click on another layer's card does not activate a covered +card of these layers or clear their selection; a marker of theirs under that +card is still theirs to select. Flight trails and the directions route line and +markers are passive pick owners (`registerPickOwner(…, { passive })`): still +not empty space (`isOwnedByOtherLayer`), but `isActedOnByOtherLayer` leaves +them out, so the quake card and magnitude labels act over them. Directions +selects only its maneuver steps, though any other click still clears a selected +step. Fire, vessel and CCTV cards over a trail or the route stay as they were +(no action). Submarine cables and rocket launches, whose own overlays are not +interactive, stand aside when any overlay entry is under the click, so a card +or label over a cable or a launch marker acts once. Layers whose shapes stand +aside like this (drone airspace, fire perimeters, quake discs, cables, +launches) register them with `registerCardBackground`, and a live top CCTV card +acts over any shape `isCardBackground` names; unknown identified objects and +registered foreign owners still block it. An empty-map click keeps its existing +deselection behavior. Air quality (`./layers/air-quality`) draws its station discs as one renderer draw set of ground-clamped fills and reads the view through the camera port; it diff --git a/scripts/format-scope.json b/scripts/format-scope.json index 1069652db2..e41531fc57 100644 --- a/scripts/format-scope.json +++ b/scripts/format-scope.json @@ -435,6 +435,8 @@ "src/layers/earthquakes/source.js", "src/layers/earthquakes/ownership.test.mjs", "src/layers/earthquakes/selection.test.mjs", + "src/layers/submarineCables/interaction.test.mjs", + "src/layers/launches/clickYield.test.mjs", "src/app/layers/earthquakeRipples.js", "src/app/layers/earthquakeRipples.test.mjs", "src/layers/perimeters/index.js", diff --git a/src/app/layers/rocketLaunches.js b/src/app/layers/rocketLaunches.js index af60bd3b62..44ed64ead6 100644 --- a/src/app/layers/rocketLaunches.js +++ b/src/app/layers/rocketLaunches.js @@ -2,11 +2,12 @@ import { createRocketLaunchesLayer } from '../../layers/launches/index.js'; import * as geometry from '../../celestialRing.js'; import * as overlays from '../../overlays/worldOverlay.js'; import * as render from '../../renderGovernor.js'; +import * as picking from '../../data/pickRegistry.js'; /** Construct one layer using the application scene owners and a supplied source. */ export function createApplicationLaunches({ source, satellites }) { return createRocketLaunchesLayer({ source, - services: { satellites, geometry, overlays, render }, + services: { satellites, geometry, overlays, render, picking }, }); } diff --git a/src/app/layers/submarineCables.js b/src/app/layers/submarineCables.js index 1f6dd7d817..5b19b8cf10 100644 --- a/src/app/layers/submarineCables.js +++ b/src/app/layers/submarineCables.js @@ -1,9 +1,13 @@ import { createSubmarineCableLayer } from '../../layers/submarineCables/index.js'; import { overlayHost } from './overlayHost.js'; +import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; +import * as picking from '../../data/pickRegistry.js'; /** Wire cable source geometry to the application overlay host. */ export function createApplicationCables(options) { return createSubmarineCableLayer({ - overlayHost, + // Hit-testing lets a card painted over a cable keep its click. + overlayHost: { ...overlayHost, hitTest: hitTestWorldOverlay }, + picking, mapStackEventTarget: typeof window !== 'undefined' ? window : null, ...options, }); diff --git a/src/data/cctv.test.mjs b/src/data/cctv.test.mjs index 35a634c6cf..4fb15c6903 100644 --- a/src/data/cctv.test.mjs +++ b/src/data/cctv.test.mjs @@ -1022,10 +1022,6 @@ test('CCTV repeated in-world clicks dispatch focus only for the one real activat componentFunctionSource(cctvLayer.init), /_cctvOverlayHost\.hitTest/, ); - assert.match( - componentFunctionSource(cctvLayer.init), - /sourceId: CCTV_OVERLAY_SOURCE_ID/, - ); assert.match( componentFunctionSource(cctvLayer.init), /activateCctvCameraFromWorldClick\(cameraId, setActiveCamera\)/, @@ -1157,11 +1153,8 @@ test('CCTV empty-click gate excludes every identified scene object, ADJUST, and ); const initSource = componentFunctionSource(cctvLayer.init); - assert.ok( - initSource.indexOf('if (pickedId !== null) return') < - initSource.indexOf('_cctvOverlayHost.hitTest'), - 'every identified sibling must win before an overlapping CCTV card hit test', - ); + // The real init-bound click route, including identified-object barriers, + // is exercised in layers/cctv/lifecycle.test.mjs. assert.match(initSource, /activeCameraId: _activeCameraId/); assert.match(initSource, /calibrationMode: _calibrationMode/); }); diff --git a/src/data/directions.test.mjs b/src/data/directions.test.mjs index ddd144e81f..6657c0a27e 100644 --- a/src/data/directions.test.mjs +++ b/src/data/directions.test.mjs @@ -28,6 +28,8 @@ import { createApplicationDirectionsLayer, } from './directions.js'; import { GROUND_FLOOR_LIFT_M } from './groundFloor.js'; +import { isActedOnByOtherLayer, isOwnedByOtherLayer } from './pickRegistry.js'; +import { fakeInput } from '../input/testDoubles.mjs'; import { instructionFor } from './routeSteps.js'; import { setLocale } from '../i18n/index.js'; import { @@ -465,6 +467,45 @@ function ownershipFixture(t) { }); } +// Directions acts only on its maneuver steps. The route line and the A/B +// markers are passive picks: still not empty space to other layers, but a +// card painted over them (a quake card) keeps its click. +test('enabled, directions owns its picks and acts only on its steps', (t) => { + ownershipFixture(t); + const viewer = { + scene: { + pick: () => null, + canvas: { clientWidth: 100, clientHeight: 100 }, + }, + }; + const input = fakeInput(viewer); + t.after(() => input.destroy()); + directionsLayer.enable(viewer); + try { + for (const id of [ + 'directions:route', + 'directions:marker:a', + 'directions:step:3', + ]) + assert.equal(isOwnedByOtherLayer('earthquakes', id), true, id); + assert.equal( + isActedOnByOtherLayer('earthquakes', 'directions:route'), + false, + ); + assert.equal( + isActedOnByOtherLayer('earthquakes', 'directions:marker:a'), + false, + ); + assert.equal( + isActedOnByOtherLayer('earthquakes', 'directions:step:3'), + true, + ); + } finally { + directionsLayer.disable(viewer); + } + assert.equal(isOwnedByOtherLayer('earthquakes', 'directions:route'), false); +}); + test('placing an endpoint takes the pointer, and every exit path gives it back', (t) => { ownershipFixture(t); diff --git a/src/data/pickRegistry.js b/src/data/pickRegistry.js index 95243c02ee..e6807e1e7c 100644 --- a/src/data/pickRegistry.js +++ b/src/data/pickRegistry.js @@ -26,6 +26,19 @@ const isSurface = (hit) => !hit || hit.surface === true; /** @type {Map boolean>} layerId -> ownership predicate */ const _owners = new Map(); +/** + * Owners that claim picks but never act on a click on them (flight trails, a + * directions route line): `true` for all of an owner's picks, or a predicate + * naming which. Their picks are still not empty space to other layers. + * @type {Map boolean)>} + */ +const _passive = new Map(); +/** + * Layers whose shapes are background to any card painted over them: their + * click handlers stand aside under a card, so the card's layer may act there. + * @type {Map boolean>} + */ +const _cardBackgrounds = new Map(); /** * A hit's canonical pick id, for the ownership scan: its item's id. Layers' @@ -47,11 +60,17 @@ export function resolvePickId(hit) { * @param {string} layerId - Owning layer id (e.g. 'flights'). * @param {(pickedId: string) => boolean} predicate - Returns true when the * picked primitive/entity id belongs to this layer. + * @param {{passive?: boolean | ((pickedId: string) => boolean)}} [options] + * `passive`: the layer never acts on a click on these picks (all of them, + * or those the predicate names). See {@link isActedOnByOtherLayer}. * @returns {void} */ -export function registerPickOwner(layerId, predicate) { +export function registerPickOwner(layerId, predicate, { passive } = {}) { if (!layerId || typeof predicate !== 'function') return; _owners.set(layerId, predicate); + if (passive === true || typeof passive === 'function') + _passive.set(layerId, passive); + else _passive.delete(layerId); } /** @@ -61,6 +80,7 @@ export function registerPickOwner(layerId, predicate) { */ export function unregisterPickOwner(layerId) { _owners.delete(layerId); + _passive.delete(layerId); } /** @@ -99,6 +119,31 @@ export function isOwnedByOtherLayer(layerId, pickedId) { return false; } +/** + * True when some OTHER registered layer owns the picked id and acts on a + * click on it: {@link isOwnedByOtherLayer} without passive owners. A card + * painted over a passive pick (a flight trail) is still the card's click. + * @param {string} layerId - The asking layer's id (excluded from the scan). + * @param {string} pickedId - Picked primitive/entity id. + * @returns {boolean} + */ +export function isActedOnByOtherLayer(layerId, pickedId) { + if (!pickedId) return false; + for (const [ownerId, predicate] of _owners) { + if (ownerId === layerId) continue; + try { + if (!predicate(pickedId)) continue; + const passive = _passive.get(ownerId); + if (passive === true) continue; + if (typeof passive === 'function' && passive(pickedId)) continue; + return true; + } catch { + // a broken predicate must never break click handling + } + } + return false; +} + /** * Resolve a moving-contact click without letting map tiles hide a nearby touch * target. Exact picks always win; only a coarse primary pointer may expand a @@ -145,3 +190,43 @@ export function pickContact(query, position, options = {}) { } return picked; } + +/** + * Registers a layer's unowned shapes that stand aside for a card painted over + * them (its click handler returns when a world-overlay entry is on top). + * @param {string} layerId - Registering layer id. + * @param {(hit: import('../render/contract/query').Hit) => boolean} predicate + * True when a click's draw hit is one of this layer's shapes. + * @returns {void} + */ +export function registerCardBackground(layerId, predicate) { + if (!layerId || typeof predicate !== 'function') return; + _cardBackgrounds.set(layerId, predicate); +} + +/** + * Removes a layer's card-background predicate (call when its clicks stop). + * @param {string} layerId - Registering layer id. + * @returns {void} + */ +export function unregisterCardBackground(layerId) { + _cardBackgrounds.delete(layerId); +} + +/** + * True when a click's draw hit is a shape whose layer stands aside for a card + * painted over it, so that card may act on the click. + * @param {import('../render/contract/query').Hit|null|undefined} hit + * @returns {boolean} + */ +export function isCardBackground(hit) { + if (isSurface(hit)) return false; + for (const predicate of _cardBackgrounds.values()) { + try { + if (predicate(hit)) return true; + } catch { + // a broken predicate must never break click handling + } + } + return false; +} diff --git a/src/data/pickRegistry.test.mjs b/src/data/pickRegistry.test.mjs index 924c956692..bcc1876f07 100644 --- a/src/data/pickRegistry.test.mjs +++ b/src/data/pickRegistry.test.mjs @@ -15,8 +15,13 @@ import { registerPickOwner, unregisterPickOwner, isOwnedByOtherLayer, + isActedOnByOtherLayer, resolvePickId, pickContact, + findPickOwner, + registerCardBackground, + unregisterCardBackground, + isCardBackground, } from './pickRegistry.js'; // --------------------------------------------------------------------------- @@ -49,8 +54,11 @@ test('resolvePickId: the map and nothing → null', () => { // --------------------------------------------------------------------------- test('ownership: sibling layers recognize each other via String-coerced ids', () => { - const points = new Map([[25544, {}], [43013, {}]]); // satellites: numeric keys - const vessels = new Map([['367123450', {}]]); // AIS: string id keys + const points = new Map([ + [25544, {}], + [43013, {}], + ]); // satellites: numeric keys + const vessels = new Map([['367123450', {}]]); // AIS: string id keys registerPickOwner('satellites', (pickedId) => { const norad = Number(pickedId); return Number.isFinite(norad) && points.has(norad); @@ -58,9 +66,15 @@ test('ownership: sibling layers recognize each other via String-coerced ids', () registerPickOwner('ais-live-vessels', (pickedId) => vessels.has(pickedId)); try { // Flights asking about a satellite pick (raw numeric id → String upstream) - assert.equal(isOwnedByOtherLayer('flights', resolvePickId(item('sat:1', '25544'))), true); + assert.equal( + isOwnedByOtherLayer('flights', resolvePickId(item('sat:1', '25544'))), + true, + ); // Flights asking about a vessel pick (an icon row id: the vessel's id) - assert.equal(isOwnedByOtherLayer('flights', resolvePickId(item('ais:1', '367123450'))), true); + assert.equal( + isOwnedByOtherLayer('flights', resolvePickId(item('ais:1', '367123450'))), + true, + ); // A layer never owns its own pick via the sibling scan assert.equal(isOwnedByOtherLayer('satellites', '25544'), false); // Unknown ids belong to nobody @@ -73,7 +87,9 @@ test('ownership: sibling layers recognize each other via String-coerced ids', () }); test('ownership: a throwing predicate never breaks click handling', () => { - registerPickOwner('broken', () => { throw new Error('boom'); }); + registerPickOwner('broken', () => { + throw new Error('boom'); + }); registerPickOwner('cctv', (pickedId) => pickedId === 'atx-cam-3'); try { assert.equal(isOwnedByOtherLayer('flights', 'atx-cam-3'), true); @@ -121,6 +137,49 @@ function query(picked, drillPick = () => assert.fail('must not drill')) { }; } +test('ownership: passive owners still own their picks but act on none of them', () => { + registerPickOwner('test-trails', (id) => id.startsWith('trail:'), { + passive: true, + }); + registerPickOwner('test-route', (id) => id.startsWith('route:'), { + passive: (id) => !id.startsWith('route:step:'), + }); + registerPickOwner('test-plane', (id) => id === 'plane:1'); + registerPickOwner('test-broken', () => { + throw new Error('broken'); + }); + try { + assert.equal( + isOwnedByOtherLayer('cards', 'trail:9'), + true, + 'not empty space', + ); + assert.equal(isActedOnByOtherLayer('cards', 'trail:9'), false); + assert.equal(isActedOnByOtherLayer('cards', 'route:line'), false); + assert.equal(isActedOnByOtherLayer('cards', 'route:step:3'), true); + assert.equal(isActedOnByOtherLayer('cards', 'plane:1'), true); + assert.equal( + isActedOnByOtherLayer('test-plane', 'plane:1'), + false, + 'never the asker', + ); + assert.equal(isActedOnByOtherLayer('cards', null), false); + // Registering again without the option makes the owner act. + registerPickOwner('test-trails', (id) => id.startsWith('trail:')); + assert.equal(isActedOnByOtherLayer('cards', 'trail:9'), true); + // Unregistering drops the option with the predicate. + registerPickOwner('test-trails', (id) => id.startsWith('trail:'), { + passive: true, + }); + unregisterPickOwner('test-trails'); + registerPickOwner('test-trails', (id) => id.startsWith('trail:')); + assert.equal(isActedOnByOtherLayer('cards', 'trail:9'), true); + } finally { + for (const id of ['test-trails', 'test-route', 'test-plane', 'test-broken']) + unregisterPickOwner(id); + } +}); + test('touch contact pick expands only a surface miss, bounded to 8 hits in 14 CSS pixels', (t) => { primaryPointer(t, true); contactOwners(t); @@ -141,10 +200,14 @@ test("touch contact pick uses the click's own pick and drill", (t) => { contactOwners(t); const contact = item('flights:1', 'civil'); const asked = []; - const found = pickContact(query(null), { x: 1, y: 1 }, { - picked: null, - drill: (...args) => (asked.push(args), [contact]), - }); + const found = pickContact( + query(null), + { x: 1, y: 1 }, + { + picked: null, + drill: (...args) => (asked.push(args), [contact]), + }, + ); assert.equal(found, contact); assert.deepEqual(asked, [[8, 14, 14]]); }); @@ -177,7 +240,13 @@ test('touch expansion stops at an unowned item and respects the drill bound', (t [...Array(8).fill(item('notes:1', 'x')), item('flights:1', 'civil')], [], ]) - assert.equal(pickContact(query(SURFACE, () => hits), { x: 1, y: 1 }), SURFACE); + assert.equal( + pickContact( + query(SURFACE, () => hits), + { x: 1, y: 1 }, + ), + SURFACE, + ); }); test('fine primary pointers keep the exact mouse pick without a drill', (t) => { @@ -197,3 +266,23 @@ test('touch picking tolerates a failing drill and preserves empty sky', (t) => { ]) assert.equal(pickContact(query(null, drillPick), { x: 1, y: 1 }), null); }); + +test('card backgrounds: a registered shape, never the map, and safe to break', () => { + const shape = { set: 'zones:1:fills', id: 'zone:1', surface: false }; + assert.equal(isCardBackground(shape), false); + registerCardBackground('test-zones', (hit) => hit.set === shape.set); + registerCardBackground('test-broken', () => { + throw new Error('broken predicate'); + }); + try { + assert.equal(isCardBackground(shape), true); + assert.equal(isCardBackground({ ...shape, set: 'other:1' }), false); + assert.equal(isCardBackground({ surface: true }), false); + assert.equal(isCardBackground(null), false); + assert.equal(findPickOwner(shape.id), null, 'not an owner'); + } finally { + unregisterCardBackground('test-zones'); + unregisterCardBackground('test-broken'); + } + assert.equal(isCardBackground(shape), false); +}); diff --git a/src/data/trailRenderer.js b/src/data/trailRenderer.js index 06c8581318..1c8f6dc598 100644 --- a/src/data/trailRenderer.js +++ b/src/data/trailRenderer.js @@ -36,8 +36,12 @@ import { registerPickOwner } from './pickRegistry.js'; // plane being tracked. Claiming the 'gev-trail:' id namespace makes // isOwnedByOtherLayer() true for every layer — clicking a trail is a no-op // everywhere. Registered once at module load; the predicate is pure. -registerPickOwner('trails', (pickedId) => - String(pickedId).startsWith('gev-trail:'), +// Passive: no layer acts on a trail click, so a card painted over a trail +// still takes its click (isActedOnByOtherLayer). +registerPickOwner( + 'trails', + (pickedId) => String(pickedId).startsWith('gev-trail:'), + { passive: true }, ); /** @type {number} Uniquifier for trail set and line ids. */ diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index 233a2b38e7..fec21a0549 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -23,8 +23,13 @@ export function createLifecycle({ source, }) { const { activateCctvCameraFromWorldClick } = services.activation; - const { resolvePickId, registerPickOwner, unregisterPickOwner } = - services.picking; + const { + resolvePickId, + registerPickOwner, + unregisterPickOwner, + isOwnedByOtherLayer, + isCardBackground, + } = services.picking; const { onFocusTargetAppear } = services.focus; const { releaseContinuousRender } = services.render; @@ -401,23 +406,32 @@ export function createLifecycle({ ); return; } - // Any identified scene object owns this click even if its layer does not - // register a shared pick predicate. This keeps selectable siblings ahead - // of an overlapping CCTV card while ID-less globe/terrain/tile surfaces - // remain eligible for true empty-space deselection. - const pickedId = resolvePickId(picked); - if (pickedId !== null) return; - // Item A (owner round 2): the scene pick found no camera — try the - // painted ambient cards. The cards canvas is pointer-events:none (this - // handler owns the events), so a click landing on a card's rect selects - // its camera exactly like a click on the icon. Click positions - // and the recorded rects are both CSS px — direct comparison. - const cardId = layerState._cctvOverlayHost.hitTest( + // Cards use the last-painted top hit, never an obscured card from + // our own source. Actual camera icons above keep their normal route. + const cardHit = layerState._cctvOverlayHost.hitTest( event.screenPosition.x, event.screenPosition.y, - { sourceId: CCTV_OVERLAY_SOURCE_ID }, - )?.entryId; - if (cardId && layerState._recordById.has(cardId)) { + {}, + ); + const cardId = + cardHit?.sourceId === CCTV_OVERLAY_SOURCE_ID && + layerState._recordById.has(cardHit.entryId) + ? cardHit.entryId + : null; + const pickedId = resolvePickId(picked); + const hit = event.drawHit; + // A live top CCTV card acts over shapes whose layers stand aside + // for a painted card (drone zones, fire perimeters, quake discs, + // cables, launch markers), as each registers them. Unknown + // identified objects and registered owners remain barriers. + const cardBackground = + cardId && + typeof pickedId === 'string' && + !isOwnedByOtherLayer?.('cctv', pickedId) && + Boolean(isCardBackground?.(hit)); + if (pickedId !== null && !cardBackground) return; + if (cardHit && cardHit.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; + if (cardId) { activateCctvCameraFromWorldClick( cardId, parts.selection.setActiveCamera, diff --git a/src/layers/cctv/lifecycle.test.mjs b/src/layers/cctv/lifecycle.test.mjs index 205997721b..c1ffdb4da8 100644 --- a/src/layers/cctv/lifecycle.test.mjs +++ b/src/layers/cctv/lifecycle.test.mjs @@ -1,6 +1,10 @@ import { test } from 'node:test'; import assert from 'node:assert/strict'; import { createLifecycle } from './lifecycle.js'; +import { createSelection } from './selection.js'; +import { CCTV_OVERLAY_SOURCE_ID } from '../../data/cctvCards.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; import { bindRenderer } from '../../render/rendererOf.js'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; @@ -72,3 +76,130 @@ test('the view listeners follow the camera port and let go on teardown', () => { assert.deepEqual(counts(second.camera), [0, 0]); assert.equal(state._viewListenerCamera, null); }); + +test('world clicks respect the painted top card and registered card backgrounds', async (t) => { + const noop = () => {}; + const { viewer } = viewerWithCamera(); + let picked = null; + viewer.scene = { + canvas: {}, + pick: () => (picked ? { id: picked } : undefined), + }; + const input = fakeInput(viewer); + const ownCard = { sourceId: CCTV_OVERLAY_SOURCE_ID, entryId: 'cam-1' }; + const foreignCard = { + sourceId: 'earthquake-card', + entryId: 'earthquake-card:qa', + }; + let painted = []; + const actions = []; + const state = { + _cctvOverlayHost: { + hitTest: (_x, _y, options = {}) => + painted.find( + (hit) => !options.sourceId || hit.sourceId === options.sourceId, + ) ?? null, + }, + }; + const parts = { + calibration: { loadCalibrationStore: () => new Map() }, + catalog: { + loadCameraSources: async () => [], + buildCatalogFromSources: () => [], + seedCatalog: () => [], + }, + ground: { + resolveGroundPriors: async () => [], + currentSurfaceRegime: () => 'terrain-globe', + }, + cards: { teardownAmbientCards: noop }, + projection: { clearProjectionOverlay: noop }, + geometryQueue: { stopGeometryLoadQueue: noop }, + rendering: { + createCameraIcons: noop, + refreshHorizonCulling: () => false, + refreshCoverageStyles: noop, + extractPickedCameraId: (hit) => + hit?.set === 'cctv:fixture' ? hit.id : null, + }, + hover: { handleHoverMove: noop }, + health: { syncHealthState: async () => {} }, + presentation: { notifyListeners: noop }, + }; + const services = { + sprites: {}, + focus: {}, + render: {}, + picking, + activation: { activateCctvCameraFromWorldClick: (id) => actions.push(id) }, + }; + parts.selection = createSelection({ state, services, parts }); + parts.selection.deactivateActiveCamera = () => actions.push('clear'); + const lifecycle = createLifecycle({ state, services, parts }); + t.after(() => { + state._clickSubscription?.(); + lifecycle.detachViewListeners(); + input.destroy(); + picking.unregisterPickOwner('area-control'); + picking.unregisterCardBackground('area-fixture'); + }); + await lifecycle.methods.init(viewer); + state._enabled = true; + state._activeCameraId = 'cam-1'; + state._recordById.set('cam-1', { camera: { id: 'cam-1' } }); + const click = (hit, cards, expected) => { + picked = hit; + painted = cards; + actions.length = 0; + input.tap(); + assert.deepEqual(actions, expected, JSON.stringify({ hit, cards })); + }; + const drone = { + set: 'drone-airspace:1:fills', + id: 'drone-airspace:zone:0', + surface: false, + }; + const perimeter = { + set: 'fire-perimeters:1:lines', + id: 'fire-perimeter:incident:0', + surface: false, + }; + const quake = { set: 'earthquakes:1', id: 'earthquake:q1', surface: false }; + const cable = { set: 'submarine-cables:1:lines', id: 'c:0', surface: false }; + const launch = { + set: 'launches:1:markers', + id: 'rocket-x:1', + surface: false, + }; + const backgrounds = [drone, perimeter, quake, cable, launch]; + // Each of those layers registers its own shapes this way (their tests + // check the real predicates); CCTV only asks the registry. + picking.registerCardBackground('area-fixture', (hit) => + backgrounds.some((b) => b.set === hit.set && b.id === hit.id), + ); + for (const area of backgrounds) { + click(area, [ownCard], ['cam-1']); + click(area, [], []); + click(area, [foreignCard, ownCard], []); + } + for (const hit of [ + { set: 'flights:1', id: 'aircraft', surface: false }, + { set: '', id: 'unregistered-local-entity', surface: false }, + { set: '', id: '', surface: false }, + { ...drone, set: 'unrelated:1:fills' }, + { ...drone, id: 'unregistered-local-entity' }, + ]) + click(hit, [ownCard], []); + picking.registerPickOwner('area-control', (id) => id === drone.id); + click(drone, [ownCard], []); + picking.unregisterPickOwner('area-control'); + click(null, [foreignCard, ownCard], []); + click(null, [ownCard], ['cam-1']); + click(null, [], ['clear']); + click(drone, [{ ...ownCard, entryId: 'stale-camera' }], []); + click( + { set: 'cctv:fixture', id: 'cam-1' }, + [foreignCard, ownCard], + ['cam-1'], + ); +}); diff --git a/src/layers/directions/index.js b/src/layers/directions/index.js index 54ec30c095..873eac5041 100644 --- a/src/layers/directions/index.js +++ b/src/layers/directions/index.js @@ -1672,10 +1672,13 @@ export function createDirectionsLayer({ services, source }) { _overlayHost.setVisible(DIRECTIONS_STEP_OVERLAY_SOURCE_ID, true); _overlayHost.setVisible(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID, true); _installClickHandler(viewer); + // Only the maneuver steps act on a click; the route line and the A/B + // markers are passive, so a card painted over them keeps its click. services.picking.registerPickOwner( 'directions', (pickedId) => typeof pickedId === 'string' && pickedId.startsWith('directions:'), + { passive: (pickedId) => !pickedId.startsWith('directions:step:') }, ); syncRenderHold(); }, diff --git a/src/layers/droneAirspace/index.js b/src/layers/droneAirspace/index.js index 2e64bafd37..1e359b8d9b 100644 --- a/src/layers/droneAirspace/index.js +++ b/src/layers/droneAirspace/index.js @@ -129,25 +129,26 @@ export function createDroneAirspaceLayer({ // so claiming these large ground polygons would make FIRMS/vessel/CCTV // cards inert anywhere over a zone. Unowned, our picks read as // "empty space" to siblings — the same contract as fire perimeters. + // Our shapes stand aside for a card painted over them (below), so that + // card's layer may act on the click; without a hit-test they cannot. + if (overlayHost?.hitTest) + picking?.registerCardBackground?.( + layer.id, + (hit) => pickedZoneId(hit) !== null, + ); _clickSubscription = inputFor(_viewer).onClick((event) => { const cardHit = overlayHost.hitTest?.( event.screenPosition?.x, event.screenPosition?.y, - { sourceId: DRONE_AIRSPACE_OVERLAY_SOURCE_ID }, ); + // Only the top painted card owns the click; this area's shapes are + // background when another layer has painted a card or label over them. + if (cardHit && cardHit.sourceId !== DRONE_AIRSPACE_OVERLAY_SOURCE_ID) + return; if (cardHit && cardHit.entryId === _selectedCardId) return; const picked = event.topHit; const zoneId = picked ? pickedZoneId(event.drawHit) : null; if (zoneId) { - // Another layer's card or label painted over the zone (a quake's - // card or magnitude label, a fire card) is that layer's click: under - // it the zone is background, as it is to siblings, so it stays as is. - const top = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - {}, - ); - if (top && top.sourceId !== DRONE_AIRSPACE_OVERLAY_SOURCE_ID) return; _selectedId = zoneId; publishSelectedCard(); return; @@ -166,6 +167,7 @@ export function createDroneAirspaceLayer({ function removeClickHandler() { _clickSubscription?.(); _clickSubscription = null; + picking?.unregisterCardBackground?.(layer.id); } function clearSelection() { diff --git a/src/layers/droneAirspace/ownership.test.mjs b/src/layers/droneAirspace/ownership.test.mjs index b6e4cbdcb2..306fd32c55 100644 --- a/src/layers/droneAirspace/ownership.test.mjs +++ b/src/layers/droneAirspace/ownership.test.mjs @@ -17,6 +17,7 @@ const liveSet = (draw, suffix) => function harness(source, { pick = () => null, cardHit = () => null } = {}) { const overlay = { entries: new Map(), visible: null }; const owners = new Map(); + const backgrounds = new Map(); const viewer = { scene: { pick } }; const { draw } = bindFakeDraw(viewer); const input = fakeInput(viewer); @@ -47,6 +48,9 @@ function harness(source, { pick = () => null, cardHit = () => null } = {}) { String(pickedId).startsWith('other-layer:'), registerPickOwner: (layerId, predicate) => owners.set(layerId, predicate), unregisterPickOwner: (layerId) => owners.delete(layerId), + registerCardBackground: (layerId, predicate) => + backgrounds.set(layerId, predicate), + unregisterCardBackground: (layerId) => backgrounds.delete(layerId), }, }); layer.init(viewer); @@ -61,6 +65,7 @@ function harness(source, { pick = () => null, cardHit = () => null } = {}) { overlay, clicks, owners, + backgrounds, }; } @@ -153,6 +158,8 @@ test("another layer's overlay on top keeps a click off the area", async () => { { pick: () => pickResult, // Unfiltered: the topmost entry of any source. + // As the host does: drone-airspace cards are not interactive, so only + // another layer's card painted on top is ever hit. cardHit: (_x, _y, options) => foreignOnTop && !options?.sourceId ? { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' } @@ -171,13 +178,20 @@ test("another layer's overlay on top keeps a click off the area", async () => { h.overlay.entries.get('drone-airspace')[0].id, 'drone-airspace-card:310', ); - // An overlay on top never clears an existing selection either. + // An overlay on top covers the selected area's card. foreignOnTop = true; h.clicks.handler({ position: { x: 10, y: 10 } }); assert.equal( h.overlay.entries.get('drone-airspace')[0].id, 'drone-airspace-card:310', ); + pickResult = null; + h.clicks.handler({ position: { x: 10, y: 10 } }); + assert.equal( + h.overlay.entries.get('drone-airspace')[0].id, + 'drone-airspace-card:310', + 'the foreground overlay preserves selection over bare map too', + ); }); test('late refresh cannot publish after disable or destroy', async () => { @@ -270,3 +284,21 @@ test('a boundary change alone redraws the zone; identical geometry does not', as assert.notDeepEqual(redrawn.positions, first.positions); assert.ok(h.layer.getAnalystRecords()[0].lon > -76.6); }); + +// A card painted over the area may act there (a live CCTV card): the layer +// names its own drawn shapes, and only while it takes clicks. +test('enabled, the zone shapes register as card background', async () => { + const h = harness({ getSnapshot: async () => [row] }); + await h.layer.update(h.viewer); + const isBackground = h.backgrounds.get('drone-airspace'); + const own = { + set: h.fills().spec.id, + id: 'drone-airspace:310:0', + surface: false, + }; + assert.equal(isBackground(own), true); + assert.equal(isBackground({ ...own, set: 'other:1:fills' }), false); + assert.equal(isBackground({ ...own, id: 'other-layer:x' }), false); + h.layer.disable(h.viewer); + assert.equal(h.backgrounds.has('drone-airspace'), false); +}); diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index cd4b0ca1c3..898ea6c9a5 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -60,7 +60,11 @@ let instances = 0; * the card be clicked). * @param {(viewer: object) => {onClick: Function}} [options.input] The * viewer's click dispatcher. - * @param {{resolvePickId: Function, isOwnedByOtherLayer: Function}} [options.picking] + * @param {{resolvePickId: Function, isOwnedByOtherLayer: Function, + * isActedOnByOtherLayer?: Function, registerCardBackground?: Function, + * unregisterCardBackground?: Function}} [options.picking] The pick + * registry; with the card-background pair, a card painted over a disc + * (a CCTV card) may act on the click. * @param {{registerEntityContext: Function, selectEntityContext: Function, * clearSelectedEntityContextForLayer: Function, * getContextStore: Function}} [options.context] Shared selection store. @@ -319,6 +323,14 @@ export function createEarthquakesLayer({ clicks = null; } if (!clicks) return; + // Our discs stand aside for another layer's card painted over them + // (below), so that card's layer may act on the click; without a + // hit-test they cannot. + if (overlayHost?.hitTest) + picking.registerCardBackground?.( + EARTHQUAKES_LAYER_ID, + (hit) => pickedEvent(hit) !== null, + ); _clickHandler = clicks.onClick((click) => { if (!_enabled || (pointer && !pointer.isPointerFree())) return; const at = click.screenPosition; @@ -331,14 +343,16 @@ export function createEarthquakesLayer({ topEntry.sourceId !== EARTHQUAKE_OVERLAY_SOURCE_ID ) return; - // Another layer's pick (an aircraft, a camera) is not this layer's, - // even under this layer's card or a magnitude label: that layer acts - // on the click itself, and this card stays. Checked before the card - // and the labels, as the fire layer does. + // Another layer's pick that it acts on (an aircraft, a camera) is not + // this layer's, even under this layer's card or a magnitude label: + // that layer takes the click, and this card stays. A passive owner's + // pick (a flight trail, a directions route) acts for nobody, so the + // card or label over it keeps the click. const hit = click.hit; const pickId = picking.resolvePickId(hit); - if (pickId && picking.isOwnedByOtherLayer(EARTHQUAKES_LAYER_ID, pickId)) - return; + const actedOn = + picking.isActedOnByOtherLayer ?? picking.isOwnedByOtherLayer; + if (pickId && actedOn(EARTHQUAKES_LAYER_ID, pickId)) return; const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID, }); @@ -355,6 +369,10 @@ export function createEarthquakesLayer({ selectAndFocus(labelHit.entryId); return; } + // A passive owner's pick with nothing of ours over it is still not + // empty space: leave the selection alone, as every layer does. + if (pickId && picking.isOwnedByOtherLayer(EARTHQUAKES_LAYER_ID, pickId)) + return; const event = pickedEvent(hit); if (event) { _selectedId = event.stableId; @@ -383,6 +401,7 @@ export function createEarthquakesLayer({ function removeClickHandler() { _clickHandler?.(); _clickHandler = null; + picking?.unregisterCardBackground?.(EARTHQUAKES_LAYER_ID); } const layer = { diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index ad8765b05d..528ff6fbe3 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -2,6 +2,8 @@ import assert from 'node:assert/strict'; import test from 'node:test'; import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs'; import * as picking from '../../data/pickRegistry.js'; +// Registers the shared `gev-trail:` owner as passive, as the app does. +import '../../data/trailRenderer.js'; import { fakeInput } from '../../input/testDoubles.mjs'; import { createDroneAirspaceLayer } from '../droneAirspace/index.js'; import { @@ -250,12 +252,17 @@ test('a refresh keeps the selected quake while it is in the feed', async () => { h.layer.destroy(); }); -test('disable removes the click handler and the card', async () => { +test('disable removes the click handler, card background and the card', async () => { const h = harness([quake('ak1')]); h.layer.enable(h.viewer); await h.layer.update(h.viewer); h.clickDisc('ak1'); + // A drawn disc is background to a card painted over it (a CCTV card). + const disc = { set: h.discs().spec.id, id: 'earthquake:ak1' }; + assert.equal(picking.isCardBackground(disc), true); + assert.equal(picking.isCardBackground({ ...disc, set: 'other:1' }), false); h.layer.disable(h.viewer); + assert.equal(picking.isCardBackground(disc), false); assert.deepEqual(h.lastCard(), []); assert.equal( h.handlers.every((handler) => handler.destroyed), @@ -878,3 +885,49 @@ test('quake card and label work over pickable items no layer acts on', async () h.layer.destroy(); } }); + +// Flight trails and a directions route line are registered owners that act +// on no click. Under the quake card or a magnitude label they must not make +// the click dead; a layer that acts (an aircraft) still takes it. +test('quake card and label act over a flight trail and a directions route', async () => { + const h = harness([quake('ak1'), quake('ak2', { mag: 4 })]); + picking.registerPickOwner( + 'test-directions', + (id) => String(id).startsWith('directions:'), + { passive: (id) => !id.startsWith('directions:step:') }, + ); + picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + h.clickDisc('ak1'); + const trail = { set: 'trail:1:lines', id: 'gev-trail:fl-a1b2c3:head' }; + const route = { set: 'directions:1:route', id: 'directions:route' }; + assert.equal(picking.findPickOwner(trail.id), 'trails'); + h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, 'earthquake-card:ak1', trail); + h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, 'earthquake-card:ak1', route); + assert.equal(h.opened.length, 2, 'the card opens USGS over both'); + h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', trail); + assert.equal(h.focused.at(-1)?.id, 'earthquake:ak2', 'the label flies'); + // A route step acts for directions: it takes the click. + const focusedBefore = h.focused.length; + h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak1', { + set: 'directions:1:steps', + id: 'directions:step:2', + }); + assert.equal(h.focused.length, focusedBefore, 'a step takes the click'); + // So does an aircraft under the card. + h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, 'earthquake-card:ak2', { + set: 'flights:1', + id: 'plane-9', + }); + assert.equal(h.opened.length, 2); + // A plain click on a trail is still not empty space: the card stays. + h.click(trail); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak2'); + } finally { + picking.unregisterPickOwner('test-directions'); + picking.unregisterPickOwner('test-plane'); + h.layer.destroy(); + } +}); diff --git a/src/layers/launches/clickYield.test.mjs b/src/layers/launches/clickYield.test.mjs new file mode 100644 index 0000000000..9004e10c19 --- /dev/null +++ b/src/layers/launches/clickYield.test.mjs @@ -0,0 +1,77 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { createLifecycle } from './lifecycle.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; + +/** Any part method is a no-op unless the test supplies it. */ +const stubs = (given = {}) => + new Proxy(given, { + get: (target, key) => (key in target ? target[key] : () => undefined), + }); + +// Mission overlays are not interactive: an overlay entry under the pointer is +// another layer's card or label painted over the mission (a quake label), and +// that layer takes the click, so the mission is not also selected. +test('a card painted over a launch marker keeps its click; with none the mission selects', () => { + const viewer = { + scene: { + pick: () => null, + canvas: { clientWidth: 100, clientHeight: 100 }, + }, + }; + const input = fakeInput(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + const selected = []; + const state = { _launches: [{ id: 'L1' }], _enabled: false }; + const { methods: lifecycle } = createLifecycle({ + state, + services: { + render: { holdContinuousRender() {}, releaseContinuousRender() {} }, + overlays: { hitTestWorldOverlay: () => top }, + picking, + }, + parts: { + panel: stubs(), + overlays: stubs(), + launchPad: stubs(), + orbitRendering: stubs(), + replay: stubs(), + ingestion: stubs(), + rendering: stubs({ + missionsShown: () => true, + missionHitsAt: () => [{ id: 'mission:L1' }], + launchIdFromPicks: (hits) => + hits.some((hit) => hit?.id === 'mission:L1') ? 'L1' : null, + }), + selection: stubs({ setSelectedMission: (id) => selected.push(id) }), + }, + source: {}, + }); + try { + // init installs the click handler; enable would start a feed load. + lifecycle.init(viewer); + state._enabled = true; + input.click(); + assert.deepEqual(selected, [], 'the mission stands aside'); + top = null; + input.click(); + assert.deepEqual( + selected, + ['L1'], + 'with no card on top, the mission selects', + ); + // So a card on top (a live CCTV card) may act over the mission instead. + const mission = { set: 'launches:1:markers', id: 'mission:L1' }; + assert.equal(picking.isCardBackground(mission), true); + assert.equal(picking.isCardBackground({ ...mission, id: 'x' }), false); + state._enabled = false; + assert.equal(picking.isCardBackground(mission), false); + state._inputSubscription(); + state._enabled = true; + assert.equal(picking.isCardBackground(mission), false); + } finally { + state._inputSubscription?.(); + input.destroy(); + } +}); diff --git a/src/layers/launches/lifecycle.js b/src/layers/launches/lifecycle.js index 5266763814..c326b78847 100644 --- a/src/layers/launches/lifecycle.js +++ b/src/layers/launches/lifecycle.js @@ -4,6 +4,8 @@ import { canvasOf, findCamera, findFrame } from '../../render/rendererOf.js'; import { worldClock } from '../../time/worldClock.js'; const HOVER_PICK_INTERVAL_MS = 120; +/** Our id in the pick registry's card backgrounds. */ +const CARD_BACKGROUND_ID = 'rocket-launches'; /** * Bound hover picking independently of precise click selection. A move inside @@ -200,8 +202,29 @@ export function createLifecycle({ layerState._orbitMatches = 0; parts.overlays.clearMissionOverlaySources(); const input = inputFor(viewer); + // Our mission items stand aside for a card painted over them (below), + // so that card's layer may act on the click; without a hit-test they + // cannot. + if (services.overlays?.hitTestWorldOverlay) + services.picking?.registerCardBackground?.( + CARD_BACKGROUND_ID, + (hit) => + layerState._enabled && + parts.rendering.missionsShown() && + parts.rendering.launchIdFromPicks([hit]) !== null, + ); const unsubscribeClick = input.onClick((event) => { if (!layerState._enabled || !parts.rendering.missionsShown()) return; + // Mission overlays are not interactive, so any overlay entry hit + // here is another layer's card or label painted over the click: that + // layer's click, not a mission's. + if ( + services.overlays?.hitTestWorldOverlay?.( + event.screenPosition?.x, + event.screenPosition?.y, + ) + ) + return; // The click's pick position (CSS px), as the click picked it. const launchId = parts.rendering.launchIdFromPicks( parts.rendering.missionHitsAt(event.position, 12), @@ -221,6 +244,7 @@ export function createLifecycle({ layerState._inputSubscription = () => { unsubscribeClick(); unsubscribeHover(); + services.picking?.unregisterCardBackground?.(CARD_BACKGROUND_ID); }; // Apply horizon visibility before the renderer draws and picks. // A postRender write is one frame late and can remain visibly stale when diff --git a/src/layers/perimeters/index.js b/src/layers/perimeters/index.js index 017e7ab46c..d973f8d6d7 100644 --- a/src/layers/perimeters/index.js +++ b/src/layers/perimeters/index.js @@ -215,14 +215,23 @@ export function createFirePerimetersLayer({ // so claiming these large ground polygons would make FIRMS/vessel/CCTV // cards inert anywhere over a perimeter. Unowned, our picks read as // "empty space" to siblings — the pre-existing behavior for the globe. + // Our shapes stand aside for a card painted over them (below), so that + // card's layer may act on the click; without a hit-test they cannot. + if (overlayHost?.hitTest) + picking?.registerCardBackground?.( + layer.id, + (hit) => pickedIncidentId(hit) !== null, + ); _clickSubscription = inputFor(_viewer).onClick((event) => { // A click on the incident card itself opens its InciWeb page (when the // incident has one) and never disturbs the selection. const cardHit = overlayHost.hitTest?.( event.screenPosition?.x, event.screenPosition?.y, - { sourceId: PERIMETER_OVERLAY_SOURCE_ID }, ); + // Only the top painted card owns the click; this area's shapes are + // background when another layer has painted a card or label over them. + if (cardHit && cardHit.sourceId !== PERIMETER_OVERLAY_SOURCE_ID) return; if (cardHit && cardHit.entryId === _selectedCardId) { if (_selectedLink && openExternal) openExternal(_selectedLink); return; @@ -230,15 +239,6 @@ export function createFirePerimetersLayer({ const picked = event.topHit; const incidentId = picked ? pickedIncidentId(event.drawHit) : null; if (incidentId) { - // Another layer's card or label painted over the perimeter (a - // quake's card or magnitude label, a fire card) is that layer's - // click: under it the perimeter is background, so it stays as is. - const top = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - {}, - ); - if (top && top.sourceId !== PERIMETER_OVERLAY_SOURCE_ID) return; abortLinkVerification(); _selectedId = incidentId; publishSelectedCard(); @@ -261,6 +261,7 @@ export function createFirePerimetersLayer({ function removeClickHandler() { _clickSubscription?.(); _clickSubscription = null; + picking?.unregisterCardBackground?.(layer.id); } function clearSelection() { diff --git a/src/layers/perimeters/ownership.test.mjs b/src/layers/perimeters/ownership.test.mjs index 9f11d5b177..bd0533a28b 100644 --- a/src/layers/perimeters/ownership.test.mjs +++ b/src/layers/perimeters/ownership.test.mjs @@ -27,6 +27,7 @@ function harness( ) { const overlay = { entries: new Map(), visible: null }; const owners = new Map(); + const backgrounds = new Map(); const opened = []; const viewer = { scene: { pick } }; const { draw } = bindFakeDraw(viewer); @@ -58,6 +59,9 @@ function harness( String(pickedId).startsWith('other-layer:'), registerPickOwner: (layerId, predicate) => owners.set(layerId, predicate), unregisterPickOwner: (layerId) => owners.delete(layerId), + registerCardBackground: (layerId, predicate) => + backgrounds.set(layerId, predicate), + unregisterCardBackground: (layerId) => backgrounds.delete(layerId), }, inciwebSource: inciwebIndex ? { getIndex: async () => inciwebIndex } @@ -77,6 +81,7 @@ function harness( overlay, clicks, owners, + backgrounds, opened, }; } @@ -316,12 +321,16 @@ test('a matched incident card carries the InciWeb line and click-through', async }, ]; let cardHitResult = null; + let foreignOnTop = false; const h = harness( { getSnapshot: async () => [{ ...row, name: 'Fixture' }] }, { pick: () => null, inciwebIndex, - cardHit: () => cardHitResult, + cardHit: (_x, _y, options) => + foreignOnTop && !options?.sourceId + ? { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' } + : cardHitResult, }, ); await h.layer.update(h.viewer); @@ -336,9 +345,15 @@ test('a matched incident card carries the InciWeb line and click-through', async const entries = h.overlay.entries.get('fire-perimeters'); assert.equal(entries[0].details.at(-1), 'InciWeb ↗ · click card to open'); - // Clicking the card itself opens the InciWeb page. - cardHitResult = { entryId: entries[0].id }; + // A selected card covered by a quake card cannot open its hidden link. + cardHitResult = { sourceId: 'fire-perimeters', entryId: entries[0].id }; h.viewer.scene.pick = () => null; + foreignOnTop = true; + h.clicks.handler({ position: { x: 12, y: 12 } }); + assert.deepEqual(h.opened, []); + assert.equal(h.overlay.entries.get('fire-perimeters')[0].id, entries[0].id); + // Removing the foreground card makes the incident card actionable again. + foreignOnTop = false; h.clicks.handler({ position: { x: 12, y: 12 } }); assert.deepEqual(h.opened, ['https://inciweb.wildfire.gov/node/329300']); assert.equal( @@ -365,7 +380,7 @@ test('an unmatched incident renders no InciWeb line and card clicks stay inert', entries[0].details.some((line) => line.includes('InciWeb')), false, ); - cardHitResult = { entryId: entries[0].id }; + cardHitResult = { sourceId: 'fire-perimeters', entryId: entries[0].id }; h.viewer.scene.pick = () => null; h.clicks.handler({ position: { x: 12, y: 12 } }); assert.deepEqual(h.opened, []); @@ -679,3 +694,21 @@ test('a failed refresh after a stale snapshot reads as the failure, not stale', assert.equal(h.layer.getStats().stale, false); assert.equal(h.layer.getStats().error, 'WFIGS HTTP 502'); }); + +// A card painted over the area may act there (a live CCTV card): the layer +// names its own drawn shapes, and only while it takes clicks. +test('enabled, the perimeter shapes register as card background', async () => { + const h = harness({ getSnapshot: async () => [row] }); + await h.layer.update(h.viewer); + const isBackground = h.backgrounds.get('fire-perimeters'); + const own = { + set: h.fills().spec.id, + id: 'fire-perimeter:2026-NMGNF-000123:0', + surface: false, + }; + assert.equal(isBackground(own), true); + assert.equal(isBackground({ ...own, set: 'other:1:fills' }), false); + assert.equal(isBackground({ ...own, id: 'other-layer:x' }), false); + h.layer.disable(h.viewer); + assert.equal(h.backgrounds.has('fire-perimeters'), false); +}); diff --git a/src/layers/submarineCables/index.js b/src/layers/submarineCables/index.js index e38e69bf31..de47082b0f 100644 --- a/src/layers/submarineCables/index.js +++ b/src/layers/submarineCables/index.js @@ -8,6 +8,7 @@ import { inputFor as defaultInputFor } from '../../input/dispatcher.js'; export function createSubmarineCableLayer({ source, overlayHost, + picking = null, inputFor = defaultInputFor, mapStackEventTarget = null, sweepClock = defaultSweepClock, @@ -23,6 +24,8 @@ export function createSubmarineCableLayer({ parts, source, inputFor, + overlayHost, + picking, mapStackEventTarget, }; parts.rendering = createRendering(context); diff --git a/src/layers/submarineCables/interaction.js b/src/layers/submarineCables/interaction.js index de7470da27..823020e16e 100644 --- a/src/layers/submarineCables/interaction.js +++ b/src/layers/submarineCables/interaction.js @@ -1,15 +1,40 @@ import { toRadians } from '../../geo/vector.js'; import { cameraOf } from '../../render/rendererOf.js'; -export function createInteraction({ state, parts, inputFor }) { +const CARD_BACKGROUND_ID = 'submarine-cables'; + +export function createInteraction({ + state, + parts, + inputFor, + overlayHost, + picking, +}) { function beginInteraction(viewer) { if (state._clickSubscription) return; - state._clickSubscription = inputFor(viewer).onClick((event) => { + // Our cables stand aside for a card painted over them (below), so that + // card's layer may act on the click; without a hit-test they cannot. + if (overlayHost?.hitTest) + picking?.registerCardBackground?.( + CARD_BACKGROUND_ID, + (hit) => state._enabled && Boolean(resolvePickRecord(hit)?.reference), + ); + const unsubscribe = inputFor(viewer).onClick((event) => { if (!state._enabled) return; + // Cable labels are not interactive, so any overlay entry hit here is + // another layer's card or label painted over the cable: its click. + if ( + overlayHost?.hitTest?.(event.screenPosition?.x, event.screenPosition?.y) + ) + return; const record = resolvePickRecord(event.drawHit); if (!record?.reference) return; flyToReference(viewer, record.reference); }); + state._clickSubscription = () => { + unsubscribe(); + picking?.unregisterCardBackground?.(CARD_BACKGROUND_ID); + }; } /** diff --git a/src/layers/submarineCables/interaction.test.mjs b/src/layers/submarineCables/interaction.test.mjs new file mode 100644 index 0000000000..79282c02e8 --- /dev/null +++ b/src/layers/submarineCables/interaction.test.mjs @@ -0,0 +1,89 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { createInteraction } from './interaction.js'; +import * as picking from '../../data/pickRegistry.js'; + +/** The cable click handler, with its click and overlay seams faked. */ +function harness({ overlayTop = null } = {}) { + let onClick = null; + const picked = []; + let top = overlayTop; + const interaction = createInteraction({ + state: { _enabled: true, _clickSubscription: null }, + parts: { + rendering: { + pickInfo: (hit) => { + picked.push(hit); + return null; + }, + }, + }, + inputFor: () => ({ + onClick: (fn) => { + onClick = fn; + return () => (onClick = null); + }, + }), + overlayHost: { hitTest: () => top }, + }); + interaction.beginInteraction({}); + return { + picked, + setTop: (next) => { + top = next; + }, + click: () => + onClick({ + screenPosition: { x: 5, y: 5 }, + drawHit: { set: 'c', id: 'x' }, + }), + }; +} + +// Cable labels are not interactive: an overlay entry under the pointer is +// another layer's card or label painted over the cable (a quake card), and +// that layer takes the click, so the cable does not also fly the camera. +test('a card painted over a cable keeps its click; with none the cable reads the pick', () => { + const h = harness({ + overlayTop: { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }, + }); + h.click(); + assert.equal(h.picked.length, 0, 'the cable stands aside'); + h.setTop(null); + h.click(); + assert.equal( + h.picked.length, + 1, + 'with no card on top, the cable reads its pick', + ); +}); + +// So a card on top (a live CCTV card) may act over the cable instead. +test('while it takes clicks, a drawn cable registers as card background', () => { + const state = { _enabled: true, _clickSubscription: null }; + const interaction = createInteraction({ + state, + parts: { + rendering: { + pickInfo: (hit) => + hit?.set === 'cables:1' ? { reference: { lon: 1, lat: 2 } } : null, + }, + }, + inputFor: () => ({ onClick: () => () => {} }), + overlayHost: { hitTest: () => null }, + picking, + }); + interaction.beginInteraction({}); + const cable = { set: 'cables:1', id: 'cable:0' }; + try { + assert.equal(picking.isCardBackground(cable), true); + assert.equal(picking.isCardBackground({ set: 'other:1', id: 'x' }), false); + state._enabled = false; + assert.equal(picking.isCardBackground(cable), false); + state._enabled = true; + state._clickSubscription(); + assert.equal(picking.isCardBackground(cable), false); + } finally { + state._clickSubscription?.(); + } +}); From 830c980ca6a60b7d812ab5f2a65728621f295c4c Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Tue, 17 Nov 2026 13:18:32 +0530 Subject: [PATCH 09/60] fix(touch): give each tap to the layer that acts on it On a coarse pointer the dispatcher can name a contact near the tap instead of the exact pick. Only flights, military, vessels, radio and Street Level act on such a contact, so they now register as expanded pick owners, and a quake card or label yields only to them. A FIRMS fire or CCTV camera reached only as a nearby contact no longer swallows a quake card, a quake label or a vessel's own card tap, and FIRMS and CCTV cards yield to a contact whose layer does act on it. Radio and Street Level also pick through their own windows. A station or Street Level item found only there, not as the touch contact, yields to another layer's card painted over it, and Street Level takes its own touch contact beyond its narrower window. Fire, CCTV and vessel cards now act over a passive owner's pick (a flight trail, the directions route), as the quake card does. The Context panel leaves a passive route, or a fire or camera reached only as a nearby contact, to the card painted over it. --- docs/CURRENT-STATE.md | 27 +++- scripts/format-scope.json | 2 + src/app/layers/streetLevel.js | 4 +- src/data/aisLiveVessels.test.mjs | 73 +++++++++- src/data/firmsInteraction.test.mjs | 115 +++++++++++++++ src/data/pickOwnerExpanded.test.mjs | 165 ++++++++++++++++++++++ src/data/pickRegistry.js | 25 +++- src/data/pickRegistry.test.mjs | 34 +++++ src/data/pickedContext.js | 28 +++- src/data/pickedContext.test.mjs | 52 ++++++- src/layers/cctv/lifecycle.js | 22 ++- src/layers/cctv/lifecycle.test.mjs | 35 +++++ src/layers/earthquakes/index.js | 6 +- src/layers/earthquakes/selection.test.mjs | 156 +++++++++++++++----- src/layers/firms/selection.js | 25 +++- src/layers/flights/lifecycle.js | 8 ++ src/layers/military/lifecycle.js | 8 ++ src/layers/news/layer.test.mjs | 6 +- src/layers/radio/interaction.js | 21 ++- src/layers/radio/interaction.test.mjs | 39 +++++ src/layers/streetLevel/selection.js | 25 +++- src/layers/streetLevel/selection.test.mjs | 135 ++++++++++++++++++ src/layers/vessels/lifecycle.js | 6 +- src/layers/vessels/selection.js | 38 ++++- src/ui/entityContextBridge.js | 8 +- src/ui/entityContextBridge.test.mjs | 101 +++++++++++++ 26 files changed, 1095 insertions(+), 69 deletions(-) create mode 100644 src/data/pickOwnerExpanded.test.mjs create mode 100644 src/ui/entityContextBridge.test.mjs diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 23029867b3..f492bedce2 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2055,6 +2055,25 @@ painted with a gradient fading to the outer circle and wavy contour lines clicks, picking, context, focus, the opener, the painter and the translator by injection (`src/app/layers/earthquakes.js`); without input and picking it draws and takes no clicks, and its labels stay non-interactive. +On a coarse pointer, a nearby FIRMS or CCTV icon that requires an exact hit +does not swallow a quake card or label tap, or a tap on a vessel's own card. +Owners that pick nearby contacts register as `expanded` pick owners: flights, +military aircraft, vessels, radio and Street Level, and a quake card or label +yields to one the shared touch contact (14 px) reaches. Flights, military and +vessels act on that contact, and so do radio and Street Level, which also pick +through their own windows (17 and 9 px). A station or Street Level item found +only through that window, not as the exact hit or the touch contact, yields to +another layer's card or label painted over it, so a quake card or label beside +one acts alone, with a mouse or a coarse pointer. Fire and CCTV cards in turn +yield to a touch contact whose layer acts on it. The aircraft a layer already +tracks and Street Level's position marker are passive picks, since a click on +either does nothing. Fire, CCTV and vessel cards, like the quake's, act over a +passive owner's pick (a flight trail, the directions route); with no card +there, that pick still leaves a selection alone. Context +(`src/ui/entityContextBridge.js`) names what a click identifies, except under a +world-overlay card or label when the item's owner does not act on that hit +(`cardKeepsClick` in `src/data/pickedContext.js`): a passive route, or a fire +or camera reached only as a nearby contact. The card takes that click. Quake discs are deliberately not registered in the pick-ownership registry, like drone airspace and fire perimeters: sibling layers read a disc as empty space, so their cards, near-miss taps and deselection work over a quake as @@ -2082,10 +2101,10 @@ card of these layers or clear their selection; a marker of theirs under that card is still theirs to select. Flight trails and the directions route line and markers are passive pick owners (`registerPickOwner(…, { passive })`): still not empty space (`isOwnedByOtherLayer`), but `isActedOnByOtherLayer` leaves -them out, so the quake card and magnitude labels act over them. Directions -selects only its maneuver steps, though any other click still clears a selected -step. Fire, vessel and CCTV cards over a trail or the route stay as they were -(no action). Submarine cables and rocket launches, whose own overlays are not +them out, so the quake card and magnitude labels act over them, as do fire, +vessel and CCTV cards. Directions selects only its maneuver steps, though any +other click still clears a selected step. Submarine cables and rocket +launches, whose own overlays are not interactive, stand aside when any overlay entry is under the click, so a card or label over a cable or a launch marker acts once. Layers whose shapes stand aside like this (drone airspace, fire perimeters, quake discs, cables, diff --git a/scripts/format-scope.json b/scripts/format-scope.json index 82643e508d..993e64a297 100644 --- a/scripts/format-scope.json +++ b/scripts/format-scope.json @@ -439,6 +439,8 @@ "src/layers/earthquakes/ownership.test.mjs", "src/layers/earthquakes/selection.test.mjs", "src/layers/submarineCables/interaction.test.mjs", + "src/data/pickOwnerExpanded.test.mjs", + "src/ui/entityContextBridge.test.mjs", "src/layers/launches/clickYield.test.mjs", "src/app/layers/earthquakeRipples.js", "src/app/layers/earthquakeRipples.test.mjs", diff --git a/src/app/layers/streetLevel.js b/src/app/layers/streetLevel.js index 3b7c7cc0b9..964d495300 100644 --- a/src/app/layers/streetLevel.js +++ b/src/app/layers/streetLevel.js @@ -6,6 +6,7 @@ import { createPanoramaxProvider } from '../../layers/streetLevel/providers/pano import * as picking from '../../data/pickRegistry.js'; import * as scenePick from '../../data/scenePick.js'; import * as render from '../../renderGovernor.js'; +import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; /** The browser Maps key the scene was started with (src/app/scene.js). */ const googleApiKey = () => globalThis.window?.__GOOGLE_MAPS_API_KEY__ || null; @@ -35,6 +36,7 @@ export function createApplicationStreetLevel({ }) { return createStreetLevelLayer({ providers, - services: { picking, scenePick, render }, + // Hit-testing lets a card painted over a near miss keep its click. + services: { picking, scenePick, render, overlayHit: hitTestWorldOverlay }, }); } diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs index b2ea95ceb1..25747f257c 100644 --- a/src/data/aisLiveVessels.test.mjs +++ b/src/data/aisLiveVessels.test.mjs @@ -1012,7 +1012,7 @@ function makeCesiumEvent() { }; } -function installWireHarness(picked, stateOverrides = {}) { +function installWireHarness(picked, stateOverrides = {}, sceneExtras = {}) { const hadWindow = Object.hasOwn(globalThis, 'window'); const hadDocument = Object.hasOwn(globalThis, 'document'); const priorWindow = globalThis.window; @@ -1038,7 +1038,7 @@ function installWireHarness(picked, stateOverrides = {}) { }, }; const viewer = { - scene: { pick: () => picked }, + scene: { pick: () => picked, ...sceneExtras }, }; const input = fakeInput(viewer); // The camera port other layers follow through, with no pose to read; its @@ -1993,6 +1993,75 @@ test('vessel interaction wire: a sibling-owned pick wins without selection mutat } }); +// A trail acts for nobody: the vessel's card painted over it still selects, +// and a bare trail pick stays a no-op that keeps the selection. +test('vessel interaction wire: a card over a trail selects; a bare trail is a no-op', () => { + for (const carded of [true, false]) { + const harness = installWireHarness( + { id: 'gev-trail:fl-a1b2c3:head' }, + { selectedRecord: null }, + ); + const requests = []; + harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => + requests.push(event.detail), + ); + _setVesselOverlayHostForTest( + hostWithCardHit(carded ? `vessel:${harness.record.mmsi}` : null), + ); + try { + harness.handler.click({ position: { x: 10, y: 20 } }); + assert.equal(requests.length, carded ? 1 : 0, `card: ${carded}`); + assert.equal( + aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, + carded ? harness.record.mmsi : null, + ); + } finally { + _setVesselOverlayHostForTest(null); + harness.cleanup(); + } + } +}); + +// A coarse tap on the vessel's card finds a fire nearby through the shared +// touch contact. The fire layer acts only on exact hits, so the card keeps the +// tap; an exact fire pick under the card still belongs to the fire. +test('vessel interaction wire: a coarse near miss of an exact-only item keeps the card tap', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const fire = 'fire:near-miss'; + registerPickOwner('test-exact-fires', (pickedId) => pickedId === fire); + t.after(() => unregisterPickOwner('test-exact-fires')); + for (const exact of [false, true]) { + const harness = installWireHarness( + exact ? { id: fire } : null, + { selectedRecord: null }, + { drillPick: () => [{ id: fire }] }, + ); + const requests = []; + harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => + requests.push(event.detail), + ); + _setVesselOverlayHostForTest( + hostWithCardHit(`vessel:${harness.record.mmsi}`), + ); + try { + harness.handler.click({ position: { x: 10, y: 20 } }); + assert.equal(requests.length, exact ? 0 : 1, `exact fire: ${exact}`); + assert.equal( + aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, + exact ? null : harness.record.mmsi, + ); + } finally { + _setVesselOverlayHostForTest(null); + harness.cleanup(); + } + } +}); + for (const card of ['live', 'stale', 'absent', 'covered']) { test(`vessel interaction wire: ${card} foreground card over registered cyclone`, () => { const id = 'cyclone:fixture:cone:0'; diff --git a/src/data/firmsInteraction.test.mjs b/src/data/firmsInteraction.test.mjs index 55413c1d85..0bdf158f98 100644 --- a/src/data/firmsInteraction.test.mjs +++ b/src/data/firmsInteraction.test.mjs @@ -63,6 +63,7 @@ function harness({ withDataSource = false, withGlobe = false, feed = null, + drilled = null, } = {}) { const hadWindow = Object.hasOwn(globalThis, 'window'); const priorWindow = globalThis.window; @@ -112,6 +113,7 @@ function harness({ const viewer = { scene: { pick, + ...(drilled ? { drillPick: () => drilled } : {}), canvas: { clientWidth: 1280, clientHeight: 800 }, camera: cameraPosition ? { positionWC: cameraPosition } : undefined, globe: { ellipsoid: Cesium.Ellipsoid.WGS84 }, @@ -162,6 +164,9 @@ function harness({ cover: (hit) => { topCard = hit; }, + setPicked: (next) => { + picked = next; + }, cleanup() { Cesium.SceneTransforms.worldToWindowCoordinates = priorProjection; if (hadWindow) globalThis.window = priorWindow; @@ -461,6 +466,116 @@ for (const [layerId, ownedId, picked] of SIBLING_PICKS) { }); } +// A passive owner's pick (a directions route, a flight trail) acts for nobody: +// a fire card over it still takes the click, and with no card the pick is +// still not empty space, so the selection stays. +test('a fire card acts over a passive pick; the bare pick leaves the selection', () => { + const fire = makeFire(); + registerPickOwner('test-route', (pickedId) => pickedId === 'route:line', { + passive: true, + }); + const carded = harness({ + fires: [fire], + picked: { id: 'route:line' }, + cardHit: `fire:${fireDetectionKey(fire)}`, + }); + try { + carded.click(); + assert.equal(carded.requests.length, 1, 'the card acts over the route'); + assert.ok(carded.layer.getSelectedInfo()); + } finally { + carded.cleanup(); + } + const bare = harness({ fires: [fire], picked: { id: 'route:line' } }); + try { + bare.click(); + assert.equal(bare.requests.length, 0); + assert.equal( + bare.layer.getSelectedInfo(), + null, + 'nothing to clear or pick', + ); + } finally { + bare.cleanup(); + unregisterPickOwner('test-route'); + } +}); + +// A coarse tap on a fire card finds an aircraft nearby through the shared +// touch contact. The flights layer acts on that contact, so the card yields: +// one action, not two. +test('a fire card yields to a touch contact its layer acts on', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const fire = makeFire(); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1', { + expanded: true, + }); + t.after(() => unregisterPickOwner('test-planes')); + const h = harness({ + fires: [fire], + drilled: [{ id: 'plane:1' }], + cardHit: `fire:${fireDetectionKey(fire)}`, + }); + try { + h.click(); + assert.equal(h.requests.length, 0, 'the aircraft takes the tap'); + assert.equal(h.layer.getSelectedInfo(), null); + } finally { + h.cleanup(); + } +}); + +// A touch contact whose layer acts only on exact hits does not take the tap +// from our card; with no card, a coarse tap near an aircraft still clears. +test('a fire card keeps a tap whose contact does not act; bare taps still clear', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const fire = makeFire(); + registerPickOwner('test-cameras', (pickedId) => pickedId === 'cam:1'); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1', { + expanded: true, + }); + t.after(() => { + unregisterPickOwner('test-cameras'); + unregisterPickOwner('test-planes'); + }); + const carded = harness({ + fires: [fire], + drilled: [{ id: 'cam:1' }], + cardHit: `fire:${fireDetectionKey(fire)}`, + }); + try { + carded.click(); + assert.equal(carded.requests.length, 1, 'the card acts'); + } finally { + carded.cleanup(); + } + const bare = harness({ + fires: [fire], + picked: glowPick('firms-7'), + drilled: [{ id: 'plane:1' }], + }); + try { + bare.click(); + assert.ok(bare.layer.getSelectedInfo(), 'a fire is selected'); + // Nothing exact now; the touch contact is an aircraft, with no card. + bare.setPicked(null); + bare.click(); + assert.equal(bare.layer.getSelectedInfo(), null, 'the bare tap clears'); + } finally { + bare.cleanup(); + } +}); + test('a stale card id resolves to nothing instead of an arbitrary fire', () => { const h = harness({ picked: { primitive: {}, content: {}, featureId: 0 }, diff --git a/src/data/pickOwnerExpanded.test.mjs b/src/data/pickOwnerExpanded.test.mjs new file mode 100644 index 0000000000..83ab4afa79 --- /dev/null +++ b/src/data/pickOwnerExpanded.test.mjs @@ -0,0 +1,165 @@ +/** + * Which pick owners select nearby contacts. A coarse tap's shared contact + * hit (`pickContact`) can land on a contact near an exact miss; only owners + * whose click handlers act on such a hit, or on their own pick window, + * register `expanded`, so a quake card or label yields to them and not to + * exact-only owners (FIRMS, CCTV). Each case runs the layer's own + * registration code (its enable or install step) with stand-in services. + */ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createLifecycle as createFlightLifecycle } from '../layers/flights/lifecycle.js'; +import { createLifecycle as createMilitaryLifecycle } from '../layers/military/lifecycle.js'; +import { createLifecycle as createVesselLifecycle } from '../layers/vessels/lifecycle.js'; +import { createInteraction as createRadioInteraction } from '../layers/radio/interaction.js'; +import { createSelection as createStreetSelection } from '../layers/streetLevel/selection.js'; +import { fakeInput } from '../input/testDoubles.mjs'; +import { STREET_LEVEL_LAYER_ID } from '../layers/streetLevel/policy.js'; +import * as picking from './pickRegistry.js'; + +/** + * A stand-in for any collaborator: every property is another stand-in and + * every call returns one, except the keys `given` names. Not a thenable. + */ +function stub(given = {}) { + return new Proxy(function stand() {}, { + get(target, key) { + if (key in given) return given[key]; + if (key === 'then' || typeof key === 'symbol') return undefined; + return stub(); + }, + set(target, key, value) { + given[key] = value; + return true; + }, + apply: () => stub(), + }); +} + +/** Picking services that record each registration's options. */ +function recordingPicking() { + const registered = new Map(); + return { + registered, + services: { + ...picking, + registerPickOwner(layerId, predicate, options) { + registered.set(layerId, options ?? {}); + picking.registerPickOwner(layerId, predicate, options); + }, + }, + }; +} + +function withDocument(t) { + const previous = globalThis.document; + globalThis.document = { + body: { classList: { contains: () => false } }, + addEventListener() {}, + removeEventListener() {}, + }; + t.after(() => { + if (previous === undefined) delete globalThis.document; + else globalThis.document = previous; + }); +} + +/** A quake card over `pickedId` reached as a nearby touch contact. */ +const actsOnNearbyHit = (pickedId) => + picking.isActedOnByOtherLayer('earthquakes', pickedId, { expanded: true }); + +for (const [name, layerId, create] of [ + ['flights', 'flights', createFlightLifecycle], + ['military', 'military', createMilitaryLifecycle], +]) { + test(`${name} registers its aircraft as acting on nearby touch hits`, (t) => { + withDocument(t); + const { registered, services } = recordingPicking(); + const flightState = stub({ + _icons: { show: false, has: (id) => id === `${name}-1` }, + records: { geoidReady: true }, + timeline: null, + _trackedIcao: null, + }); + const { methods: lifecycle } = create({ + flightState, + services: stub({ picking: services }), + parts: stub(), + layer: stub(), + resolveAsset: () => '', + }); + t.after(() => picking.unregisterPickOwner(layerId)); + lifecycle.enable({}); + assert.equal(registered.get(layerId)?.expanded, true); + assert.equal(actsOnNearbyHit(`${name}-1`), true); + // A click on the aircraft already tracked is ignored, so it is passive. + flightState._trackedIcao = `${name}-1`; + assert.equal(actsOnNearbyHit(`${name}-1`), false); + }); +} + +test('vessels register their icons as acting on nearby touch hits', (t) => { + withDocument(t); + const { registered, services } = recordingPicking(); + const state = { + feed: { enabled: true, sessionId: 1 }, + records: { byId: new Map([['vessel-1', {}]]) }, + viewer: {}, + }; + const created = createVesselLifecycle({ + vesselState: stub({ state, _geoidReady: true }), + services: stub({ picking: services }), + parts: stub(), + }); + const lifecycle = created.methods ?? created; + t.after(() => picking.unregisterPickOwner('ais-live-vessels')); + lifecycle.enable({}); + assert.equal(registered.get('ais-live-vessels')?.expanded, true); + assert.equal(actsOnNearbyHit('vessel-1'), true); +}); + +test('radio registers its stations as acting on nearby touch hits', (t) => { + const { registered, services } = recordingPicking(); + const viewer = { scene: { canvas: new EventTarget(), pick: () => null } }; + const input = fakeInput(viewer); + const state = { _viewer: viewer, _clickSubscription: null }; + const interaction = createRadioInteraction({ + state, + services: { picking: services, overlays: stub() }, + parts: stub(), + }); + t.after(() => { + interaction.removeInteraction(); + input.destroy(); + }); + interaction.installInteraction(); + assert.equal(registered.get('radio')?.expanded, true); + assert.equal(actsOnNearbyHit('radio:kexp'), true); + interaction.removeInteraction(); + assert.equal(actsOnNearbyHit('radio:kexp'), false); +}); + +test('Street Level registers its picks as acting on nearby touch hits', (t) => { + withDocument(t); + const { registered, services } = recordingPicking(); + const viewer = { scene: { canvas: new EventTarget(), pick: () => null } }; + const input = fakeInput(viewer); + const state = { services: { picking: services }, clickSubscription: null }; + const selection = createStreetSelection({ + state, + parts: stub({ + router: { + ownsPick: (id) => id === 'mly:seq-1', + resolve: (id) => (id === 'mly:seq-1' ? { id, instance: {} } : null), + }, + }), + }); + t.after(() => { + state.clickSubscription?.(); + picking.unregisterPickOwner(STREET_LEVEL_LAYER_ID); + input.destroy(); + }); + selection.install(viewer); + assert.equal(registered.get(STREET_LEVEL_LAYER_ID)?.expanded, true); + assert.equal(actsOnNearbyHit('mly:seq-1'), true); +}); diff --git a/src/data/pickRegistry.js b/src/data/pickRegistry.js index e6807e1e7c..b16264f71f 100644 --- a/src/data/pickRegistry.js +++ b/src/data/pickRegistry.js @@ -33,6 +33,8 @@ const _owners = new Map(); * @type {Map boolean)>} */ const _passive = new Map(); +/** Owners whose click handlers also select nearby contacts. */ +const _expanded = new Set(); /** * Layers whose shapes are background to any card painted over them: their * click handlers stand aside under a card, so the card's layer may act there. @@ -60,14 +62,22 @@ export function resolvePickId(hit) { * @param {string} layerId - Owning layer id (e.g. 'flights'). * @param {(pickedId: string) => boolean} predicate - Returns true when the * picked primitive/entity id belongs to this layer. - * @param {{passive?: boolean | ((pickedId: string) => boolean)}} [options] + * @param {{passive?: boolean | ((pickedId: string) => boolean), expanded?: boolean}} [options] * `passive`: the layer never acts on a click on these picks (all of them, * or those the predicate names). See {@link isActedOnByOtherLayer}. + * `expanded`: preserve precedence for handlers that select nearby contacts, + * through the shared contact hit or their own pick window. * @returns {void} */ -export function registerPickOwner(layerId, predicate, { passive } = {}) { +export function registerPickOwner( + layerId, + predicate, + { passive, expanded = false } = {}, +) { if (!layerId || typeof predicate !== 'function') return; _owners.set(layerId, predicate); + if (expanded) _expanded.add(layerId); + else _expanded.delete(layerId); if (passive === true || typeof passive === 'function') _passive.set(layerId, passive); else _passive.delete(layerId); @@ -80,6 +90,7 @@ export function registerPickOwner(layerId, predicate, { passive } = {}) { */ export function unregisterPickOwner(layerId) { _owners.delete(layerId); + _expanded.delete(layerId); _passive.delete(layerId); } @@ -125,12 +136,18 @@ export function isOwnedByOtherLayer(layerId, pickedId) { * painted over a passive pick (a flight trail) is still the card's click. * @param {string} layerId - The asking layer's id (excluded from the scan). * @param {string} pickedId - Picked primitive/entity id. + * @param {{expanded?: boolean}} [options] A nearby rather than exact hit: + * only owners whose handlers select nearby contacts take precedence. * @returns {boolean} */ -export function isActedOnByOtherLayer(layerId, pickedId) { +export function isActedOnByOtherLayer( + layerId, + pickedId, + { expanded = false } = {}, +) { if (!pickedId) return false; for (const [ownerId, predicate] of _owners) { - if (ownerId === layerId) continue; + if (ownerId === layerId || (expanded && !_expanded.has(ownerId))) continue; try { if (!predicate(pickedId)) continue; const passive = _passive.get(ownerId); diff --git a/src/data/pickRegistry.test.mjs b/src/data/pickRegistry.test.mjs index bcc1876f07..1a27752646 100644 --- a/src/data/pickRegistry.test.mjs +++ b/src/data/pickRegistry.test.mjs @@ -158,6 +158,40 @@ test('ownership: passive owners still own their picks but act on none of them', assert.equal(isActedOnByOtherLayer('cards', 'route:line'), false); assert.equal(isActedOnByOtherLayer('cards', 'route:step:3'), true); assert.equal(isActedOnByOtherLayer('cards', 'plane:1'), true); + assert.equal( + isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), + false, + ); + registerPickOwner('test-plane', (id) => id === 'plane:1', { + expanded: true, + }); + assert.equal( + isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), + true, + ); + registerPickOwner('test-plane', (id) => id === 'plane:1', { + expanded: true, + passive: true, + }); + assert.equal( + isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), + false, + ); + registerPickOwner('test-plane', (id) => id === 'plane:1'); + assert.equal( + isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), + false, + ); + registerPickOwner('test-plane', (id) => id === 'plane:1', { + expanded: true, + }); + unregisterPickOwner('test-plane'); + registerPickOwner('test-plane', (id) => id === 'plane:1'); + assert.equal( + isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), + false, + ); + assert.equal( isActedOnByOtherLayer('test-plane', 'plane:1'), false, diff --git a/src/data/pickedContext.js b/src/data/pickedContext.js index 8957c5a24b..ed23d093ff 100644 --- a/src/data/pickedContext.js +++ b/src/data/pickedContext.js @@ -1,6 +1,10 @@ import { getContextStore, isContextRecordActive } from './contextStore.js'; import { readEntityRecord } from './entityRecords.js'; -import { findPickOwner, resolvePickId } from './pickRegistry.js'; +import { + findPickOwner, + isActedOnByOtherLayer, + resolvePickId, +} from './pickRegistry.js'; /** * Resolve a pick (the contract's `Hit`, as `pickAt` in @@ -123,3 +127,25 @@ export function resolvePickedContext(picked, { dataManager = null } = {}) { altitudeM: finite(found?.altitudeM), }; } + +/** + * Whether a world-overlay card or label under a click keeps it from the item + * the click names, because that item's owner does not act on this hit: a + * passive owner (a directions route) acts on none, and an owner that acts + * only on exact hits (a fire, a camera) does not act on a coarse pointer's + * nearby contact (`hit` is not the exact `topHit`). The card's layer takes + * such a click (quake, fire, camera, vessel, news and wildlife cards act over + * it; an inert card, such as a selected drone-zone card, does nothing), so + * Context leaves the item; owners that act on it (an aircraft, a vessel, a + * directions step) still name it. + * @param {{hit?: object|null, topHit?: object|null}} click + * @param {boolean} underCard Whether a world-overlay entry is under it. + * @returns {boolean} + */ +export function cardKeepsClick(click, underCard) { + if (!underCard || !click?.hit) return false; + const pickId = resolvePickId(click.hit); + if (!pickId) return false; + const expanded = pickId !== resolvePickId(click.topHit ?? null); + return !isActedOnByOtherLayer('', pickId, { expanded }); +} diff --git a/src/data/pickedContext.test.mjs b/src/data/pickedContext.test.mjs index 4b452e0cab..70ed704b4d 100644 --- a/src/data/pickedContext.test.mjs +++ b/src/data/pickedContext.test.mjs @@ -12,7 +12,7 @@ globalThis.dispatchEvent ||= () => true; const { registerEntityContext } = await import('./contextStore.js'); const { registerPickOwner, unregisterPickOwner, findPickOwner } = await import('./pickRegistry.js'); -const { resolvePickedContext, pickedKindForLayer } = await import('./pickedContext.js'); +const { resolvePickedContext, pickedKindForLayer, cardKeepsClick } = await import('./pickedContext.js'); function manager({ enabled = new Set(['flights', 'local-datacenters']), modules = {} } = {}) { return { @@ -97,3 +97,53 @@ test('disabled layers, trails and empty picks never resolve', () => { assert.equal(resolvePickedContext(hit('unknown'), { dataManager: manager() }), null); assert.equal(pickedKindForLayer('ais-live-vessels'), 'vessel'); }); + +test('a card keeps a click from items whose layer does not act on that hit', (t) => { + registerPickOwner('test-fires', (id) => id === 'fire:1'); + registerPickOwner('test-planes', (id) => id === 'plane:1', { + expanded: true, + }); + registerPickOwner('test-route', (id) => id.startsWith('route:'), { + passive: (id) => !id.startsWith('route:step:'), + }); + t.after(() => { + unregisterPickOwner('test-fires'); + unregisterPickOwner('test-planes'); + unregisterPickOwner('test-route'); + }); + const fire = { set: 'fires:1', id: 'fire:1' }; + const plane = { set: 'planes:1', id: 'plane:1' }; + const exact = (hit) => ({ topHit: { ...hit }, hit }); + // A coarse tap: nothing exact, the contact found nearby. + const near = (hit) => ({ topHit: null, hit }); + assert.equal( + cardKeepsClick(near(fire), true), + true, + 'fires act only on exact hits', + ); + assert.equal(cardKeepsClick(near(plane), true), false, 'aircraft act nearby'); + assert.equal( + cardKeepsClick(near(fire), false), + false, + 'open map: Context names it', + ); + assert.equal( + cardKeepsClick(exact(fire), true), + false, + "an exact fire is the fire's", + ); + const line = { set: 'route:1', id: 'route:line' }; + const step = { set: 'route:1', id: 'route:step:2' }; + // Every card layer acts over a passive route, so the card keeps the click. + assert.equal( + cardKeepsClick(exact(line), true), + true, + 'a route acts for nobody', + ); + assert.equal( + cardKeepsClick(exact(step), true), + false, + "a step is directions' own", + ); + assert.equal(cardKeepsClick({ topHit: null, hit: null }, true), false); +}); diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index fec21a0549..561fc503cc 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -28,6 +28,7 @@ export function createLifecycle({ registerPickOwner, unregisterPickOwner, isOwnedByOtherLayer, + isActedOnByOtherLayer, isCardBackground, } = services.picking; const { onFocusTargetAppear } = services.focus; @@ -429,7 +430,26 @@ export function createLifecycle({ typeof pickedId === 'string' && !isOwnedByOtherLayer?.('cctv', pickedId) && Boolean(isCardBackground?.(hit)); - if (pickedId !== null && !cardBackground) return; + // A passive owner's pick (a flight trail, a directions route) acts + // for nobody, so a live top CCTV card over it keeps the click. + const passiveUnderCard = + cardId && + typeof pickedId === 'string' && + Boolean(isActedOnByOtherLayer) && + isOwnedByOtherLayer?.('cctv', pickedId) && + !isActedOnByOtherLayer('cctv', pickedId); + if (pickedId !== null && !cardBackground && !passiveUnderCard) return; + // A coarse tap's touch contact (not the exact pick) that its layer + // acts on (an aircraft, a vessel, a radio station) is that layer's + // click, even under a card of ours. + const contactId = resolvePickId(event.hit ?? null); + if ( + cardId && + contactId && + contactId !== pickedId && + isActedOnByOtherLayer?.('cctv', contactId, { expanded: true }) + ) + return; if (cardHit && cardHit.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; if (cardId) { activateCctvCameraFromWorldClick( diff --git a/src/layers/cctv/lifecycle.test.mjs b/src/layers/cctv/lifecycle.test.mjs index c1ffdb4da8..ea43a55990 100644 --- a/src/layers/cctv/lifecycle.test.mjs +++ b/src/layers/cctv/lifecycle.test.mjs @@ -84,7 +84,9 @@ test('world clicks respect the painted top card and registered card backgrounds' viewer.scene = { canvas: {}, pick: () => (picked ? { id: picked } : undefined), + drillPick: () => drilled.map((id) => ({ id })), }; + let drilled = []; const input = fakeInput(viewer); const ownCard = { sourceId: CCTV_OVERLAY_SOURCE_ID, entryId: 'cam-1' }; const foreignCard = { @@ -141,6 +143,8 @@ test('world clicks respect the painted top card and registered card backgrounds' lifecycle.detachViewListeners(); input.destroy(); picking.unregisterPickOwner('area-control'); + picking.unregisterPickOwner('test-trails'); + picking.unregisterPickOwner('test-planes'); picking.unregisterCardBackground('area-fixture'); }); await lifecycle.methods.init(viewer); @@ -190,6 +194,37 @@ test('world clicks respect the painted top card and registered card backgrounds' { ...drone, id: 'unregistered-local-entity' }, ]) click(hit, [ownCard], []); + // A passive owner's pick (a trail, a route) acts for nobody: the live top + // card keeps the click, and with no card the pick is not empty map. + const trail = { set: 'trails:1', id: 'gev-trail:fl-1:head', surface: false }; + picking.registerPickOwner('test-trails', (id) => id === trail.id, { + passive: true, + }); + click(trail, [ownCard], ['cam-1']); + click(trail, [], []); + click(trail, [foreignCard, ownCard], []); + picking.unregisterPickOwner('test-trails'); + // A coarse tap whose touch contact is an aircraft (a layer that acts on + // nearby contacts) is the aircraft's, even under a live CCTV card. + const previousMatch = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + picking.registerPickOwner('test-planes', (id) => id === 'plane:1', { + expanded: true, + }); + drilled = ['plane:1']; + click(null, [ownCard], []); + // With no card, the bare tap near the aircraft still deselects. + click(null, [], ['clear']); + // A contact whose layer acts only on exact hits leaves the card its tap. + picking.registerPickOwner('test-exact', (id) => id === 'exact:1'); + drilled = ['exact:1']; + click(null, [ownCard], ['cam-1']); + picking.unregisterPickOwner('test-exact'); + drilled = []; + click(null, [ownCard], ['cam-1']); + picking.unregisterPickOwner('test-planes'); + if (previousMatch) globalThis.matchMedia = previousMatch; + else delete globalThis.matchMedia; picking.registerPickOwner('area-control', (id) => id === drone.id); click(drone, [ownCard], []); picking.unregisterPickOwner('area-control'); diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 898ea6c9a5..3d3984376b 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -352,7 +352,11 @@ export function createEarthquakesLayer({ const pickId = picking.resolvePickId(hit); const actedOn = picking.isActedOnByOtherLayer ?? picking.isOwnedByOtherLayer; - if (pickId && actedOn(EARTHQUAKES_LAYER_ID, pickId)) return; + // Exact-only handlers cannot act on a nearby touch hit. Compare ids, + // since the dispatcher may expose distinct objects for the same pick. + const expanded = + 'topHit' in click && picking.resolvePickId(click.topHit) !== pickId; + if (pickId && actedOn(EARTHQUAKES_LAYER_ID, pickId, { expanded })) return; const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID, }); diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index 528ff6fbe3..6a2b3bf808 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -4,6 +4,7 @@ import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs'; import * as picking from '../../data/pickRegistry.js'; // Registers the shared `gev-trail:` owner as passive, as the app does. import '../../data/trailRenderer.js'; +import { createSelection as createFireSelection } from '../firms/selection.js'; import { fakeInput } from '../../input/testDoubles.mjs'; import { createDroneAirspaceLayer } from '../droneAirspace/index.js'; import { @@ -36,7 +37,10 @@ const quake = (id, extra = {}) => ({ }); /** A layer whose globe clicks, card hits and context store the test drives. */ -function harness(rows, { context = null, ripples = null } = {}) { +function harness( + rows, + { context = null, ripples = null, input: inputFactory = null } = {}, +) { let snapshot = rows; const handlers = []; const opened = []; @@ -50,41 +54,44 @@ function harness(rows, { context = null, ripples = null } = {}) { let foreignTop = null; const viewer = {}; const { draw } = bindFakeDraw(viewer); + const 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 } = {}) { + // Unfiltered, as the host answers: another layer's entry on top + // first, else this layer's own. + if (!sourceId) + return ( + foreignTop ?? + this.hitTest(_x, _y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID }) ?? + this.hitTest(_x, _y, { sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID }) + ); + 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; + }, + }; 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 } = {}) { - // Unfiltered, as the host answers: another layer's entry on top - // first, else this layer's own. - if (!sourceId) - return ( - foreignTop ?? - this.hitTest(_x, _y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID }) ?? - this.hitTest(_x, _y, { sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID }) - ); - 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; - }; - }, - }), + overlayHost, + input: + inputFactory ?? + (() => ({ + onClick(callback) { + const handler = { callback, destroyed: false }; + handlers.push(handler); + return () => { + handler.destroyed = true; + }; + }, + })), picking, context, ripples, @@ -108,6 +115,8 @@ function harness(rows, { context = null, ripples = null } = {}) { visible, focused, handlers, + overlayHost, + overlayHits, discs, setRows(next) { snapshot = next; @@ -657,7 +666,9 @@ test('a touch-expanded sibling hit takes precedence over a quake label', async ( h.layer.enable(h.viewer); await h.layer.update(h.viewer); h.clickDisc('ak1'); - picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); + picking.registerPickOwner('test-plane', (id) => id === 'plane-9', { + expanded: true, + }); h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', null, { set: 'flights:1', id: 'plane-9', @@ -931,3 +942,78 @@ test('quake card and label act over a flight trail and a directions route', asyn h.layer.destroy(); } }); + +test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits act once', async (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + let sceneHit = null; + const fireHit = { set: 'firms:test', id: 'fire:test' }; + let input; + const h = harness([quake('ak1')], { + input(viewer) { + viewer.scene = { + pick: () => (sceneHit ? { id: sceneHit } : null), + drillPick: () => [{ id: fireHit }], + }; + input ??= fakeInput(viewer); + return input.input; + }, + }); + const fire = { lat: 60, lon: -153, frp: 5, acqMs: 1, sensor: 'test' }; + const fireFocus = []; + const state = { + _viewer: h.viewer, + _icons: { id: fireHit.set }, + _pickIndexById: new Map([[fireHit.id, fire]]), + _fireByCardId: new Map(), + _contextIds: new Set(), + }; + const selection = createFireSelection({ + layerState: state, + services: { + picking, + context: {}, + focus: { requestWorldFocus: (x) => fireFocus.push(x) }, + }, + components: { + cards: { rebuildAmbientLabels() {} }, + model: { firePosition: () => ({ x: 1, y: 2, z: 3 }) }, + }, + config: { id: 'firms', name: 'FIRMS', overlayHost: h.overlayHost }, + feed: {}, + }); + try { + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + selection.installClickHandler(); + picking.registerPickOwner('firms', (id) => state._pickIndexById.has(id)); + h.overlayHits.set(EARTHQUAKE_OVERLAY_SOURCE_ID, { + sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID, + entryId: 'ak1', + }); + input.click(); + assert.equal(h.focused.length, 1, 'label acts on the exact miss'); + assert.equal(fireFocus.length, 0, 'nearby fire does not act'); + h.overlayHits.clear(); + h.overlayHits.set(EARTHQUAKE_CARD_SOURCE_ID, { + sourceId: EARTHQUAKE_CARD_SOURCE_ID, + entryId: 'earthquake-card:ak1', + }); + input.click(); + assert.equal(h.opened.length, 1, 'selected card opens once'); + assert.equal(fireFocus.length, 0); + sceneHit = fireHit; + input.click(); + assert.equal(fireFocus.length, 1, 'exact fire hit acts'); + assert.equal(h.opened.length, 1, 'card yields to the exact fire'); + } finally { + selection.removeClickHandler(); + picking.unregisterPickOwner('firms'); + h.layer.destroy(); + input?.destroy(); + } +}); diff --git a/src/layers/firms/selection.js b/src/layers/firms/selection.js index edbae6734b..d6bcdd9cc3 100644 --- a/src/layers/firms/selection.js +++ b/src/layers/firms/selection.js @@ -13,7 +13,8 @@ export function createSelection({ config, feed, }) { - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isActedOnByOtherLayer } = + services.picking; const { requestWorldFocus } = services.focus; const { selectEntityContext, @@ -42,14 +43,34 @@ export function createSelection({ } // A pick that belongs to a sibling layer (e.g. an aircraft) is not // "empty space" — leave the selection alone and let that layer handle it. + // A passive owner's pick (a flight trail, a directions route) acts for + // nobody, so a card of ours painted over it still takes the click. + let passivePick = false; if (picked) { const pickedId = resolvePickId(picked); - if (pickedId && isOwnedByOtherLayer(id, pickedId)) return; + if (pickedId && isOwnedByOtherLayer(id, pickedId)) { + passivePick = + Boolean(isActedOnByOtherLayer) && + !isActedOnByOtherLayer(id, pickedId); + if (!passivePick) return; + } } const cardHit = overlayHost.hitTest?.( event.screenPosition?.x, event.screenPosition?.y, ); + if (passivePick && cardHit?.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; + // A coarse tap's touch contact (not the exact pick) that its layer acts + // on (an aircraft, a vessel, a radio station) is that layer's click, + // even under a card of ours. + const contactId = resolvePickId(event.hit ?? null); + if ( + cardHit && + contactId && + contactId !== resolvePickId(picked ?? null) && + isActedOnByOtherLayer?.(id, contactId, { expanded: true }) + ) + return; if (cardHit) { if (cardHit.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; const carded = layerState._fireByCardId.get(cardHit.entryId); diff --git a/src/layers/flights/lifecycle.js b/src/layers/flights/lifecycle.js index 790aad1495..f85260f735 100644 --- a/src/layers/flights/lifecycle.js +++ b/src/layers/flights/lifecycle.js @@ -134,6 +134,14 @@ export function createLifecycle({ registerPickOwner( 'flights', (pickedId) => flightState._icons?.has(pickedId) === true, + { + expanded: true, + // A click on the aircraft already tracked is ignored: for that one + // plane the layer acts on nothing, so a card over it keeps the tap. + passive: (pickedId) => + Boolean(flightState._trackedIcao) && + pickedId === flightState._trackedIcao, + }, ); const frame = findFrame(viewer); if (!flightState._preRenderRemove && frame) { diff --git a/src/layers/military/lifecycle.js b/src/layers/military/lifecycle.js index 0389ef3f02..7c96171206 100644 --- a/src/layers/military/lifecycle.js +++ b/src/layers/military/lifecycle.js @@ -115,6 +115,14 @@ export function createLifecycle({ registerPickOwner( 'military', (pickedId) => flightState._icons?.has(pickedId) === true, + { + expanded: true, + // A click on the aircraft already tracked is ignored: for that one + // plane the layer acts on nothing, so a card over it keeps the tap. + passive: (pickedId) => + Boolean(flightState._trackedIcao) && + pickedId === flightState._trackedIcao, + }, ); // The flights layer suppresses its military duplicates while we render them setMilitaryLayerActive(true); diff --git a/src/layers/news/layer.test.mjs b/src/layers/news/layer.test.mjs index 0070b6b773..7ad0d9a8a1 100644 --- a/src/layers/news/layer.test.mjs +++ b/src/layers/news/layer.test.mjs @@ -5,11 +5,7 @@ import { fromDegrees } from '../../geo/ellipsoid.js'; import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; import { NEWS_KEY_PROVIDERS, createNewsLayer } from './index.js'; -import { - findPickOwner, - registerPickOwner, - unregisterPickOwner, -} from '../../data/pickRegistry.js'; +import { findPickOwner } from '../../data/pickRegistry.js'; // Registers the shared `gev-trail:` no-op owner, as the app does. import '../../data/trailRenderer.js'; import { getSelectedEntityContext } from '../../data/contextStore.js'; diff --git a/src/layers/radio/interaction.js b/src/layers/radio/interaction.js index cc129d491a..9e1b59f134 100644 --- a/src/layers/radio/interaction.js +++ b/src/layers/radio/interaction.js @@ -48,11 +48,26 @@ export function createInteraction({ RADIO_PICK_WINDOW_PX, )) { const stationId = stationFromPick(picked); - if (stationId) return stationId; + if (!stationId) continue; + // Found only through our wider window, not as the tap's touch contact: + // another layer's card or label painted here is that layer's click, + // since its handler never sees this window. + if (stationFromPick(event.hit) !== stationId && foreignCardAt(event)) + return null; + return stationId; } return null; } + /** Whether another layer's world-overlay card or label is under a click. */ + function foreignCardAt(event) { + const top = services.overlays?.hitTestWorldOverlay?.( + event.screenPosition?.x, + event.screenPosition?.y, + ); + return Boolean(top) && top.sourceId !== RADIO_OVERLAY_SOURCE_ID; + } + function radioPresentationAllowed() { if (!layerState._managerLifecyclePresentation) return layerState._enabled; return ( @@ -80,7 +95,9 @@ export function createInteraction({ function installInteraction() { if (!layerState._viewer || layerState._clickSubscription) return; - registerPickOwner('radio', (id) => id.startsWith(RADIO_PREFIX)); + registerPickOwner('radio', (id) => id.startsWith(RADIO_PREFIX), { + expanded: true, + }); const viewer = layerState._viewer; layerState._clickSubscription = inputFor(viewer).onClick((event) => { if (!radioPresentationAllowed()) return; diff --git a/src/layers/radio/interaction.test.mjs b/src/layers/radio/interaction.test.mjs index c88310bee9..40d2e48a37 100644 --- a/src/layers/radio/interaction.test.mjs +++ b/src/layers/radio/interaction.test.mjs @@ -62,3 +62,42 @@ test('a direct hit needs no drill, and another layer’s contact keeps its click }); assert.equal(pickedRadioStationAt(other), null); }); + +// A station found only through radio's wider window, not as the tap's own +// pick or its touch contact, sits under another layer's card or label: that +// layer acts and never sees this window, so radio leaves the click. +test('a window-only station yields to a card painted over it', () => { + let top = null; + const radio = createInteraction({ + state: { _stationById: new Map([['kexp', {}]]) }, + services: { + picking: { + resolvePickId: (picked) => picked?.id ?? null, + isOwnedByOtherLayer: () => false, + registerPickOwner() {}, + unregisterPickOwner() {}, + }, + overlays: { + setOverlaySourceVisible() {}, + hitTestWorldOverlay: () => top, + }, + }, + parts: { rendering: { radioStationIdFromPick } }, + }); + const station = hit('radio:kexp'); + const near = (contact = null) => ({ + ...clickEvent({ windowHits: [station] }), + hit: contact, + screenPosition: { x: 5, y: 5 }, + }); + assert.equal(radio.pickedRadioStationAt(near()), 'kexp', 'open map'); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + assert.equal(radio.pickedRadioStationAt(near()), null, 'under a quake card'); + assert.equal( + radio.pickedRadioStationAt(near(station)), + 'kexp', + 'the touch contact: the card yielded to the station', + ); + top = { sourceId: 'radio', entryId: 'radio:kexp' }; + assert.equal(radio.pickedRadioStationAt(near()), 'kexp', 'our own card'); +}); diff --git a/src/layers/streetLevel/selection.js b/src/layers/streetLevel/selection.js index 9e01729b62..1d7a673c23 100644 --- a/src/layers/streetLevel/selection.js +++ b/src/layers/streetLevel/selection.js @@ -24,7 +24,23 @@ export function createSelection({ state, parts }) { function onClick(event) { if (!state.viewer || !state.enabled) return; const hit = event.windowHit(CLICK_PICK_WINDOW_PX, CLICK_PICK_WINDOW_PX); - const route = parts.router.resolve(pickIdOf(hit)); + const windowId = pickIdOf(hit); + // A coarse tap's touch contact (event.hit) reaches farther than this + // window; a card or label over it yields to our item there, so it is ours. + const contact = event.hit; + const contactId = + contact && !contact.surface + ? pickIdOf({ drawHit: contact.set ? contact : null, id: event.id }) + : null; + let route = parts.router.resolve(windowId); + // Found only through our window, not as the contact (which is the exact + // hit whenever there is one): another layer's card or label painted here + // is that layer's click, since its handler never sees this window. + if (route && windowId !== contactId) { + const at = event.screenPosition; + if (state.services.overlayHit?.(at?.x, at?.y)) return; + } + if (!route && contactId) route = parts.router.resolve(contactId); // Not ours: the ground handler decides whether it is the map itself. if (!route) { parts.openAtGround?.({ surface: hit.surface, ground: groundOf(event) }); @@ -71,7 +87,12 @@ export function createSelection({ state, parts }) { if (state.clickSubscription) return; state.clickSubscription = inputFor(viewer).onClick(onClick); document.addEventListener('keydown', onKeyDown); - picking?.registerPickOwner?.(STREET_LEVEL_LAYER_ID, parts.router.ownsPick); + picking?.registerPickOwner?.(STREET_LEVEL_LAYER_ID, parts.router.ownsPick, { + expanded: true, + // The core's position marker is ours but selects nothing: a card over + // it keeps the tap. + passive: (id) => !parts.router.resolve(id)?.instance, + }); } function uninstall() { diff --git a/src/layers/streetLevel/selection.test.mjs b/src/layers/streetLevel/selection.test.mjs index 07f55b9e19..e1bc976f69 100644 --- a/src/layers/streetLevel/selection.test.mjs +++ b/src/layers/streetLevel/selection.test.mjs @@ -4,6 +4,7 @@ import * as Cesium from 'cesium'; import { createSelection } from './selection.js'; import { createPickRouter } from './pickRouter.js'; import { fakeInput } from '../../input/testDoubles.mjs'; +import * as pickRegistry from '../../data/pickRegistry.js'; /** The selection installed on a stand-in viewer, with what its clicks reach. */ function harness({ @@ -289,3 +290,137 @@ test('a click on a provider line hands it the ground under the click, measured o h.restore(); } }); + +// An image found only through Street Level's own window (not the exact pick) +// under another layer's card or label is that card's click: its layer never +// sees this window. +test('an item found only in our window yields to a card painted over it', () => { + let top = null; + const h = harness({ + services: { overlayHit: () => top }, + sceneExtras: { + pick: (_position, width = 3) => + width >= 9 ? { id: 'mly:img:near' } : null, + }, + }); + try { + h.click(); + assert.deepEqual(h.opened, ['near'], 'open map: the window finds it'); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + h.click(); + assert.deepEqual(h.opened, ['near'], 'under a card: the card keeps it'); + assert.equal(h.groundClicks.length, 0); + } finally { + h.restore(); + } +}); + +// A coarse tap's touch contact reaches farther than this window. A quake card +// or label over that contact yields to it, so Street Level takes it here. +test('a coarse touch contact beyond our window is ours to open', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const h = harness({ + services: { + picking: pickRegistry, + overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), + }, + sceneExtras: { + pick: () => null, + drillPick: () => [{ id: 'mly:img:contact' }], + }, + }); + try { + h.click(); + assert.deepEqual(h.opened, ['contact']); + assert.equal(h.groundClicks.length, 0); + } finally { + h.restore(); + } +}); + +// The exact hit or the touch contact is ours under a card too: a quake card +// or label yields to a Street Level owner's pick, so yielding back would +// leave the click dead. Line parts compare by the sequence they pick as. +test('an exact or contact hit on our line part acts under a card', (t) => { + const part = { + set: 'street-level:mapillary-coverage:1', + id: 'mly:seq:abc#2', + meta: { pick: 'mly:seq:abc' }, + }; + const card = () => ({ sourceId: 'earthquake-card', entryId: 'q' }); + const exact = harness({ services: { overlayHit: card } }); + try { + exact.scene.under = part; + exact.click(); + assert.deepEqual(exact.sequences.selects, ['abc'], 'mouse, exact part'); + } finally { + exact.restore(); + } + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const contact = harness({ + services: { picking: pickRegistry, overlayHit: card }, + sceneExtras: { + pick: (_position, width = 3) => (width >= 9 ? { id: part } : null), + drillPick: () => [{ id: part }], + }, + }); + try { + contact.click(); + assert.deepEqual(contact.sequences.selects, ['abc'], 'coarse contact'); + } finally { + contact.restore(); + } +}); + +// Our window catching another layer's item says nothing about our own touch +// contact beyond it: that contact is still ours under a card. +test('a contact of ours acts even when our window finds another item', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const h = harness({ + services: { + picking: pickRegistry, + overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), + }, + sceneExtras: { + pick: (_position, width = 3) => + width >= 9 ? { id: { set: 'flights:1', id: 'flight:9' } } : null, + drillPick: () => [{ id: 'mly:img:contact' }], + }, + }); + try { + h.click(); + assert.deepEqual(h.opened, ['contact']); + } finally { + h.restore(); + } +}); + +// The core's position marker is ours but selects nothing, so it is a passive +// pick: a card painted over it keeps the tap. Our images and lines act. +test('the position marker is a passive pick; our items act', () => { + const h = harness({ services: { picking: pickRegistry } }); + try { + const acted = (id) => + pickRegistry.isActedOnByOtherLayer('test-card', id, { expanded: true }); + assert.equal(pickRegistry.findPickOwner('sl:pos'), 'street-level'); + assert.equal(acted('sl:pos'), false, 'the marker acts for nobody'); + assert.equal(acted('mly:img:abc'), true, 'an image opens'); + } finally { + h.restore(); + } +}); diff --git a/src/layers/vessels/lifecycle.js b/src/layers/vessels/lifecycle.js index c9c7d3e344..5ebebd0970 100644 --- a/src/layers/vessels/lifecycle.js +++ b/src/layers/vessels/lifecycle.js @@ -192,8 +192,10 @@ export function createLifecycle({ }); } // Pick-ownership (H2): a vessel icon's pick id is its row id, the record's id. - registerPickOwner('ais-live-vessels', (pickedId) => - state.records.byId.has(pickedId), + registerPickOwner( + 'ais-live-vessels', + (pickedId) => state.records.byId.has(pickedId), + { expanded: true }, ); // Vessels are asked for by view, so ask again when the view moves away. removeViewListener(); diff --git a/src/layers/vessels/selection.js b/src/layers/vessels/selection.js index f236aebf7e..7a4821dc45 100644 --- a/src/layers/vessels/selection.js +++ b/src/layers/vessels/selection.js @@ -10,7 +10,8 @@ export function createSelection({ options, }) { const { state } = vesselState; - const { isOwnedByOtherLayer } = services.picking; + const { isOwnedByOtherLayer, isActedOnByOtherLayer, resolvePickId } = + services.picking; const { requestWorldFocus } = services.worldFocus; const { selectEntityContext, @@ -47,19 +48,46 @@ export function createSelection({ // `gev-trail:*` pick is also a no-op. Every other non-vessel pick — sibling // unowned scene picks dismiss the current vessel inspection. if (ownRecordPick && (!pickedId || !record)) return; - if (pickedId && !record && String(pickedId).startsWith('gev-trail:')) - return; + /** Whether this layer's own card is painted under the click. */ + const ownCardUnder = () => + vesselState._vesselOverlayHost.hitTest?.( + event.screenPosition?.x, + event.screenPosition?.y, + )?.sourceId === VESSEL_OVERLAY_SOURCE_ID; + // A passive owner's pick (a trail, a directions route) acts for nobody: + // a card of ours painted over it keeps the click; otherwise a no-op. + const passivePick = + Boolean(pickedId) && + !record && + (String(pickedId).startsWith('gev-trail:') || + (Boolean(isActedOnByOtherLayer) && + isOwnedByOtherLayer('ais-live-vessels', pickedId) && + !isActedOnByOtherLayer('ais-live-vessels', pickedId))); + if (passivePick && !ownCardUnder()) return; // A sibling layer already owns this click. Preserve the current vessel // selection and do not compete with its camera command. const siblingOwned = - pickedId && isOwnedByOtherLayer('ais-live-vessels', pickedId); + !passivePick && + pickedId && + isOwnedByOtherLayer('ais-live-vessels', pickedId); // Cyclone geometry is ambient context behind painted cards. Its handler // yields to the same foreground AIS hit. Keep moving-contact precedence // unchanged: those handlers may issue their own camera command. const cycloneBackground = siblingOwned && !isOwnedByOtherLayer('weather-cyclones', pickedId); - if (siblingOwned && !cycloneBackground) return; + if (siblingOwned && !cycloneBackground) { + // A coarse tap's nearby contact (not the exact pick) whose layer acts + // only on exact hits (a fire, a camera) does not take a tap on this + // layer's own card: that card keeps it. + const nearMissOfExactOnly = + isActedOnByOtherLayer && + resolvePickId?.(event.topHit ?? null) !== pickedId && + !isActedOnByOtherLayer('ais-live-vessels', pickedId, { + expanded: true, + }); + if (!nearMissOfExactOnly || !ownCardUnder()) return; + } // Cards are painted on a pointer-events:none canvas, so the scene pick is // usually terrain behind the card. Resolve against the host's current diff --git a/src/ui/entityContextBridge.js b/src/ui/entityContextBridge.js index eea7e72c29..cb1906f233 100644 --- a/src/ui/entityContextBridge.js +++ b/src/ui/entityContextBridge.js @@ -1,4 +1,4 @@ -import { resolvePickedContext } from '../data/pickedContext.js'; +import { cardKeepsClick, resolvePickedContext } from '../data/pickedContext.js'; import { followedOf, onFollowChanged } from '../data/followed.js'; import { fromDegreesInto } from '../geo/ellipsoid.js'; import { inputFor } from '../input/dispatcher.js'; @@ -315,6 +315,12 @@ export function installEntityContext({ dataManager: getDataManager(), }); if (identity) { + // A card or label painted over an item its layer does not act on here + // (a quake card beside a fire, or over a route) is the card's click. + const underCard = Boolean( + overlayHit?.(event.screenPosition?.x, event.screenPosition?.y), + ); + if (cardKeepsClick(event, underCard)) return; // These layers start following on their own click; following again // from here would fight them (the flights layer reads a second track // of the same plane as a click on empty map and lets go). diff --git a/src/ui/entityContextBridge.test.mjs b/src/ui/entityContextBridge.test.mjs new file mode 100644 index 0000000000..541350bd5a --- /dev/null +++ b/src/ui/entityContextBridge.test.mjs @@ -0,0 +1,101 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import { createPinia } from 'pinia'; +import { installEntityContext } from './entityContextBridge.js'; +import { useEntityCardStore } from './stores/entityCard.js'; +import { fakeInput } from '../input/testDoubles.mjs'; +import { + registerPickOwner, + unregisterPickOwner, +} from '../data/pickRegistry.js'; + +// A coarse tap that misses everything exactly finds a fire within the shared +// touch window. On open map Context names it; under a quake card or label the +// card takes the tap, since the fire layer acts only on exact hits; an exact +// hit on the fire is the fire's, under a card or not. +test('Context leaves a near-missed exact-only item to a card painted over it', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const fire = { set: 'test-fires:1', id: 'fire:1' }; + registerPickOwner('test-fires', (id) => id === fire.id); + t.after(() => unregisterPickOwner('test-fires')); + let exact = false; + const viewer = { + scene: { + pick: () => (exact ? { id: fire } : null), + drillPick: () => [{ id: fire }], + }, + }; + const input = fakeInput(viewer); + let cardOnTop = false; + const pinia = createPinia(); + const disconnect = installEntityContext({ + viewer, + getDataManager: () => ({ + isEnabled: () => true, + layers: new Map(), + getAll: () => [], + }), + pinia, + overlayHit: () => + cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, + }); + t.after(() => { + disconnect(); + input.destroy(); + }); + const store = useEntityCardStore(pinia); + const named = []; + store.select = (identity) => named.push(identity.id); + const tap = () => { + named.length = 0; + input.click(); + return [...named]; + }; + assert.deepEqual(tap(), ['fire:1'], 'open map: Context names the fire'); + cardOnTop = true; + assert.deepEqual(tap(), [], 'under a card: the card keeps the tap'); + exact = true; + assert.deepEqual(tap(), ['fire:1'], 'an exact hit is the fire’s'); +}); + +// Every card layer acts over a passive owner's pick (a directions route), so +// Context leaves an exact route hit under a card to that card, and names it on +// open map as before. +test('Context leaves an exact passive route under a card to the card', (t) => { + const route = { set: 'test-route:1', id: 'route:line' }; + registerPickOwner('test-route', (id) => id.startsWith('route:'), { + passive: true, + }); + t.after(() => unregisterPickOwner('test-route')); + const viewer = { scene: { pick: () => ({ id: route }) } }; + const input = fakeInput(viewer); + let cardOnTop = false; + const pinia = createPinia(); + const disconnect = installEntityContext({ + viewer, + getDataManager: () => ({ + isEnabled: () => true, + layers: new Map(), + getAll: () => [], + }), + pinia, + overlayHit: () => + cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, + }); + t.after(() => { + disconnect(); + input.destroy(); + }); + const named = []; + useEntityCardStore(pinia).select = (identity) => named.push(identity.id); + input.click(); + assert.deepEqual(named, ['route:line'], 'open map: Context names the route'); + cardOnTop = true; + input.click(); + assert.deepEqual(named, ['route:line'], 'under a card: the card keeps it'); +}); From 54fd3d3bed8a1ae950f2c38d67e587179bcf19da Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Tue, 17 Nov 2026 15:51:14 +0530 Subject: [PATCH 10/60] fix(picking): settle which layers act on a click when it resolves The flights and military layers treat the aircraft they already track as a passive pick, but they start tracking during the click itself. A card handler running later in the same click then saw the plane as passive and acted too: a quake card opened its source while the plane started tracking, and fire, CCTV and vessel cards could do the same. The pick registry now records the acting owners of a click's exact hit and touch contact when the dispatcher first resolves them, and the quake, FIRMS, CCTV, vessel and Context checks read that record for the rest of the click. Calls without a click keep the live lookup. --- docs/CURRENT-STATE.md | 10 ++- src/data/aisLiveVessels.test.mjs | 45 ++++++++++++- src/data/firmsInteraction.test.mjs | 32 ++++++++++ src/data/pickRegistry.js | 55 +++++++++++----- src/data/pickedContext.js | 2 +- src/data/pickedContext.test.mjs | 22 ++++++- src/input/dispatcher.js | 9 ++- src/layers/cctv/lifecycle.js | 7 ++- src/layers/cctv/lifecycle.test.mjs | 16 +++++ src/layers/earthquakes/index.js | 3 +- src/layers/earthquakes/selection.test.mjs | 77 +++++++++++++++++------ src/layers/firms/selection.js | 4 +- src/layers/vessels/selection.js | 5 +- 13 files changed, 239 insertions(+), 48 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index f492bedce2..064fa13e44 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2067,9 +2067,13 @@ another layer's card or label painted over it, so a quake card or label beside one acts alone, with a mouse or a coarse pointer. Fire and CCTV cards in turn yield to a touch contact whose layer acts on it. The aircraft a layer already tracks and Street Level's position marker are passive picks, since a click on -either does nothing. Fire, CCTV and vessel cards, like the quake's, act over a -passive owner's pick (a flight trail, the directions route); with no card -there, that pick still leaves a selection alone. Context +either does nothing. The pick registry records which owners act on a click's +exact hit and touch contact when the click first reads them +(`rememberClickPickActions`), and every layer asks that record for the rest of +the click, so an aircraft that starts tracking during the click does not leave +it to a later card handler as well. Fire, CCTV and vessel cards, like the +quake's, act over a passive owner's pick (a flight trail, the directions +route); with no card there, that pick still leaves a selection alone. Context (`src/ui/entityContextBridge.js`) names what a click identifies, except under a world-overlay card or label when the item's owner does not act on that hit (`cardKeepsClick` in `src/data/pickedContext.js`): a passive route, or a fire diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs index 25747f257c..fc2c09a3f9 100644 --- a/src/data/aisLiveVessels.test.mjs +++ b/src/data/aisLiveVessels.test.mjs @@ -1012,7 +1012,12 @@ function makeCesiumEvent() { }; } -function installWireHarness(picked, stateOverrides = {}, sceneExtras = {}) { +function installWireHarness( + picked, + stateOverrides = {}, + sceneExtras = {}, + firstClick = null, +) { const hadWindow = Object.hasOwn(globalThis, 'window'); const hadDocument = Object.hasOwn(globalThis, 'document'); const priorWindow = globalThis.window; @@ -1041,6 +1046,8 @@ function installWireHarness(picked, stateOverrides = {}, sceneExtras = {}) { scene: { pick: () => picked, ...sceneExtras }, }; const input = fakeInput(viewer); + // A subscriber that runs before the layer's own (an aircraft layer). + if (firstClick) input.input.onClick(firstClick); // The camera port other layers follow through, with no pose to read; its // followChanged event counts who listens. const followChanged = makeCesiumEvent(); @@ -1993,6 +2000,42 @@ test('vessel interaction wire: a sibling-owned pick wins without selection mutat } }); +// The aircraft layer runs first and starts tracking the plane under the +// vessel's card, making it passive. The card reads the owners that acted +// when the click resolved, so it still yields: one action. +test('vessel interaction wire: a card yields to an aircraft that starts tracking in the same click', (t) => { + let tracked = null; + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', { + expanded: true, + passive: (pickedId) => pickedId === tracked, + }); + t.after(() => unregisterPickOwner('test-planes')); + const harness = installWireHarness( + { id: 'plane:9' }, + { selectedRecord: null }, + {}, + (event) => { + if (event.hit?.id === 'plane:9') tracked = 'plane:9'; + }, + ); + const requests = []; + harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => + requests.push(event.detail), + ); + _setVesselOverlayHostForTest( + hostWithCardHit(`vessel:${harness.record.mmsi}`), + ); + try { + harness.handler.click({ position: { x: 10, y: 20 } }); + assert.equal(tracked, 'plane:9', 'the aircraft starts tracking'); + assert.equal(requests.length, 0, 'the vessel card yields'); + assert.equal(aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, null); + } finally { + _setVesselOverlayHostForTest(null); + harness.cleanup(); + } +}); + // A trail acts for nobody: the vessel's card painted over it still selects, // and a bare trail pick stays a no-op that keeps the selection. test('vessel interaction wire: a card over a trail selects; a bare trail is a no-op', () => { diff --git a/src/data/firmsInteraction.test.mjs b/src/data/firmsInteraction.test.mjs index 0bdf158f98..026be0a877 100644 --- a/src/data/firmsInteraction.test.mjs +++ b/src/data/firmsInteraction.test.mjs @@ -64,6 +64,7 @@ function harness({ withGlobe = false, feed = null, drilled = null, + firstClick = null, } = {}) { const hadWindow = Object.hasOwn(globalThis, 'window'); const priorWindow = globalThis.window; @@ -137,6 +138,8 @@ function harness({ if (!withGlobe) layer.attachShellServices({ imageryHost: () => ({ kind: 'none' }) }); const input = fakeInput(viewer); + // A subscriber that runs before the layer's own (an aircraft layer). + if (firstClick) input.input.onClick(firstClick); // The LOD rebuild (and with it the context-registration sweep) is inert // without a data source, so tests that drive a real refresh need one. if (withDataSource) layer.init(viewer); @@ -576,6 +579,35 @@ test('a fire card keeps a tap whose contact does not act; bare taps still clear' } }); +// The aircraft layer runs first and starts tracking the plane it was clicked +// on, which makes that plane passive. The fire card painted over it reads +// the owners that acted when the click resolved, so it still yields. +test('a fire card yields to an aircraft that starts tracking in the same click', (t) => { + const fire = makeFire(); + let tracked = null; + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', { + expanded: true, + passive: (pickedId) => pickedId === tracked, + }); + t.after(() => unregisterPickOwner('test-planes')); + const h = harness({ + fires: [fire], + picked: { id: 'plane:9' }, + cardHit: `fire:${fireDetectionKey(fire)}`, + firstClick: (event) => { + if (event.hit?.id === 'plane:9') tracked = 'plane:9'; + }, + }); + try { + h.click(); + assert.equal(tracked, 'plane:9', 'the aircraft starts tracking'); + assert.equal(h.requests.length, 0, 'the fire card yields'); + assert.equal(h.layer.getSelectedInfo(), null); + } finally { + h.cleanup(); + } +}); + test('a stale card id resolves to nothing instead of an arbitrary fire', () => { const h = harness({ picked: { primitive: {}, content: {}, featureId: 0 }, diff --git a/src/data/pickRegistry.js b/src/data/pickRegistry.js index b16264f71f..9b4ef36047 100644 --- a/src/data/pickRegistry.js +++ b/src/data/pickRegistry.js @@ -35,6 +35,8 @@ const _owners = new Map(); const _passive = new Map(); /** Owners whose click handlers also select nearby contacts. */ const _expanded = new Set(); +/** @type {WeakMap>} */ +const clickActions = new WeakMap(); /** * Layers whose shapes are background to any card painted over them: their * click handlers stand aside under a card, so the card's layer may act there. @@ -130,33 +132,58 @@ export function isOwnedByOtherLayer(layerId, pickedId) { return false; } +/** @param {string} pickedId @returns {Generator<[string, boolean]>} */ +function* actingPickOwners(pickedId) { + for (const [ownerId, predicate] of _owners) { + try { + if (!predicate(pickedId)) continue; + const passive = _passive.get(ownerId); + if (passive === true) continue; + if (typeof passive === 'function' && passive(pickedId)) continue; + yield [ownerId, _expanded.has(ownerId)]; + } catch { + // a broken predicate must never break click handling + } + } +} + +/** + * Hold the acting owners as soon as a click resolves a hit. A handler can + * start tracking the hit and make it passive before later handlers run. + * @param {object} click The shared dispatcher event. + * @param {import('../render/contract/query').Hit|null} hit The resolved hit. + */ +export function rememberClickPickActions(click, hit) { + const pickedId = resolvePickId(hit); + if (!pickedId) return; + let actions = clickActions.get(click); + if (!actions) clickActions.set(click, (actions = new Map())); + if (!actions.has(pickedId)) { + actions.set(pickedId, [...actingPickOwners(pickedId)]); + } +} + /** * True when some OTHER registered layer owns the picked id and acts on a * click on it: {@link isOwnedByOtherLayer} without passive owners. A card * painted over a passive pick (a flight trail) is still the card's click. * @param {string} layerId - The asking layer's id (excluded from the scan). * @param {string} pickedId - Picked primitive/entity id. - * @param {{expanded?: boolean}} [options] A nearby rather than exact hit: - * only owners whose handlers select nearby contacts take precedence. + * @param {{expanded?: boolean, click?: object}} [options] For a nearby hit, + * only expanded owners take precedence. Pass the shared click to use the + * acting owners from when it first resolved this hit. * @returns {boolean} */ export function isActedOnByOtherLayer( layerId, pickedId, - { expanded = false } = {}, + { expanded = false, click } = {}, ) { if (!pickedId) return false; - for (const [ownerId, predicate] of _owners) { - if (ownerId === layerId || (expanded && !_expanded.has(ownerId))) continue; - try { - if (!predicate(pickedId)) continue; - const passive = _passive.get(ownerId); - if (passive === true) continue; - if (typeof passive === 'function' && passive(pickedId)) continue; - return true; - } catch { - // a broken predicate must never break click handling - } + const owners = + clickActions.get(click)?.get(pickedId) ?? actingPickOwners(pickedId); + for (const [ownerId, selectsNearby] of owners) { + if (ownerId !== layerId && (!expanded || selectsNearby)) return true; } return false; } diff --git a/src/data/pickedContext.js b/src/data/pickedContext.js index ed23d093ff..803075244a 100644 --- a/src/data/pickedContext.js +++ b/src/data/pickedContext.js @@ -147,5 +147,5 @@ export function cardKeepsClick(click, underCard) { const pickId = resolvePickId(click.hit); if (!pickId) return false; const expanded = pickId !== resolvePickId(click.topHit ?? null); - return !isActedOnByOtherLayer('', pickId, { expanded }); + return !isActedOnByOtherLayer('', pickId, { expanded, click }); } diff --git a/src/data/pickedContext.test.mjs b/src/data/pickedContext.test.mjs index 70ed704b4d..6d147bfeaa 100644 --- a/src/data/pickedContext.test.mjs +++ b/src/data/pickedContext.test.mjs @@ -11,7 +11,7 @@ globalThis.CustomEvent ||= class CustomEvent { globalThis.dispatchEvent ||= () => true; const { registerEntityContext } = await import('./contextStore.js'); -const { registerPickOwner, unregisterPickOwner, findPickOwner } = await import('./pickRegistry.js'); +const { registerPickOwner, unregisterPickOwner, findPickOwner, rememberClickPickActions } = await import('./pickRegistry.js'); const { resolvePickedContext, pickedKindForLayer, cardKeepsClick } = await import('./pickedContext.js'); function manager({ enabled = new Set(['flights', 'local-datacenters']), modules = {} } = {}) { @@ -147,3 +147,23 @@ test('a card keeps a click from items whose layer does not act on that hit', (t) ); assert.equal(cardKeepsClick({ topHit: null, hit: null }, true), false); }); + +// An aircraft layer can start tracking the plane it was clicked on before +// Context runs, making that plane passive. Context reads the owners that +// acted when the click resolved, so the card over it does not keep the click. +test('a card keeps a click by the owners that acted when it resolved', (t) => { + let tracked = null; + registerPickOwner('test-planes', (id) => id === 'plane:9', { + expanded: true, + passive: (id) => id === tracked, + }); + t.after(() => unregisterPickOwner('test-planes')); + const plane = { set: 'planes:1', id: 'plane:9' }; + const click = { topHit: plane, hit: plane }; + rememberClickPickActions(click, plane); + tracked = 'plane:9'; + assert.equal(cardKeepsClick(click, true), false, 'the aircraft acted'); + // A click that resolves now sees the tracked plane as passive. + const later = { topHit: { ...plane }, hit: { ...plane } }; + assert.equal(cardKeepsClick(later, true), true); +}); diff --git a/src/input/dispatcher.js b/src/input/dispatcher.js index 7d4ea04606..6387a7a1c2 100644 --- a/src/input/dispatcher.js +++ b/src/input/dispatcher.js @@ -51,6 +51,7 @@ import { import { findPickOwner, pickContact, + rememberClickPickActions, resolvePickId, } from '../data/pickRegistry.js'; import { isPickedWorldPosition } from '../data/scenePick.js'; @@ -456,7 +457,9 @@ function createClickEvent(viewer, queryOf, at, gesture) { // The adapter's own pick of this click is the renderer's pass, held // now: read later, it would be another, of a scene drawn since. void native()?.native.pick; - return topHitOf(hit, () => native()?.foreign() ?? null); + const top = topHitOf(hit, () => native()?.foreign() ?? null); + rememberClickPickActions(this, top); + return top; }); }, get drawHit() { @@ -467,7 +470,7 @@ function createClickEvent(viewer, queryOf, at, gesture) { return once('hit', () => { const q = query(); if (!q) return this.topHit; - return pickContact(q, position, { + const hit = pickContact(q, position, { picked: this.topHit, // Everything drawn there, as the adapter sees it, so a contact // search stops at what is drawn over a contact outside the draw @@ -480,6 +483,8 @@ function createClickEvent(viewer, queryOf, at, gesture) { : this.drill(limit, width, height); }, }); + rememberClickPickActions(this, hit); + return hit; }); }, get id() { diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index 561fc503cc..2e3da9c172 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -437,7 +437,7 @@ export function createLifecycle({ typeof pickedId === 'string' && Boolean(isActedOnByOtherLayer) && isOwnedByOtherLayer?.('cctv', pickedId) && - !isActedOnByOtherLayer('cctv', pickedId); + !isActedOnByOtherLayer('cctv', pickedId, { click: event }); if (pickedId !== null && !cardBackground && !passiveUnderCard) return; // A coarse tap's touch contact (not the exact pick) that its layer // acts on (an aircraft, a vessel, a radio station) is that layer's @@ -447,7 +447,10 @@ export function createLifecycle({ cardId && contactId && contactId !== pickedId && - isActedOnByOtherLayer?.('cctv', contactId, { expanded: true }) + isActedOnByOtherLayer?.('cctv', contactId, { + expanded: true, + click: event, + }) ) return; if (cardHit && cardHit.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; diff --git a/src/layers/cctv/lifecycle.test.mjs b/src/layers/cctv/lifecycle.test.mjs index ea43a55990..cf1c3f98bd 100644 --- a/src/layers/cctv/lifecycle.test.mjs +++ b/src/layers/cctv/lifecycle.test.mjs @@ -88,6 +88,12 @@ test('world clicks respect the painted top card and registered card backgrounds' }; let drilled = []; const input = fakeInput(viewer); + // An aircraft layer that runs before ours and starts tracking the plane + // it was clicked on, which makes that plane passive mid-click. + let tracked = null; + input.input.onClick((event) => { + if (event.hit?.id === 'plane:9') tracked = 'plane:9'; + }); const ownCard = { sourceId: CCTV_OVERLAY_SOURCE_ID, entryId: 'cam-1' }; const foreignCard = { sourceId: 'earthquake-card', @@ -145,6 +151,7 @@ test('world clicks respect the painted top card and registered card backgrounds' picking.unregisterPickOwner('area-control'); picking.unregisterPickOwner('test-trails'); picking.unregisterPickOwner('test-planes'); + picking.unregisterPickOwner('test-tracking'); picking.unregisterCardBackground('area-fixture'); }); await lifecycle.methods.init(viewer); @@ -225,6 +232,15 @@ test('world clicks respect the painted top card and registered card backgrounds' picking.unregisterPickOwner('test-planes'); if (previousMatch) globalThis.matchMedia = previousMatch; else delete globalThis.matchMedia; + // The live card reads the owners that acted when the click resolved, so it + // yields to the aircraft even though tracking made it passive meanwhile. + picking.registerPickOwner('test-tracking', (id) => id === 'plane:9', { + expanded: true, + passive: (id) => id === tracked, + }); + click({ set: 'flights:1', id: 'plane:9', surface: false }, [ownCard], []); + assert.equal(tracked, 'plane:9', 'the aircraft started tracking'); + picking.unregisterPickOwner('test-tracking'); picking.registerPickOwner('area-control', (id) => id === drone.id); click(drone, [ownCard], []); picking.unregisterPickOwner('area-control'); diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 3d3984376b..93e715e03e 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -356,7 +356,8 @@ export function createEarthquakesLayer({ // since the dispatcher may expose distinct objects for the same pick. const expanded = 'topHit' in click && picking.resolvePickId(click.topHit) !== pickId; - if (pickId && actedOn(EARTHQUAKES_LAYER_ID, pickId, { expanded })) return; + if (pickId && actedOn(EARTHQUAKES_LAYER_ID, pickId, { expanded, click })) + return; const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { sourceId: EARTHQUAKE_CARD_SOURCE_ID, }); diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index 6a2b3bf808..65f82c8745 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -701,33 +701,70 @@ test("another layer's card over a quake disc takes the click, and the disc yield } }); -test("another layer's object under the quake card takes the click", async () => { - const h = harness([quake('ak1')]); - picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); - try { +for (const coarse of [false, true]) { + test(`a quake card yields while an aircraft starts tracking (${coarse ? 'coarse' : 'exact'} hit)`, async (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: coarse }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const plane = { set: 'flights:1', id: 'plane-9' }; + let sceneHit = null; + let nearby = null; + let tracked = null; + let tracks = 0; + let input; + const h = harness([quake('ak1')], { + input(viewer) { + viewer.scene = { + pick: () => (sceneHit ? { id: sceneHit } : null), + drillPick: () => (nearby ? [{ id: nearby }] : []), + }; + input = fakeInput(viewer); + // The aircraft layer runs first and changes its passive predicate + // synchronously after reading the dispatched hit. + input.input.onClick((event) => { + const id = event.hit?.id; + if (id !== plane.id || tracked === id) return; + tracked = id; + tracks++; + }); + return input.input; + }, + }); + picking.registerPickOwner('test-plane', (id) => id === plane.id, { + expanded: true, + passive: (id) => id === tracked, + }); + t.after(() => { + picking.unregisterPickOwner('test-plane'); + h.layer.destroy(); + input?.destroy(); + }); h.layer.enable(h.viewer); await h.layer.update(h.viewer); - h.clickDisc('ak1'); + sceneHit = { set: h.discs().spec.id, id: 'earthquake:ak1' }; + input.click(); const card = h.lastCard()[0]; - // The card is painted over a plane: the flight layer acts on the click, - // so the card neither opens its link nor changes. - overlayHitCard(h, card.id, { set: 'flights:1', id: 'plane-9' }); - assert.deepEqual(h.opened, []); + h.overlayHits.set(EARTHQUAKE_CARD_SOURCE_ID, { + sourceId: EARTHQUAKE_CARD_SOURCE_ID, + entryId: card.id, + }); + sceneHit = coarse ? null : plane; + nearby = coarse ? plane : null; + + input.click(); + assert.equal(tracks, 1, 'the aircraft starts tracking'); + assert.deepEqual(h.opened, [], 'the quake card yields for the whole click'); assert.equal(h.lastCard()[0].id, card.id, 'the card stays'); - // Over open ground the card opens the USGS page. - h.clickCard(card.id); + + input.click(); + assert.equal(tracks, 1, 'already tracking the aircraft'); assert.deepEqual(h.opened, [ 'https://earthquake.usgs.gov/earthquakes/eventpage/ak1', ]); - } finally { - picking.unregisterPickOwner('test-plane'); - h.layer.destroy(); - } -}); - -/** Click this layer's card with `hit` (another layer's object) under it. */ -function overlayHitCard(h, entryId, hit) { - h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, entryId, hit); + }); } for (const kind of ['card', 'label']) { diff --git a/src/layers/firms/selection.js b/src/layers/firms/selection.js index d6bcdd9cc3..6788cf64f4 100644 --- a/src/layers/firms/selection.js +++ b/src/layers/firms/selection.js @@ -51,7 +51,7 @@ export function createSelection({ if (pickedId && isOwnedByOtherLayer(id, pickedId)) { passivePick = Boolean(isActedOnByOtherLayer) && - !isActedOnByOtherLayer(id, pickedId); + !isActedOnByOtherLayer(id, pickedId, { click: event }); if (!passivePick) return; } } @@ -68,7 +68,7 @@ export function createSelection({ cardHit && contactId && contactId !== resolvePickId(picked ?? null) && - isActedOnByOtherLayer?.(id, contactId, { expanded: true }) + isActedOnByOtherLayer?.(id, contactId, { expanded: true, click: event }) ) return; if (cardHit) { diff --git a/src/layers/vessels/selection.js b/src/layers/vessels/selection.js index 7a4821dc45..1aba2248b5 100644 --- a/src/layers/vessels/selection.js +++ b/src/layers/vessels/selection.js @@ -62,7 +62,9 @@ export function createSelection({ (String(pickedId).startsWith('gev-trail:') || (Boolean(isActedOnByOtherLayer) && isOwnedByOtherLayer('ais-live-vessels', pickedId) && - !isActedOnByOtherLayer('ais-live-vessels', pickedId))); + !isActedOnByOtherLayer('ais-live-vessels', pickedId, { + click: event, + }))); if (passivePick && !ownCardUnder()) return; // A sibling layer already owns this click. Preserve the current vessel @@ -85,6 +87,7 @@ export function createSelection({ resolvePickId?.(event.topHit ?? null) !== pickedId && !isActedOnByOtherLayer('ais-live-vessels', pickedId, { expanded: true, + click: event, }); if (!nearMissOfExactOnly || !ownCardUnder()) return; } From 99bd0443cd0d19c6026cfc969373b4516ed4f68d Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Tue, 17 Nov 2026 17:18:27 +0530 Subject: [PATCH 11/60] fix(touch): keep radio and Street Level contacts under a card Under another layer's card, radio and Street Level yielded whenever their own pick window found an item that was not the tap's touch contact. If the contact was a different station or Street Level item of theirs, the card yielded to that contact too, and the tap did nothing. Under a card they now act on their own touch contact, and still yield when the contact is not theirs. On bare map the window keeps its precedence. --- docs/CURRENT-STATE.md | 4 ++- src/layers/radio/interaction.js | 8 +++--- src/layers/radio/interaction.test.mjs | 32 +++++++++++++++++++++++ src/layers/streetLevel/selection.js | 7 ++++- src/layers/streetLevel/selection.test.mjs | 30 +++++++++++++++++++++ 5 files changed, 76 insertions(+), 5 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 064fa13e44..712b3af4c0 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2064,7 +2064,9 @@ vessels act on that contact, and so do radio and Street Level, which also pick through their own windows (17 and 9 px). A station or Street Level item found only through that window, not as the exact hit or the touch contact, yields to another layer's card or label painted over it, so a quake card or label beside -one acts alone, with a mouse or a coarse pointer. Fire and CCTV cards in turn +one acts alone, with a mouse or a coarse pointer; under such a card, their own +touch contact stays theirs even when the window names another item. Fire and +CCTV cards in turn yield to a touch contact whose layer acts on it. The aircraft a layer already tracks and Street Level's position marker are passive picks, since a click on either does nothing. The pick registry records which owners act on a click's diff --git a/src/layers/radio/interaction.js b/src/layers/radio/interaction.js index 9e1b59f134..154652aed3 100644 --- a/src/layers/radio/interaction.js +++ b/src/layers/radio/interaction.js @@ -51,9 +51,11 @@ export function createInteraction({ if (!stationId) continue; // Found only through our wider window, not as the tap's touch contact: // another layer's card or label painted here is that layer's click, - // since its handler never sees this window. - if (stationFromPick(event.hit) !== stationId && foreignCardAt(event)) - return null; + // since its handler never sees this window. A station of ours that is + // the contact is still ours: that card yields to it. + const contactStationId = stationFromPick(event.hit); + if (contactStationId !== stationId && foreignCardAt(event)) + return contactStationId; return stationId; } return null; diff --git a/src/layers/radio/interaction.test.mjs b/src/layers/radio/interaction.test.mjs index 40d2e48a37..e11dd61bdf 100644 --- a/src/layers/radio/interaction.test.mjs +++ b/src/layers/radio/interaction.test.mjs @@ -101,3 +101,35 @@ test('a window-only station yields to a card painted over it', () => { top = { sourceId: 'radio', entryId: 'radio:kexp' }; assert.equal(radio.pickedRadioStationAt(near()), 'kexp', 'our own card'); }); + +// Under another layer's card, radio's window can name a different station +// from the tap's touch contact. The card yields to that contact, a station of +// ours, so radio acts on it instead of leaving the click dead. +test('under a card, the touch contact station is ours even when the window names another', () => { + const radio = createInteraction({ + state: { _stationById: new Map([['kexp', {}], ['kuow', {}]]) }, + services: { + picking: { + resolvePickId: (picked) => picked?.id ?? null, + isOwnedByOtherLayer: () => false, + registerPickOwner() {}, + unregisterPickOwner() {}, + }, + overlays: { + setOverlaySourceVisible() {}, + hitTestWorldOverlay: () => ({ + sourceId: 'earthquake-card', + entryId: 'earthquake-card:ak1', + }), + }, + }, + parts: { rendering: { radioStationIdFromPick } }, + }); + const tap = (contact) => ({ + ...clickEvent({ windowHits: [hit('radio:kexp')] }), + hit: contact, + screenPosition: { x: 5, y: 5 }, + }); + assert.equal(radio.pickedRadioStationAt(tap(hit('radio:kuow'))), 'kuow'); + assert.equal(radio.pickedRadioStationAt(tap(null)), null, 'no contact'); +}); diff --git a/src/layers/streetLevel/selection.js b/src/layers/streetLevel/selection.js index 1d7a673c23..9a7cfea8f5 100644 --- a/src/layers/streetLevel/selection.js +++ b/src/layers/streetLevel/selection.js @@ -36,9 +36,14 @@ export function createSelection({ state, parts }) { // Found only through our window, not as the contact (which is the exact // hit whenever there is one): another layer's card or label painted here // is that layer's click, since its handler never sees this window. + // An item of ours that is the contact is still ours: that card yields + // to it. if (route && windowId !== contactId) { const at = event.screenPosition; - if (state.services.overlayHit?.(at?.x, at?.y)) return; + if (state.services.overlayHit?.(at?.x, at?.y)) { + route = contactId ? parts.router.resolve(contactId) : null; + if (!route) return; + } } if (!route && contactId) route = parts.router.resolve(contactId); // Not ours: the ground handler decides whether it is the map itself. diff --git a/src/layers/streetLevel/selection.test.mjs b/src/layers/streetLevel/selection.test.mjs index e1bc976f69..db5304b8a0 100644 --- a/src/layers/streetLevel/selection.test.mjs +++ b/src/layers/streetLevel/selection.test.mjs @@ -424,3 +424,33 @@ test('the position marker is a passive pick; our items act', () => { h.restore(); } }); + +// Under another layer's card, our window can name a different item from the +// tap's touch contact. The card yields to that contact, an item of ours, so +// Street Level opens it instead of leaving the click dead. +test('under a card, the touch contact item is ours even when the window names another', (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const h = harness({ + services: { + picking: pickRegistry, + overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), + }, + sceneExtras: { + pick: (_position, width = 3) => + width >= 9 ? { id: 'mly:img:window' } : null, + drillPick: () => [{ id: 'mly:img:contact' }], + }, + }); + try { + h.click(); + assert.deepEqual(h.opened, ['contact']); + assert.equal(h.groundClicks.length, 0); + } finally { + h.restore(); + } +}); From fde5f95b45b90d16510fa9d24462f1442246ca09 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Tue, 17 Nov 2026 18:34:00 +0530 Subject: [PATCH 12/60] docs(changelog): add earthquake selection entry --- changelog.d/1781-earthquake-click-details.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 changelog.d/1781-earthquake-click-details.md diff --git a/changelog.d/1781-earthquake-click-details.md b/changelog.d/1781-earthquake-click-details.md new file mode 100644 index 0000000000..8dc909f6d0 --- /dev/null +++ b/changelog.d/1781-earthquake-click-details.md @@ -0,0 +1,7 @@ +- Make earthquake discs and magnitude labels selectable, with magnitude, USGS + class, depth, location, time and source details. Labels also fly to the quake; + the selected disc shows a fading gradient and bounded contour animation. + Prevent dead or duplicate taps across the affected overlay cards, nearby + contacts and passive trails/routes, including radio and Street Level pick + windows, and keep the Context panel from taking a card's click + (Manjunath, @manjunath22466, #1781). From 731228081771f32fdf9cd686615a36a72de552c8 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Wed, 18 Nov 2026 19:19:41 +0530 Subject: [PATCH 13/60] fix(earthquakes): address review follow-ups on click arbitration A drifting touch tap or a cockpit-mode tap on a fire, quake or vessel card beside an aircraft did nothing: the cards deferred to the aircraft, whose click handler ignores such taps. Pick owners can now declare the clicks they ignore (registerPickOwner(..., { declinesClick })); flights and military decline a drag or a cockpit tap and CCTV declines any click that is not clean, so a card over them keeps that tap. Also from review: - the selected quake's contour rings sit on the ground the disc is draped on, re-read through the heights service while they paint; - a label's fly-to frames the whole disc for large quakes; - a quake that ages out of the feed clears its selection as evicted; - id-less quakes are named by their content, not their row; - the Bhote Koshi trigger-record callout opens its source on a click, as its keyboard action does, and yields like the other cards; - the card's place line is cut to 48 characters, its link hint shows only with an opener, and its accessible name carries depth, place and time; a link-less card's click and keyboard action fly to the quake; - camera trace comparison scales its tolerance with the value and wraps heading and roll. --- docs/CURRENT-STATE.md | 32 +++-- src/app/layers/earthquakeRipples.js | 48 +++++++- src/app/layers/earthquakeRipples.test.mjs | 32 +++++ src/app/layers/earthquakes.js | 4 + src/data/bhoteKoshiLocator.js | 53 +++++++++ src/data/bhoteKoshiLocator.test.mjs | 86 +++++++++++++ src/data/pickOwnerExpanded.test.mjs | 21 +++- src/data/pickRegistry.js | 29 ++++- src/i18n/locales/ar.json | 2 + src/i18n/locales/de.json | 2 + src/i18n/locales/es.json | 2 + src/i18n/locales/fr.json | 2 + src/i18n/locales/he.json | 2 + src/i18n/locales/it.json | 2 + src/i18n/locales/ja.json | 2 + src/i18n/locales/pt.json | 2 + src/i18n/locales/ru.json | 2 + src/i18n/locales/sv.json | 2 + src/i18n/locales/uk.json | 2 + src/i18n/locales/zh-CN.json | 2 + src/i18n/locales/zh-Hant.json | 2 + src/layers/cctv/lifecycle.js | 34 ++++-- src/layers/cctv/lifecycle.test.mjs | 39 +++++- src/layers/earthquakes/index.js | 51 ++++++-- src/layers/earthquakes/model.js | 64 ++++++++-- src/layers/earthquakes/records.js | 13 +- src/layers/earthquakes/records.test.mjs | 31 ++++- src/layers/earthquakes/selection.test.mjs | 139 +++++++++++++++++++++- src/layers/flights/lifecycle.js | 6 + src/layers/military/lifecycle.js | 6 + src/render/cesium/cameraGoldens.test.mjs | 25 +++- src/worldFocus.js | 16 ++- src/worldFocus.test.mjs | 23 ++++ 33 files changed, 702 insertions(+), 76 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 712b3af4c0..57f59afdaa 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2047,14 +2047,20 @@ Clicking a quake's disc selects it; clicking its magnitude label (what a far view can hit) also flies the camera there through the world-focus request (`earthquake` framing in `src/worldFocus.js`). The selected quake shows a card (`describeEarthquake`): magnitude and USGS class (`M5.5 · Moderate`), a -six-step class meter with the depth band, place, UTC time and source; with a -USGS event id the card opens that event's page. The selection is also the +six-step class meter with the depth band, place (cut to 48 characters; the +card's accessible name carries all of it), UTC time and source; with a USGS +event id the card opens that event's page, and without one a click or its +keyboard action flies to the quake. The selection is also the shared context selection, so "what's selected" answers with it. Its disc is painted with a gradient fading to the outer circle and wavy contour lines -(shaped by the quake's id, never crossing) under the labels. The package takes -clicks, picking, context, focus, the opener, the painter and the translator by -injection (`src/app/layers/earthquakes.js`); without input and picking it draws -and takes no clicks, and its labels stay non-interactive. +(shaped by the quake's id, never crossing) under the labels, drawn at the +ground height the disc is draped on (read again, at most twice a second, while +they paint, as the ground loads under a label's fly-to). A label's +fly-to frames the whole disc, scaling its range from the disc's radius above +the M6 framing. The package takes clicks, picking, context, focus, the ground +height, the opener, the painter and the translator by injection +(`src/app/layers/earthquakes.js`); without input and picking it draws and takes +no clicks, and its labels stay non-interactive. On a coarse pointer, a nearby FIRMS or CCTV icon that requires an exact hit does not swallow a quake card or label tap, or a tap on a vessel's own card. Owners that pick nearby contacts register as `expanded` pick owners: flights, @@ -2069,13 +2075,19 @@ touch contact stays theirs even when the window names another item. Fire and CCTV cards in turn yield to a touch contact whose layer acts on it. The aircraft a layer already tracks and Street Level's position marker are passive picks, since a click on -either does nothing. The pick registry records which owners act on a click's -exact hit and touch contact when the click first reads them -(`rememberClickPickActions`), and every layer asks that record for the rest of +either does nothing, and the aircraft layers decline a tap that drifts past +the click travel or comes in cockpit mode (`declinesClick`), as CCTV declines +any click that is not clean, so a card over them keeps that tap. The pick +registry records which owners act on a click's exact hit and touch contact +when the click first reads them (`rememberClickPickActions`), and every layer +asks that record for the rest of the click, so an aircraft that starts tracking during the click does not leave it to a later card handler as well. Fire, CCTV and vessel cards, like the quake's, act over a passive owner's pick (a flight trail, the directions -route); with no card there, that pick still leaves a selection alone. Context +route); with no card there, that pick still leaves a selection alone. The +Bhote Koshi trigger-record callout (`src/data/bhoteKoshiLocator.js`) opens its +source on a click, as its keyboard action does, and yields in the same way: to +a drag, and to a layer that acts on its exact pick or touch contact. Context (`src/ui/entityContextBridge.js`) names what a click identifies, except under a world-overlay card or label when the item's owner does not act on that hit (`cardKeepsClick` in `src/data/pickedContext.js`): a passive route, or a fire diff --git a/src/app/layers/earthquakeRipples.js b/src/app/layers/earthquakeRipples.js index c761eee0fe..015a101189 100644 --- a/src/app/layers/earthquakeRipples.js +++ b/src/app/layers/earthquakeRipples.js @@ -74,6 +74,15 @@ const reducedMotion = () => { } }; +/** How often the rings re-read the ground height under the quake. */ +const HEIGHT_READ_INTERVAL_MS = 500; +/** + * A ground height the rings accept, in metres: the Dead Sea shore to above + * Everest. Anything else is a bad sample (a hit on something drawn above + * the ground, or a broken tile), and the rings stay where they are. + */ +const groundHeightOk = (h) => Number.isFinite(h) && h >= -500 && h <= 9000; + /** * The selected earthquake's contour lines, painted on the world overlay: * wavy closed lines, shaped by the quake's id (earthquakeContourShape), run @@ -220,9 +229,32 @@ export function createEarthquakeRipples({ ); } + /** + * Re-read the ground height under the quake, at most twice a second while + * painting: the ground loads and refines as the camera comes in, and the + * rings move onto it once it differs by more than a metre. + */ + function settleHeight() { + if (!target.heightAt) return; + const at = now(); + if (at - target.heightReadAt < HEIGHT_READ_INTERVAL_MS) return; + target.heightReadAt = at; + let height = null; + try { + height = target.heightAt(); + } catch { + height = null; + } + if (!groundHeightOk(height) || Math.abs(height - target.heightM) <= 1) + return; + target.heightM = height; + target.center = fromDegrees(target.lon, target.lat, height); + } + function paint(frame) { if (!target) return; const { ctx } = frame; + settleHeight(); const center = target.center; onScreen = false; if (frame.occluder?.isPointVisible?.(center) === false) return; @@ -309,7 +341,7 @@ export function createEarthquakeRipples({ /** * Run the contour lines around one quake, replacing any other. - * @param {{id: string, lon: number, lat: number, radiusM: number, color: string}} next + * @param {{id: string, lon: number, lat: number, heightM?: number, heightAt?: () => number|null, radiusM: number, color: string}} next * @param {{restart?: boolean}} [options] `restart: false` updates the * same quake in place (a feed refresh) without running it again. */ @@ -336,7 +368,19 @@ export function createEarthquakeRipples({ } target = { id: next.id, - center: fromDegrees(next.lon, next.lat), + // On the ground the disc is draped on: the height known now, then + // re-read while painting (see `settleHeight`), since a label's fly-to + // starts from far away, before that ground has loaded. + lon: next.lon, + lat: next.lat, + heightM: groundHeightOk(next.heightM) ? next.heightM : 0, + heightAt: typeof next.heightAt === 'function' ? next.heightAt : null, + heightReadAt: -Infinity, + center: fromDegrees( + next.lon, + next.lat, + groundHeightOk(next.heightM) ? next.heightM : 0, + ), radiusM: next.radiusM, color: next.color || 'rgb(255,165,0)', shape: earthquakeContourShape(next.id), diff --git a/src/app/layers/earthquakeRipples.test.mjs b/src/app/layers/earthquakeRipples.test.mjs index e97b9f00a8..1a7e047276 100644 --- a/src/app/layers/earthquakeRipples.test.mjs +++ b/src/app/layers/earthquakeRipples.test.mjs @@ -418,3 +418,35 @@ test('a refresh of the same quake does not run a settled selection again', () => assert.equal(h.frames.size, 1); h.ripples.dispose(); }); + +// The rings sit on the ground the disc is draped on. A label's fly-to starts +// far away, before that ground loads, so the painter reads the height again +// while it paints and moves the rings onto it. +test('the rings move onto the ground height once it loads', () => { + const h = harness(); + let ground = null; + h.ripples.show({ ...target, heightM: 0, heightAt: () => ground }); + h.advance(600); + const [lane] = h.lanes; + lane.painter(h.frame()); + const atSea = h.fills.at(-1).transform; + h.fills.length = 0; + ground = 4000; + h.advance(600); + lane.painter(h.frame()); + const onGround = h.fills.at(-1).transform; + assert.notDeepEqual(onGround, atSea, 'the centre moved up onto the ground'); + // A change of a metre or less, or an impossible height, leaves them put. + for (const next of [4000.5, 25000, -2000]) { + ground = next; + h.advance(600); + lane.painter(h.frame()); + assert.deepEqual(h.fills.at(-1).transform, onGround, String(next)); + } + // Reads are bounded: a second paint within the interval does not ask again. + let reads = 0; + h.ripples.show({ ...target, id: 'ak2', heightAt: () => (reads++, 4000) }); + lane.painter(h.frame()); + lane.painter(h.frame()); + assert.equal(reads, 1); +}); diff --git a/src/app/layers/earthquakes.js b/src/app/layers/earthquakes.js index dc56448d35..1862f4736e 100644 --- a/src/app/layers/earthquakes.js +++ b/src/app/layers/earthquakes.js @@ -7,6 +7,7 @@ import * as context from '../../data/contextStore.js'; import { isPointerFree } from '../../data/inputOwnership.js'; import { requestWorldFocus } from '../../worldFocus.js'; import { createEarthquakeRipples } from './earthquakeRipples.js'; +import { heightsOf } from '../../queries/heights.js'; import { formatDate, formatNumber, t } from '../../i18n/index.js'; const EVENT_TIME = Object.freeze({ @@ -40,6 +41,9 @@ export function createApplicationEarthquakes(options) { openExternal: (url) => window.open(url, '_blank', 'noopener,noreferrer'), focus: { requestWorldFocus }, ripples: createEarthquakeRipples(), + // The loaded ground (terrain or tiles) the clamped disc is draped on. + groundHeight: (viewer, lon, lat) => + viewer ? heightsOf(viewer).now({ lon, lat }) : null, text: earthquakeCardText, ...options, }); diff --git a/src/data/bhoteKoshiLocator.js b/src/data/bhoteKoshiLocator.js index 81c3e3a196..20598df4b7 100644 --- a/src/data/bhoteKoshiLocator.js +++ b/src/data/bhoteKoshiLocator.js @@ -1,7 +1,11 @@ import { clearOverlaySource, + hitTestWorldOverlay, setOverlayEntries, } from '../overlays/worldOverlay.js'; +import { inputFor } from '../input/dispatcher.js'; +import { isActedOnByOtherLayer, resolvePickId } from './pickRegistry.js'; +import { isTrackingSelectionGesture } from './trackingClickGesture.js'; import { governorRequestRender } from '../renderGovernor.js'; import { drawOf, findCamera } from '../render/rendererOf.js'; import { hexColor } from '../render/color.js'; @@ -279,8 +283,12 @@ export function createBhoteKoshiLocatorLayer({ cancelFrame = (handle) => cancelAnimationFrame(handle), scheduleDelay = (callback, delayMs) => setTimeout(callback, delayMs), cancelDelay = (handle) => clearTimeout(handle), + input = inputFor, + hitTest = hitTestWorldOverlay, } = {}) { let _viewer = null; + // The globe click that opens an actionable callout of ours on top. + let _removeClick = null; const _serial = ++layerSerial; // Whether the layer draws: from enable until it is let go. let _drawing = false; @@ -1107,6 +1115,7 @@ export function createBhoteKoshiLocatorLayer({ renderPresentation(); registerDynamicCredit(viewer, BHOTE_KOSHI_LOCATOR_CREDIT); showOsmCredit(viewer, BHOTE_KOSHI_LOCATOR_LAYER_ID); + installCalloutClick(viewer); requestRender('bhote-koshi-locator-callout'); try { @@ -1141,8 +1150,52 @@ export function createBhoteKoshiLocatorLayer({ } } + /** + * An actionable callout of ours (the trigger record's) is a card painted + * over the globe: a click on it opens its source, as its keyboard action + * does. Like the other cards, it leaves a drag alone and yields to a layer + * that acts on what is under it (an aircraft, a vessel): its exact pick, or + * a coarse tap's touch contact whose layer acts on nearby contacts. + */ + function installCalloutClick(viewer) { + if (_removeClick) return; + let clicks = null; + try { + clicks = input?.(viewer) ?? null; + } catch { + clicks = null; + } + _removeClick = + clicks?.onClick?.((event) => { + if (!_enabled || !isTrackingSelectionGesture(event.gesture)) return; + const top = hitTest?.(event.screenPosition?.x, event.screenPosition?.y); + if (top?.sourceId !== BHOTE_KOSHI_LOCATOR_OVERLAY_SOURCE_ID) return; + const exactId = resolvePickId(event.topHit ?? null); + if ( + exactId && + isActedOnByOtherLayer(BHOTE_KOSHI_LOCATOR_LAYER_ID, exactId, { + click: event, + }) + ) + return; + const contactId = resolvePickId(event.hit ?? null); + if ( + contactId && + contactId !== exactId && + isActedOnByOtherLayer(BHOTE_KOSHI_LOCATOR_LAYER_ID, contactId, { + expanded: true, + click: event, + }) + ) + return; + if (typeof top.entry?.activate === 'function') top.entry.activate(); + }) ?? null; + } + async function disable() { hideOsmCredit(_viewer, BHOTE_KOSHI_LOCATOR_LAYER_ID); + _removeClick?.(); + _removeClick = null; _enabled = false; _boundaryReady = false; _boundaryResolved = false; diff --git a/src/data/bhoteKoshiLocator.test.mjs b/src/data/bhoteKoshiLocator.test.mjs index a24afefee6..5c421ec6cb 100644 --- a/src/data/bhoteKoshiLocator.test.mjs +++ b/src/data/bhoteKoshiLocator.test.mjs @@ -11,6 +11,7 @@ import { import { BHOTE_KOSHI_FLOOD_PATH } from './bhoteKoshiFloodPath.js'; import * as Cesium from 'cesium'; import { setLocale } from '../i18n/index.js'; +import { registerPickOwner, unregisterPickOwner } from './pickRegistry.js'; import { SceneDirector } from '../scenes/director.js'; import { createPlaybackClock } from '../director/clock.js'; import { createDefaultScenePacks } from '../scenes/packs/defaults.js'; @@ -1049,3 +1050,88 @@ test('Bhote Koshi locator layers draw sets of their own, and halos only as they assert.equal(await second.disable(), true); assert.equal(viewer._test.live().length, 0); }); + +// The trigger record's callout is an actionable card: the layers under it +// stand aside for it, so a click on it opens its source, as its keyboard +// action does; anything else on top is left alone. +test('a click on the locator callout runs its action', async () => { + const viewer = viewerFixture(); + let onClick = null; + let top = null; + const activated = []; + const layer = createBhoteKoshiLocatorLayer({ + overlayHost: overlayHostFixture(), + requestRender() {}, + ...nonRunningAnimation(), + input: () => ({ + onClick(callback) { + onClick = callback; + return () => { + onClick = null; + }; + }, + }), + hitTest: () => top, + }); + await layer.init(viewer); + await layer.enable(viewer); + const click = (extra = {}) => + onClick?.({ + screenPosition: { x: 5, y: 5 }, + gesture: { travelPx: 0, durationMs: 80 }, + topHit: null, + hit: null, + ...extra, + }); + top = { + sourceId: BHOTE_KOSHI_LOCATOR_OVERLAY_SOURCE_ID, + entryId: 'bhote-koshi-trigger-record-callout', + entry: { activate: () => activated.push('trigger') }, + }; + click(); + assert.deepEqual(activated, ['trigger']); + top = { + sourceId: 'earthquake-card', + entry: { activate: () => activated.push('other') }, + }; + click(); + assert.deepEqual(activated, ['trigger'], 'another layer on top is its own'); + // A drag that ends on it is not a click on it. + top = { + sourceId: BHOTE_KOSHI_LOCATOR_OVERLAY_SOURCE_ID, + entry: { activate: () => activated.push('trigger') }, + }; + click({ gesture: { travelPx: 30, durationMs: 80 } }); + assert.deepEqual(activated, ['trigger'], 'a drag does not open it'); + // An aircraft under it is that layer's click, exact or a touch contact. + registerPickOwner('test-planes', (id) => id === 'plane:1', { + expanded: true, + }); + try { + const plane = { set: 'planes:1', id: 'plane:1' }; + click({ topHit: plane, hit: plane }); + click({ topHit: null, hit: plane }); + assert.deepEqual(activated, ['trigger'], 'the aircraft takes it'); + } finally { + unregisterPickOwner('test-planes'); + } + // A layer that acts only on exact hits does not take a touch contact, and + // one that ignores this click (a long press on a camera) takes nothing: the + // callout keeps both. + registerPickOwner('test-cameras', (id) => id === 'cam:1', { + declinesClick: (event) => (event?.gesture?.durationMs ?? 0) > 400, + }); + try { + const cam = { set: 'cams:1', id: 'cam:1' }; + click({ topHit: null, hit: cam }); + assert.equal(activated.length, 2, 'a near miss of an exact-only camera'); + click({ topHit: cam, hit: cam, gesture: { travelPx: 0, durationMs: 900 } }); + assert.equal(activated.length, 3, 'a long press the camera ignores'); + click({ topHit: cam, hit: cam }); + assert.equal(activated.length, 3, 'a clean click on the camera is its own'); + } finally { + unregisterPickOwner('test-cameras'); + } + await layer.disable(); + assert.equal(onClick, null, 'disable removes the click handler'); +}); diff --git a/src/data/pickOwnerExpanded.test.mjs b/src/data/pickOwnerExpanded.test.mjs index 83ab4afa79..ea013e7ef6 100644 --- a/src/data/pickOwnerExpanded.test.mjs +++ b/src/data/pickOwnerExpanded.test.mjs @@ -51,10 +51,12 @@ function recordingPicking() { }; } -function withDocument(t) { +function withDocument(t, { cockpit = () => false } = {}) { const previous = globalThis.document; globalThis.document = { - body: { classList: { contains: () => false } }, + body: { + classList: { contains: (name) => name === 'cockpit-mode' && cockpit() }, + }, addEventListener() {}, removeEventListener() {}, }; @@ -73,7 +75,8 @@ for (const [name, layerId, create] of [ ['military', 'military', createMilitaryLifecycle], ]) { test(`${name} registers its aircraft as acting on nearby touch hits`, (t) => { - withDocument(t); + let cockpit = false; + withDocument(t, { cockpit: () => cockpit }); const { registered, services } = recordingPicking(); const flightState = stub({ _icons: { show: false, has: (id) => id === `${name}-1` }, @@ -92,6 +95,18 @@ for (const [name, layerId, create] of [ lifecycle.enable({}); assert.equal(registered.get(layerId)?.expanded, true); assert.equal(actsOnNearbyHit(`${name}-1`), true); + // The handler ignores a dragged tap and any tap in cockpit mode, so the + // aircraft acts on neither click. + const nearby = (gesture) => + picking.isActedOnByOtherLayer('earthquakes', `${name}-1`, { + expanded: true, + click: { gesture }, + }); + assert.equal(nearby({ travelPx: 0, durationMs: 80 }), true, 'a tap'); + assert.equal(nearby({ travelPx: 12, durationMs: 80 }), false, 'a drag'); + cockpit = true; + assert.equal(nearby({ travelPx: 0, durationMs: 80 }), false, 'cockpit'); + cockpit = false; // A click on the aircraft already tracked is ignored, so it is passive. flightState._trackedIcao = `${name}-1`; assert.equal(actsOnNearbyHit(`${name}-1`), false); diff --git a/src/data/pickRegistry.js b/src/data/pickRegistry.js index 9b4ef36047..815aac0536 100644 --- a/src/data/pickRegistry.js +++ b/src/data/pickRegistry.js @@ -35,6 +35,12 @@ const _owners = new Map(); const _passive = new Map(); /** Owners whose click handlers also select nearby contacts. */ const _expanded = new Set(); +/** + * Owners whose click handlers act on none of their picks for some clicks + * (aircraft layers ignore a dragged tap, or any tap in cockpit mode). + * @type {Map boolean>} + */ +const _declines = new Map(); /** @type {WeakMap>} */ const clickActions = new WeakMap(); /** @@ -64,20 +70,25 @@ export function resolvePickId(hit) { * @param {string} layerId - Owning layer id (e.g. 'flights'). * @param {(pickedId: string) => boolean} predicate - Returns true when the * picked primitive/entity id belongs to this layer. - * @param {{passive?: boolean | ((pickedId: string) => boolean), expanded?: boolean}} [options] + * @param {{passive?: boolean | ((pickedId: string) => boolean), expanded?: boolean, declinesClick?: (click: object) => boolean}} [options] * `passive`: the layer never acts on a click on these picks (all of them, * or those the predicate names). See {@link isActedOnByOtherLayer}. * `expanded`: preserve precedence for handlers that select nearby contacts, * through the shared contact hit or their own pick window. + * `declinesClick`: true for a click the layer's handler ignores whatever it + * picked (a dragged tap); for that click its picks act for nobody. * @returns {void} */ export function registerPickOwner( layerId, predicate, - { passive, expanded = false } = {}, + { passive, expanded = false, declinesClick } = {}, ) { if (!layerId || typeof predicate !== 'function') return; _owners.set(layerId, predicate); + if (typeof declinesClick === 'function') + _declines.set(layerId, declinesClick); + else _declines.delete(layerId); if (expanded) _expanded.add(layerId); else _expanded.delete(layerId); if (passive === true || typeof passive === 'function') @@ -93,6 +104,7 @@ export function registerPickOwner( export function unregisterPickOwner(layerId) { _owners.delete(layerId); _expanded.delete(layerId); + _declines.delete(layerId); _passive.delete(layerId); } @@ -132,11 +144,16 @@ export function isOwnedByOtherLayer(layerId, pickedId) { return false; } -/** @param {string} pickedId @returns {Generator<[string, boolean]>} */ -function* actingPickOwners(pickedId) { +/** + * @param {string} pickedId + * @param {object} [click] The click being arbitrated, if any. + * @returns {Generator<[string, boolean]>} + */ +function* actingPickOwners(pickedId, click) { for (const [ownerId, predicate] of _owners) { try { if (!predicate(pickedId)) continue; + if (click && _declines.get(ownerId)?.(click)) continue; const passive = _passive.get(ownerId); if (passive === true) continue; if (typeof passive === 'function' && passive(pickedId)) continue; @@ -159,7 +176,7 @@ export function rememberClickPickActions(click, hit) { let actions = clickActions.get(click); if (!actions) clickActions.set(click, (actions = new Map())); if (!actions.has(pickedId)) { - actions.set(pickedId, [...actingPickOwners(pickedId)]); + actions.set(pickedId, [...actingPickOwners(pickedId, click)]); } } @@ -181,7 +198,7 @@ export function isActedOnByOtherLayer( ) { if (!pickedId) return false; const owners = - clickActions.get(click)?.get(pickedId) ?? actingPickOwners(pickedId); + clickActions.get(click)?.get(pickedId) ?? actingPickOwners(pickedId, click); for (const [ownerId, selectsNearby] of owners) { if (ownerId !== layerId && (!expanded || selectsNearby)) return true; } diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json index 1b23b2b88a..a663ecb5c1 100644 --- a/src/i18n/locales/ar.json +++ b/src/i18n/locales/ar.json @@ -3645,6 +3645,8 @@ "Source: {value}": "المصدر: {value}", "Click the card to open EMODnet ↗": "انقر على البطاقة لفتح EMODnet ↗", "Click the card to open the source ↗": "انقر على البطاقة لفتح المصدر ↗", + "Open the source for {title}, {details}": "فتح مصدر «{title}»، {details}", + "Focus earthquake {title}, {details}": "التركيز على الزلزال {title}، {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata غير متاح؛ يُعرض EMODnet فقط", "EMODnet unavailable; showing Wikidata only": "EMODnet غير متاح؛ يُعرض Wikidata فقط", "Shipwrecks unavailable": "بيانات حطام السفن غير متاحة", diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json index 4b132bdc95..0a95dbeb73 100644 --- a/src/i18n/locales/de.json +++ b/src/i18n/locales/de.json @@ -3325,6 +3325,8 @@ "Source: {value}": "Quelle: {value}", "Click the card to open EMODnet ↗": "Eintrag anklicken, um EMODnet zu öffnen ↗", "Click the card to open the source ↗": "Eintrag anklicken, um die Quelle zu öffnen ↗", + "Open the source for {title}, {details}": "Quelle für {title} öffnen, {details}", + "Focus earthquake {title}, {details}": "Erdbeben {title} fokussieren, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata nicht verfügbar; nur EMODnet wird angezeigt", "EMODnet unavailable; showing Wikidata only": "EMODnet nicht verfügbar; nur Wikidata wird angezeigt", "Shipwrecks unavailable": "Schiffswracks nicht verfügbar", diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json index 17d5fa7f42..f47660ae32 100644 --- a/src/i18n/locales/es.json +++ b/src/i18n/locales/es.json @@ -3405,6 +3405,8 @@ "Source: {value}": "Fuente: {value}", "Click the card to open EMODnet ↗": "Haz clic en la tarjeta para abrir EMODnet ↗", "Click the card to open the source ↗": "Haz clic en la tarjeta para abrir la fuente ↗", + "Open the source for {title}, {details}": "Abrir la fuente de {title}, {details}", + "Focus earthquake {title}, {details}": "Enfocar el terremoto {title}, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata no disponible; solo se muestra EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet no disponible; solo se muestra Wikidata", "Shipwrecks unavailable": "Naufragios no disponibles", diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json index 821ea7d78d..d233a74773 100644 --- a/src/i18n/locales/fr.json +++ b/src/i18n/locales/fr.json @@ -3405,6 +3405,8 @@ "Source: {value}": "Source : {value}", "Click the card to open EMODnet ↗": "Cliquez sur la fiche pour ouvrir EMODnet ↗", "Click the card to open the source ↗": "Cliquez sur la fiche pour ouvrir la source ↗", + "Open the source for {title}, {details}": "Ouvrir la source de {title}, {details}", + "Focus earthquake {title}, {details}": "Centrer sur le séisme {title}, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata indisponible ; seul EMODnet est affiché", "EMODnet unavailable; showing Wikidata only": "EMODnet indisponible ; seul Wikidata est affiché", "Shipwrecks unavailable": "Épaves indisponibles", diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json index d8f6d5e082..e2d65f7942 100644 --- a/src/i18n/locales/he.json +++ b/src/i18n/locales/he.json @@ -3531,6 +3531,8 @@ "Click the card to open EMODnet ↗": "לחץ על הכרטיס כדי לפתוח את EMODnet ↗", "Click the card to open the article ↗": "לחץ על הכרטיס כדי לפתוח את הערך ↗", "Click the card to open the source ↗": "לחץ על הכרטיס כדי לפתוח את המקור ↗", + "Open the source for {title}, {details}": "פתיחת המקור של {title}, {details}", + "Focus earthquake {title}, {details}": "התמקדות ברעידת האדמה {title}, {details}", "All years": "כל השנים", "Period": "תקופה", "From": "מ-", diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json index 99a74ffc61..c166ddf76a 100644 --- a/src/i18n/locales/it.json +++ b/src/i18n/locales/it.json @@ -3405,6 +3405,8 @@ "Source: {value}": "Fonte: {value}", "Click the card to open EMODnet ↗": "Fai clic sulla scheda per aprire EMODnet ↗", "Click the card to open the source ↗": "Fai clic sulla scheda per aprire la fonte ↗", + "Open the source for {title}, {details}": "Apri la fonte di {title}, {details}", + "Focus earthquake {title}, {details}": "Inquadra il terremoto {title}, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata non disponibile; solo EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet non disponibile; solo Wikidata", "Shipwrecks unavailable": "Relitti non disponibili", diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json index f52bf611a8..d9859b0e0e 100644 --- a/src/i18n/locales/ja.json +++ b/src/i18n/locales/ja.json @@ -3245,6 +3245,8 @@ "Source: {value}": "出典:{value}", "Click the card to open EMODnet ↗": "カードをクリックしてEMODnetを開く ↗", "Click the card to open the source ↗": "カードをクリックして出典を開く ↗", + "Open the source for {title}, {details}": "{title}のソースを開く({details})", + "Focus earthquake {title}, {details}": "地震{title}にフォーカス({details})", "Wikidata unavailable; showing EMODnet only": "Wikidataを利用できません。EMODnetのみ表示しています", "EMODnet unavailable; showing Wikidata only": "EMODnetを利用できません。Wikidataのみ表示しています", "Shipwrecks unavailable": "難破船データを利用できません", diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json index 1381de0147..ec56549bb7 100644 --- a/src/i18n/locales/pt.json +++ b/src/i18n/locales/pt.json @@ -3405,6 +3405,8 @@ "Source: {value}": "Fonte: {value}", "Click the card to open EMODnet ↗": "Clique no cartão para abrir o EMODnet ↗", "Click the card to open the source ↗": "Clique no cartão para abrir a fonte ↗", + "Open the source for {title}, {details}": "Abrir a fonte de {title}, {details}", + "Focus earthquake {title}, {details}": "Focar terremoto {title}, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata indisponível; mostrando só o EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet indisponível; mostrando só o Wikidata", "Shipwrecks unavailable": "Naufrágios indisponíveis", diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json index eb90cce216..3b68b43589 100644 --- a/src/i18n/locales/ru.json +++ b/src/i18n/locales/ru.json @@ -3485,6 +3485,8 @@ "Source: {value}": "Источник: {value}", "Click the card to open EMODnet ↗": "Нажмите на карточку, чтобы открыть EMODnet ↗", "Click the card to open the source ↗": "Нажмите на карточку, чтобы открыть источник ↗", + "Open the source for {title}, {details}": "Открыть источник: {title}, {details}", + "Focus earthquake {title}, {details}": "Фокус на землетрясении {title}, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata недоступна; показан только EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet недоступен; показана только Wikidata", "Shipwrecks unavailable": "Данные о кораблекрушениях недоступны", diff --git a/src/i18n/locales/sv.json b/src/i18n/locales/sv.json index 84eebf04f7..dd789b4f67 100644 --- a/src/i18n/locales/sv.json +++ b/src/i18n/locales/sv.json @@ -3244,6 +3244,8 @@ "Click the card to open EMODnet ↗": "Klicka på kortet för att öppna EMODnet ↗", "Click the card to open the article ↗": "Klicka på kortet för att öppna artikeln ↗", "Click the card to open the source ↗": "Klicka på kortet för att öppna källan ↗", + "Open the source for {title}, {details}": "Öppna källan för {title}, {details}", + "Focus earthquake {title}, {details}": "Fokusera på jordbävningen {title}, {details}", "All years": "Alla år", "Period": "Period", "From": "Från", diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json index e632648d41..e4d6fc35ce 100644 --- a/src/i18n/locales/uk.json +++ b/src/i18n/locales/uk.json @@ -3485,6 +3485,8 @@ "Source: {value}": "Джерело: {value}", "Click the card to open EMODnet ↗": "Клацніть картку, щоб відкрити EMODnet ↗", "Click the card to open the source ↗": "Клацніть картку, щоб відкрити джерело ↗", + "Open the source for {title}, {details}": "Відкрити джерело: {title}, {details}", + "Focus earthquake {title}, {details}": "Фокус на землетрусі {title}, {details}", "Wikidata unavailable; showing EMODnet only": "Wikidata недоступна; показано лише EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet недоступний; показано лише Wikidata", "Shipwrecks unavailable": "Дані про затонулі судна недоступні", diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json index d11d6b5545..892ca0215d 100644 --- a/src/i18n/locales/zh-CN.json +++ b/src/i18n/locales/zh-CN.json @@ -3245,6 +3245,8 @@ "Source: {value}": "来源:{value}", "Click the card to open EMODnet ↗": "点击卡片打开 EMODnet ↗", "Click the card to open the source ↗": "点击卡片打开来源 ↗", + "Open the source for {title}, {details}": "打开 {title} 的来源,{details}", + "Focus earthquake {title}, {details}": "聚焦地震 {title},{details}", "Wikidata unavailable; showing EMODnet only": "Wikidata 不可用;仅显示 EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet 不可用;仅显示 Wikidata", "Shipwrecks unavailable": "沉船数据不可用", diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json index 34409cc9d8..f0ff358b85 100644 --- a/src/i18n/locales/zh-Hant.json +++ b/src/i18n/locales/zh-Hant.json @@ -3245,6 +3245,8 @@ "Source: {value}": "來源:{value}", "Click the card to open EMODnet ↗": "點擊卡片打開 EMODnet ↗", "Click the card to open the source ↗": "點擊卡片打開來源 ↗", + "Open the source for {title}, {details}": "打開 {title} 的來源,{details}", + "Focus earthquake {title}, {details}": "聚焦地震 {title},{details}", "Wikidata unavailable; showing EMODnet only": "Wikidata 不可用;僅顯示 EMODnet", "EMODnet unavailable; showing Wikidata only": "EMODnet 不可用;僅顯示 Wikidata", "Shipwrecks unavailable": "沉船數據不可用", diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index 2e3da9c172..cd704d2617 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -5,6 +5,7 @@ import { viewshedColors, cameraHue } from '../../data/cctvViewshed.js'; import { CCTV_OVERLAY_SOURCE_ID } from '../../data/cctvCards.js'; import { GIZMO_ID_PREFIX } from '../../data/cctvGizmo.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isTrackingClickGesture } from '../../data/trackingClickGesture.js'; import { GROUND_PRIOR_INIT_WAIT_MS, CALIBRATION_RANGE_FLOOR_M, @@ -509,19 +510,26 @@ export function createLifecycle({ layerState._lastUpdate = Date.now(); // Pick-ownership (H2): camera icons use the camera id directly; // coverage polyline entities use `cctv--` entity ids. - registerPickOwner('cctv', (pickedId) => { - if (layerState._recordById.has(pickedId)) return true; - if ( - typeof pickedId === 'string' && - pickedId.startsWith(GIZMO_ID_PREFIX) - ) - return true; - const coverage = - /^cctv-(.+)-(?:ray-tl|ray-tr|ray-br|ray-bl|cap|plane|plane-label)$/.exec( - pickedId, - ); - return Boolean(coverage && layerState._recordById.has(coverage[1])); - }); + registerPickOwner( + 'cctv', + (pickedId) => { + if (layerState._recordById.has(pickedId)) return true; + if ( + typeof pickedId === 'string' && + pickedId.startsWith(GIZMO_ID_PREFIX) + ) + return true; + const coverage = + /^cctv-(.+)-(?:ray-tl|ray-tr|ray-br|ray-bl|cap|plane|plane-label)$/.exec( + pickedId, + ); + return Boolean(coverage && layerState._recordById.has(coverage[1])); + }, + // The world click handler takes only clean clicks (see + // `bindCctvWorldClickGesture`), so a card over a camera keeps any + // other tap. + { declinesClick: (click) => !isTrackingClickGesture(click?.gesture) }, + ); if (!layerState._activeCameraId && layerState._records.length) { layerState._activeCameraId = parts.navigation.openingCameraId(); layerState._autoHopSuspended = false; diff --git a/src/layers/cctv/lifecycle.test.mjs b/src/layers/cctv/lifecycle.test.mjs index cf1c3f98bd..2ff86b0fff 100644 --- a/src/layers/cctv/lifecycle.test.mjs +++ b/src/layers/cctv/lifecycle.test.mjs @@ -136,8 +136,8 @@ test('world clicks respect the painted top card and registered card backgrounds' }; const services = { sprites: {}, - focus: {}, - render: {}, + focus: { onFocusTargetAppear: () => noop }, + render: { releaseContinuousRender: noop }, picking, activation: { activateCctvCameraFromWorldClick: (id) => actions.push(id) }, }; @@ -152,6 +152,7 @@ test('world clicks respect the painted top card and registered card backgrounds' picking.unregisterPickOwner('test-trails'); picking.unregisterPickOwner('test-planes'); picking.unregisterPickOwner('test-tracking'); + picking.unregisterPickOwner('test-exact'); picking.unregisterCardBackground('area-fixture'); }); await lifecycle.methods.init(viewer); @@ -214,6 +215,13 @@ test('world clicks respect the painted top card and registered card backgrounds' // A coarse tap whose touch contact is an aircraft (a layer that acts on // nearby contacts) is the aircraft's, even under a live CCTV card. const previousMatch = globalThis.matchMedia; + const restoreMatch = () => { + if (previousMatch) globalThis.matchMedia = previousMatch; + else delete globalThis.matchMedia; + }; + // Restored below for the fine-pointer clicks that follow; here too, so a + // failing assertion cannot leave the coarse pointer for later tests. + t.after(restoreMatch); globalThis.matchMedia = () => ({ matches: true }); picking.registerPickOwner('test-planes', (id) => id === 'plane:1', { expanded: true, @@ -230,8 +238,7 @@ test('world clicks respect the painted top card and registered card backgrounds' drilled = []; click(null, [ownCard], ['cam-1']); picking.unregisterPickOwner('test-planes'); - if (previousMatch) globalThis.matchMedia = previousMatch; - else delete globalThis.matchMedia; + restoreMatch(); // The live card reads the owners that acted when the click resolved, so it // yields to the aircraft even though tracking made it passive meanwhile. picking.registerPickOwner('test-tracking', (id) => id === 'plane:9', { @@ -253,4 +260,28 @@ test('world clicks respect the painted top card and registered card backgrounds' [foreignCard, ownCard], ['cam-1'], ); + // CCTV takes only clean clicks, so for a long press or a drag its cameras + // act for nobody: a card painted over one keeps that tap. + // Enable's own work is beside the point here: only its registration. + Object.assign(parts.cards, { + refreshAmbientCards: noop, + startCardFrameLoop: noop, + }); + parts.frames = { refreshProjectionImage: noop }; + Object.assign(parts.geometryQueue, { startGeometryLoadQueue: noop }); + parts.navigation = { openingCameraId: () => 'cam-1' }; + Object.assign(parts.projection, { + ensureProjectionRuntime: noop, + startProjectionLoop: noop, + }); + state._cctvOverlayHost.setVisible ??= noop; + lifecycle.methods.enable(); + t.after(() => picking.unregisterPickOwner('cctv')); + const acted = (gesture) => + picking.isActedOnByOtherLayer('earthquakes', 'cam-1', { + click: { gesture }, + }); + assert.equal(acted({ travelPx: 0, durationMs: 80 }), true, 'a clean click'); + assert.equal(acted({ travelPx: 0, durationMs: 900 }), false, 'a long press'); + assert.equal(acted({ travelPx: 20, durationMs: 80 }), false, 'a drag'); }); diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 93e715e03e..1389662a74 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -35,6 +35,8 @@ export const EARTHQUAKES_LAYER_ID = 'earthquakes'; 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:'; +/** Fly-to range per metre of disc radius: 220 km frames an M6 (64 km). */ +const EARTHQUAKE_FOCUS_RANGE_PER_RADIUS = 3.5; /** The selected quake's flat fill, faint under the painted gradient. */ const SELECTED_DISC_ALPHA = 0.04; const CARD_HOST_OPTIONS = Object.freeze({ @@ -73,8 +75,12 @@ let instances = 0; * @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] + * heightM?: number, heightAt?: () => number|null, radiusM: number, + * color: string}) => void, hide: () => void}} [options.ripples] * The selected quake's animated contour rings. + * @param {(viewer: object, lon: number, lat: number) => number|null} [options.groundHeight] + * The loaded ground height under a point, so the rings sit on the disc + * that is draped there; null (or no service) draws them at sea level. * @param {object} [options.text] Card formatters (see describeEarthquake). */ export function createEarthquakesLayer({ @@ -87,6 +93,7 @@ export function createEarthquakesLayer({ openExternal = null, focus = null, ripples = null, + groundHeight = null, text = undefined, } = {}) { if (typeof source?.getSnapshot !== 'function') @@ -189,12 +196,14 @@ export function createEarthquakesLayer({ function publishCard({ user = false } = {}) { const event = _selectedId ? _eventById.get(_selectedId) : null; if (!_enabled || !event) { - clearSelection(); + // A refresh that no longer carries the selected quake evicts it, as + // other feeds report; anything else is a deliberate clear. + clearSelection({ evicted: _enabled && Boolean(_selectedId) && !user }); return; } const { title, details, link, accessibilityLabel } = describeEarthquake( event, - text, + { ...text, canOpen: Boolean(openExternal) }, ); _selectedLink = link && openExternal ? link : null; const card = { @@ -222,6 +231,12 @@ export function createEarthquakesLayer({ openExternal(target); return true; }; + } else if (focus?.requestWorldFocus) { + // No source to open: the card's keyboard action flies to its quake, + // as a fire card's focuses its fire, so it stays in the action list. + const stableId = event.stableId; + card.accessibilityLabel = accessibilityLabel; + card.activate = () => selectAndFocus(stableId); } _selectedCardId = card.id; overlayHost.setEntries( @@ -232,11 +247,22 @@ export function createEarthquakesLayer({ overlayHost.setVisible(EARTHQUAKE_CARD_SOURCE_ID, true); publishContext(event, user); fadeDisc(event.stableId); + let heightM = null; + try { + heightM = groundHeight?.(_viewer, event.lon, event.lat) ?? null; + } catch { + heightM = null; + } ripples?.show?.( { id: event.stableId, lon: event.lon, lat: event.lat, + heightM: Number.isFinite(heightM) ? heightM : 0, + // Read again as the ground loads: a label's fly-to starts far away. + heightAt: groundHeight + ? () => groundHeight(_viewer, event.lon, event.lat) + : null, radiusM: earthquakeDiscRadiusM(event.mag), color: depthAccent(event.depthKm || 0), }, @@ -284,10 +310,12 @@ export function createEarthquakesLayer({ } } - function clearContext() { + function clearContext({ evicted = false } = {}) { if (!context || !_contextId) return; try { - context.clearSelectedEntityContextForLayer(EARTHQUAKES_LAYER_ID); + context.clearSelectedEntityContextForLayer(EARTHQUAKES_LAYER_ID, { + evicted, + }); context.getContextStore().entities.delete(_contextId); } catch { // store unavailable: nothing to clean @@ -295,12 +323,12 @@ export function createEarthquakesLayer({ _contextId = null; } - function clearSelection() { + function clearSelection({ evicted = false } = {}) { const had = _selectedId || _selectedCardId; _selectedId = null; _selectedCardId = null; _selectedLink = null; - clearContext(); + clearContext({ evicted }); ripples?.hide?.(); fadeDisc(null); if (had) @@ -362,7 +390,11 @@ export function createEarthquakesLayer({ sourceId: EARTHQUAKE_CARD_SOURCE_ID, }); if (cardHit && cardHit.entryId === _selectedCardId) { + // The card's action, as its keyboard action: open the source, or + // with none, fly to the quake. if (_selectedLink) openExternal(_selectedLink); + else if (focus?.requestWorldFocus && _selectedId) + selectAndFocus(_selectedId); return; } // A magnitude label is what a far view (the whole globe) can click: @@ -399,6 +431,11 @@ export function createEarthquakesLayer({ id: `${PICK_PREFIX}${stableId}`, label: earthquakeMagnitudeTitle(event.mag), position: fromDegrees(event.lon, event.lat), + // The whole disc in view: the framing's range fits an M6 disc, so a + // larger one scales it (the framing stays the floor). + radiusM: earthquakeDiscRadiusM(event.mag), + rangeM: + earthquakeDiscRadiusM(event.mag) * EARTHQUAKE_FOCUS_RANGE_PER_RADIUS, }); return true; } diff --git a/src/layers/earthquakes/model.js b/src/layers/earthquakes/model.js index 228758c011..4e0abaf107 100644 --- a/src/layers/earthquakes/model.js +++ b/src/layers/earthquakes/model.js @@ -23,6 +23,12 @@ export const EARTHQUAKE_MARK_MAGNITUDE = 6; /** The longest place a timeline mark's label carries, ellipsis and all. */ const MARK_PLACE_LENGTH = 40; +/** + * The longest place line the detail card shows, ellipsis and all, so a long + * place or translation keeps the card inside a phone's width. The card's + * accessible name carries the whole place. + */ +const CARD_PLACE_LENGTH = 48; /** A magnitude as the map's labels show it: `M6.4`. */ export const earthquakeMagnitudeTitle = (magnitude) => @@ -163,43 +169,77 @@ const oneDecimal = (value) => String(Math.round(value * 10) / 10); * @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. + * @param {boolean} [text.canOpen] Whether a link can be opened here (an + * opener is injected); without one the card offers no link to click. * @returns {{title: string, details: string[], link: string|null, - * accessibilityLabel: string}} + * accessibilityLabel: string}} `accessibilityLabel` names the card's + * action, with its details: opening the source, or focusing the quake. */ export function describeEarthquake( event, - { t = english, formatTime = utcMinute, formatDepth = oneDecimal } = {}, + { + t = english, + formatTime = utcMinute, + formatDepth = oneDecimal, + canOpen = true, + } = {}, ) { const details = []; + // What the card says, spoken: depth, the whole place, and the time. + const spoken = []; // 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), - })}`, - ); + const depth = `${earthquakeDepthBandName(event.depthKm, t)} · ${t( + '{km} km deep', + { km: formatDepth(event.depthKm) }, + )}`; + glance.push(depth); + spoken.push(depth); } 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' })); + if (place) { + // Cut by characters, not UTF-16 units, so a pair is never split. + const chars = Array.from(place); + details.push( + chars.length > CARD_PLACE_LENGTH + ? `${chars + .slice(0, CARD_PLACE_LENGTH - 1) + .join('') + .trimEnd()}…` + : place, + ); + spoken.push(place); + } + if (Number.isFinite(event?.time)) { + const time = formatTime(event.time); + details.push(time); + spoken.push(time); + } + const source = t('Source: {value}', { value: 'USGS' }); + details.push(source); + // The source closes the spoken details, so they are never empty. + spoken.push(source); const link = earthquakeEventLink(event?.usgsId); - if (link) details.push(t('Click the card to open the source ↗')); + const opens = Boolean(link) && canOpen; + if (opens) details.push(t('Click the card to open the source ↗')); const title = `${earthquakeMagnitudeTitle(event?.mag)} · ${earthquakeSeverityName( event?.mag, t, )}`; + const summary = { title, details: spoken.join(', ') }; return { title, details, link, - accessibilityLabel: t('Open the source for {title}', { title }), + accessibilityLabel: opens + ? t('Open the source for {title}, {details}', summary) + : t('Focus earthquake {title}, {details}', summary), }; } diff --git a/src/layers/earthquakes/records.js b/src/layers/earthquakes/records.js index 397b4bb1c8..caaf8bc879 100644 --- a/src/layers/earthquakes/records.js +++ b/src/layers/earthquakes/records.js @@ -28,10 +28,15 @@ export function normalizeEarthquakeSnapshot(geojson) { return null; // A missing magnitude cannot establish that this event meets M2.5+. if (mag == null || mag < 2.5) continue; - const stableId = - feature.id == null || feature.id === '' - ? `event-${index + 1}` - : String(feature.id); + // An id-less event is named by what it is (time, position, depth and + // magnitude), not by its row, so a refresh that inserts a row keeps the + // selection on the same quake; a revision to any of those names a new + // one. Two id-less events that match exactly fall back to the row. + const idless = feature.id == null || feature.id === ''; + let stableId = idless + ? `event-${[properties.time ?? 'na', lon, lat, depthKm ?? 'na', mag].join(':')}` + : String(feature.id); + if (idless && ids.has(stableId)) stableId = `${stableId}:${index + 1}`; if (ids.has(stableId)) return null; ids.add(stableId); rows.push({ diff --git a/src/layers/earthquakes/records.test.mjs b/src/layers/earthquakes/records.test.mjs index cd7b6a8741..bc3447db2b 100644 --- a/src/layers/earthquakes/records.test.mjs +++ b/src/layers/earthquakes/records.test.mjs @@ -37,7 +37,7 @@ test('normalizeEarthquakeSnapshot parses valid GeoJSON earthquake features', () }); }); -test('normalizeEarthquakeSnapshot generates index-based stable IDs when id is missing or blank', () => { +test('normalizeEarthquakeSnapshot names id-less events by their content, not their row', () => { const geojson = { features: [ { @@ -55,10 +55,35 @@ test('normalizeEarthquakeSnapshot generates index-based stable IDs when id is mi const rows = normalizeEarthquakeSnapshot(geojson); assert.equal(rows.length, 2); - assert.equal(rows[0].stableId, 'event-1'); + assert.equal(rows[0].stableId, 'event-1711930000000:139.6917:35.6895:25:3.5'); assert.equal(rows[0].usgsId, null); - assert.equal(rows[1].stableId, 'event-2'); + assert.equal( + rows[1].stableId, + 'event-1711931000000:-70.6693:-33.4489:45.2:5.1', + ); assert.equal(rows[1].usgsId, ''); + // A row inserted ahead of them keeps each id-less quake's id, so a selected + // one stays selected across the refresh. + const inserted = normalizeEarthquakeSnapshot({ + features: [ + { + id: 'us7000new', + geometry: { type: 'Point', coordinates: [10, 20, 5] }, + properties: { mag: 4, place: 'New', time: 1711932000000 }, + }, + ...geojson.features, + ], + }); + assert.deepEqual( + inserted.map((row) => row.stableId).slice(1), + rows.map((row) => row.stableId), + ); + // Two id-less events that match exactly stay apart. + const twins = normalizeEarthquakeSnapshot({ + features: [geojson.features[0], geojson.features[0]], + }); + assert.equal(twins.length, 2); + assert.notEqual(twins[0].stableId, twins[1].stableId); }); test('normalizeEarthquakeSnapshot filters events below M2.5 without dropping the feed', () => { diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index 65f82c8745..496908b19a 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -39,7 +39,12 @@ const quake = (id, extra = {}) => ({ /** A layer whose globe clicks, card hits and context store the test drives. */ function harness( rows, - { context = null, ripples = null, input: inputFactory = null } = {}, + { + context = null, + ripples = null, + groundHeight = null, + input: inputFactory = null, + } = {}, ) { let snapshot = rows; const handlers = []; @@ -95,6 +100,7 @@ function harness( picking, context, ripples, + groundHeight, pointer: { isPointerFree: () => true }, openExternal: (url) => opened.push(url), focus: { @@ -179,7 +185,10 @@ test('clicking a quake disc shows its detail card; empty map clears it', async ( '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( + card.accessibilityLabel, + 'Open the source for M4.1 · Light, Intermediate · 112.4 km deep, 42 km W of Fixture, Alaska, 2026-11-13 15:37 UTC, Source: USGS', + ); assert.equal(h.visible.get(EARTHQUAKE_CARD_SOURCE_ID), true); h.click(null); @@ -209,11 +218,17 @@ test('a quake with no USGS id gets a card with no link', async () => { 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'))); + // No source to open: a click on the card flies to the quake instead. h.clickCard(card.id); assert.deepEqual(h.opened, []); + assert.equal(h.focused.length, 1); + // Its keyboard action does the same, so it still has a place in the + // action list. + assert.match(card.accessibilityLabel, /^Focus earthquake M2\.5 · Minor, /); + assert.equal(card.activate(), true); + assert.equal(h.focused.length, 2); + assert.deepEqual(h.opened, []); assert.equal(h.lastCard()[0].id, card.id, 'the card stays'); h.layer.destroy(); }); @@ -360,6 +375,24 @@ test('describeEarthquake translates through the given formatters', () => { assert.equal(bare.title, 'M3.0 · Minor'); assert.deepEqual(bare.details, ['■□□□□□', 'Source: USGS']); assert.equal(bare.link, null); + assert.equal( + bare.accessibilityLabel, + 'Focus earthquake M3.0 · Minor, Source: USGS', + ); + // A place cut short never splits a character made of a surrogate pair. + const emoji = describeEarthquake(quake('ak9', { place: '🌋'.repeat(60) })); + assert.equal(Array.from(emoji.details[1]).length, 48); + assert.ok(!/[\uD800-\uDBFF]…$/.test(emoji.details[1])); + // A long place is cut short on the card; the accessible name keeps it all. + const long = 'A very long place name '.repeat(4).trim(); + const wide = describeEarthquake(quake('ak9', { place: long })); + assert.equal(Array.from(wide.details[1]).length, 48); + assert.ok(wide.details[1].endsWith('…')); + assert.ok(wide.accessibilityLabel.includes(long)); + // With no opener to follow a link, the card does not offer one. + const closed = describeEarthquake(quake('ak9'), { canOpen: false }); + assert.ok(!closed.details.some((line) => line.includes('Click the card'))); + assert.match(closed.accessibilityLabel, /^Focus earthquake /); }); test('severity follows the USGS magnitude classes; depth bands the disc colours', () => { @@ -418,6 +451,9 @@ test('clicking a magnitude label selects the quake and flies to it', async () => assert.ok( Math.hypot(detail.position.x, detail.position.y, detail.position.z) > 6e6, ); + // The whole disc in view: radius and range scale with the magnitude. + assert.equal(detail.radiusM, 32000); + assert.equal(detail.rangeM, 32000 * 3.5); // The keyboard path does the same. assert.equal( @@ -470,21 +506,34 @@ test('the selected quake runs contour rings to its disc edge; clearing stops the hide: () => calls.push(['hide']), dispose: () => calls.push(['dispose']), }; + // The ground the disc is draped on: the rings are drawn at its height. + const heights = []; const h = harness( [quake('ak1', { mag: 5, depthKm: 10 }), quake('ak2', { mag: 3 })], - { ripples }, + { + ripples, + groundHeight: (viewer, lon, lat) => { + heights.push([lon, lat]); + return lon === -153.3 ? 1840 : null; + }, + }, ); 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, { + const { heightAt, ...rest } = shown; + assert.deepEqual(rest, { id: 'ak1', lon: -153.3, lat: 60, + heightM: 1840, radiusM: 32000, color: 'rgb(255,0,0)', }); + assert.deepEqual(heights.at(-1), [-153.3, 60]); + // The painter can read the ground again as it loads (a label's fly-to). + assert.equal(heightAt(), 1840); assert.equal( h.discs().items.get('earthquake:ak1').geometry.semiMajor, shown.radiusM, @@ -1054,3 +1103,81 @@ test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits input?.destroy(); } }); + +// A tap that drifts more than the tracking click travel is ignored by the +// aircraft layers, so a quake card painted beside an aircraft keeps it. +test('a quake card keeps a dragged tap beside an aircraft that declines it', async (t) => { + const previous = globalThis.matchMedia; + globalThis.matchMedia = () => ({ matches: true }); + t.after(() => { + if (previous) globalThis.matchMedia = previous; + else delete globalThis.matchMedia; + }); + const plane = { set: 'flights:1', id: 'plane-9' }; + let sceneHit = null; + let nearby = null; + let input; + const h = harness([quake('ak1')], { + input(viewer) { + viewer.scene = { + pick: () => (sceneHit ? { id: sceneHit } : null), + drillPick: () => (nearby ? [{ id: nearby }] : []), + }; + input = fakeInput(viewer); + return input.input; + }, + }); + picking.registerPickOwner('test-plane', (id) => id === plane.id, { + expanded: true, + declinesClick: (click) => (click?.gesture?.travelPx ?? 0) > 6, + }); + t.after(() => { + picking.unregisterPickOwner('test-plane'); + h.layer.destroy(); + input?.destroy(); + }); + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + sceneHit = { set: h.discs().spec.id, id: 'earthquake:ak1' }; + input.click(); + const card = h.lastCard()[0]; + h.overlayHits.set(EARTHQUAKE_CARD_SOURCE_ID, { + sourceId: EARTHQUAKE_CARD_SOURCE_ID, + entryId: card.id, + }); + sceneHit = null; + nearby = plane; + // A still tap: the aircraft acts on its contact, so the card yields. + input.tap({ x: 10, y: 10 }); + assert.deepEqual(h.opened, []); + // A tap that drifts 10 px: the aircraft ignores it, so the card opens. + input.down({ x: 10, y: 10 }); + input.move({ x: 20, y: 10 }, { x: 10, y: 10 }); + input.up({ x: 20, y: 10 }); + input.click({ x: 20, y: 10 }); + assert.equal(h.opened.length, 1, 'the card keeps the dragged tap'); +}); + +// A refresh that no longer carries the selected quake evicts it, as other +// feeds report; a click on empty map is a deliberate clear. +test('a quake that ages out of the feed is cleared as evicted', async () => { + const clears = []; + const context = { + registerEntityContext: (record) => ({ ...record, id: record.id }), + selectEntityContext() {}, + clearSelectedEntityContextForLayer: (layerId, options) => + clears.push([layerId, options?.evicted === true]), + getContextStore: () => ({ entities: new Map() }), + }; + const h = harness([quake('ak1'), quake('ak2')], { context }); + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + h.clickDisc('ak1'); + h.setRows([quake('ak2')]); + await h.layer.update(h.viewer); + assert.deepEqual(clears.at(-1), ['earthquakes', true], 'aged out: evicted'); + h.clickDisc('ak2'); + h.click(null); + assert.deepEqual(clears.at(-1), ['earthquakes', false], 'empty map'); + h.layer.destroy(); +}); diff --git a/src/layers/flights/lifecycle.js b/src/layers/flights/lifecycle.js index f85260f735..fa25261e83 100644 --- a/src/layers/flights/lifecycle.js +++ b/src/layers/flights/lifecycle.js @@ -1,3 +1,4 @@ +import { isTrackingSelectionGesture } from '../../data/trackingClickGesture.js'; import { findCamera, findFrame } from '../../render/rendererOf.js'; import { loadFleetModelSet } from '../../data/fleetModels.js'; import { forgetPlacedAircraft } from './placed.js'; @@ -141,6 +142,11 @@ export function createLifecycle({ passive: (pickedId) => Boolean(flightState._trackedIcao) && pickedId === flightState._trackedIcao, + // The click handler ignores a dragged tap and any tap in cockpit + // mode, so a card over the aircraft keeps that tap. + declinesClick: (click) => + !isTrackingSelectionGesture(click?.gesture) || + Boolean(document.body?.classList.contains('cockpit-mode')), }, ); const frame = findFrame(viewer); diff --git a/src/layers/military/lifecycle.js b/src/layers/military/lifecycle.js index 7c96171206..c7e667d4ff 100644 --- a/src/layers/military/lifecycle.js +++ b/src/layers/military/lifecycle.js @@ -1,3 +1,4 @@ +import { isTrackingSelectionGesture } from '../../data/trackingClickGesture.js'; import { findCamera, findFrame } from '../../render/rendererOf.js'; import { loadFleetModelSet } from '../../data/fleetModels.js'; import { forgetPlacedAircraft } from '../flights/placed.js'; @@ -122,6 +123,11 @@ export function createLifecycle({ passive: (pickedId) => Boolean(flightState._trackedIcao) && pickedId === flightState._trackedIcao, + // The click handler ignores a dragged tap and any tap in cockpit + // mode, so a card over the aircraft keeps that tap. + declinesClick: (click) => + !isTrackingSelectionGesture(click?.gesture) || + Boolean(document.body?.classList.contains('cockpit-mode')), }, ); // The flights layer suppresses its military duplicates while we render them diff --git a/src/render/cesium/cameraGoldens.test.mjs b/src/render/cesium/cameraGoldens.test.mjs index 91ca593516..d6983579cb 100644 --- a/src/render/cesium/cameraGoldens.test.mjs +++ b/src/render/cesium/cameraGoldens.test.mjs @@ -2,7 +2,7 @@ import { test } from 'node:test'; import assert from 'node:assert/strict'; import { readFileSync } from 'node:fs'; import { recordCameraGoldens } from './cameraGoldens.js'; -import { near } from '../conformance/expect.js'; +import { near, nearAngle } from '../conformance/expect.js'; // The recorder is deterministic, but platforms can differ in the last bits // of trigonometric arithmetic. Keep structure and discrete values exact. @@ -18,7 +18,16 @@ function compareTrace(actual, expected, path = []) { path.at(-2) === 'position' || key === 'height' || (path.at(-2) === 'view' && Number(key) >= 12 && Number(key) <= 14); - near(actual, expected, metres ? 1e-8 : 1e-14, label); + // A few ulps of the value itself, so large untagged values (pick points, + // ray origins, the far plane) are not held below one ulp. + const tolerance = Math.max( + metres ? 1e-8 : 1e-14, + Math.abs(expected) * 4 * Number.EPSILON, + ); + // Heading and roll wrap at 2π: a value just under it is one just over 0. + if (key === 'heading' || key === 'roll') + nearAngle(actual, expected, tolerance, label); + else near(actual, expected, tolerance, label); return; } if (expected !== null && typeof expected === 'object') { @@ -71,3 +80,15 @@ test('trace comparison tolerates only numeric roundoff, preserving structure and const { label, ...missing } = expected; assert.throws(() => compareTrace(missing, expected)); }); + +test('trace comparison scales with the value and wraps heading and roll', () => { + // One ulp of a ground pick point (about 5e-10 at 3e6 m) is roundoff. + const far = 3_000_000.123; + compareTrace({ pick: far + 2 * Number.EPSILON * far }, { pick: far }); + assert.throws(() => compareTrace({ pick: far + 1e-6 }, { pick: far })); + // A heading just under 2π is one just over 0. + compareTrace({ heading: 2 * Math.PI - 1e-16 }, { heading: 1e-16 }); + compareTrace({ roll: 1e-16 }, { roll: 2 * Math.PI - 1e-16 }); + assert.throws(() => compareTrace({ heading: 0.1 }, { heading: 0 })); + assert.throws(() => compareTrace({ heading: NaN }, { heading: 0 })); +}); diff --git a/src/worldFocus.js b/src/worldFocus.js index cf9e2fb90f..f2c3d1ce91 100644 --- a/src/worldFocus.js +++ b/src/worldFocus.js @@ -18,8 +18,9 @@ export const WORLD_FOCUS_FRAMING = Object.freeze({ // A stopped train's one fly-to, and the frame a moving train is followed // in (src/layers/rail/follow.js): the train and the track either side. train: Object.freeze({ radiusM: 200, rangeM: 2500, pitchDeg: -35 }), - // A clicked quake's magnitude label: its disc (2^M km across, so about - // 11 km at M2.5 and 128 km at M6) and the ground around it. + // A clicked quake's magnitude label: its disc (2^M km in radius, so about + // 6 km at M2.5 and 64 km at M6) and the ground around it. A larger quake + // passes its own radius and range (never less than these). earthquake: Object.freeze({ radiusM: 20000, rangeM: 220000, pitchDeg: -45 }), 'sighting-area': Object.freeze({ radiusM: 11000, @@ -115,13 +116,20 @@ export function flyToWorldTarget(viewer, target = {}) { target.durationSec > 0 ? target.durationSec : WORLD_CLICK_FOCUS_DURATION_SEC; + // A target may ask for more room than its kind's framing (a large quake's + // disc), never less. + const atLeast = (value, floor) => + Number.isFinite(value) && value > floor ? value : floor; camera.flyToBounds( - { center: target.position, radius: framing.radiusM }, + { + center: target.position, + radius: atLeast(target.radiusM, framing.radiusM), + }, { offset: { heading, pitch: toRadians(framing.pitchDeg), - range: framing.rangeM, + range: atLeast(target.rangeM, framing.rangeM), }, durationS: duration, easing: 'cubicInOut', diff --git a/src/worldFocus.test.mjs b/src/worldFocus.test.mjs index 8512a969d4..de4981fd20 100644 --- a/src/worldFocus.test.mjs +++ b/src/worldFocus.test.mjs @@ -206,6 +206,29 @@ test('fires frame wider than vessels — a fire is read by its surroundings', () ); }); +// A large quake's disc does not fit the earthquake framing, so the target +// asks for more room; it never gets less than the framing. +test('a target can widen its framing, never narrow it', () => { + const fly = (extra) => { + const camera = stubCamera(); + flyToWorldTarget(bindFakeCesiumCamera({ camera }), { + kind: 'earthquake', + id: 'earthquake:us1', + position: POSITION, + ...extra, + }); + return camera.calls.flights[0]; + }; + const m72 = fly({ radiusM: 147000, rangeM: 514000 }); + assert.equal(m72.sphere.radius, 147000); + assert.equal(m72.options.offset.range, 514000); + const m3 = fly({ radiusM: 8000, rangeM: 28000 }); + assert.equal(m3.sphere.radius, WORLD_FOCUS_FRAMING.earthquake.radiusM); + assert.equal(m3.options.offset.range, WORLD_FOCUS_FRAMING.earthquake.rangeM); + const bad = fly({ radiusM: NaN, rangeM: -1 }); + assert.equal(bad.options.offset.range, WORLD_FOCUS_FRAMING.earthquake.rangeM); +}); + test('every framing is a real oblique standoff, not a nadir or an inside-out sphere', () => { const kinds = Object.keys(WORLD_FOCUS_FRAMING); assert.deepEqual(kinds.sort(), [ From ee37511332479cc3798d803d86fa88c057825a03 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 16:35:52 -0800 Subject: [PATCH 14/60] Keep the saved Satellites state when Satellites is still busy as Space Missions turns off When Satellites had not settled within the 30 s limit, turning Space Missions off cleared the saved Satellites state and put the parameters back before failing, so Satellites stayed on as Space Missions had switched it with nothing left to retry. Now a busy Satellites layer is left untouched and the saved state is kept, so turning Space Missions off again finishes the restore. A Satellites action the person took still gets its parameters back. Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 4 ++- src/layers/launches/failedEntry.test.mjs | 7 +++++ src/layers/launches/ingestion.js | 15 ++++++---- src/layers/launches/missionCycler.test.mjs | 33 ++++++++++++++++++++++ 4 files changed, 52 insertions(+), 7 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 64207f325a..7661e19e7c 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -5592,7 +5592,9 @@ activeCameraCardEnabled: true })` may publish it through the retained > switching Space Missions off restores the pre-mission Satellite enabled > state and presentation parameters, except that an explicit Satellites action > taken while it ran is kept. Restored parameters never re-show primitives -> while the Satellite layer is disabled. +> while the Satellite layer is disabled. When Satellites is still busy after +> the 30 s limit, the restore changes nothing and keeps the saved state, so +> switching Space Missions off again finishes it. > - **Flights 3D/cockpit hardening:** the destination-direction cue is an > inline SVG rather than a remotely loaded Material Icons ligature, so a > blocked or late font can no longer expand the literal word `navigation` diff --git a/src/layers/launches/failedEntry.test.mjs b/src/layers/launches/failedEntry.test.mjs index de7b8719b3..eba7a917f9 100644 --- a/src/layers/launches/failedEntry.test.mjs +++ b/src/layers/launches/failedEntry.test.mjs @@ -623,6 +623,13 @@ test('a Satellites enable that never settles still lets mission disable complete stuck.resolve(); } await f.settle(); + // The saved Satellites state was kept: turning Space Missions off again + // once Satellites settles gives back the Satellites it turned on. + assert.equal(f.manager.isEnabled('satellites'), true); + await f.manager.setEnabled('rocket-launches', false, { origin: 'user' }); + await f.settle(); + assert.equal(f.manager.isEnabled('rocket-launches'), false); + assert.equal(f.manager.isEnabled('satellites'), false); }); test('a failed Satellites restore still clears the selected mission panel', async (t) => { diff --git a/src/layers/launches/ingestion.js b/src/layers/launches/ingestion.js index 35a4c47771..d328700b2f 100644 --- a/src/layers/launches/ingestion.js +++ b/src/layers/launches/ingestion.js @@ -179,18 +179,21 @@ export function createIngestion({ layerState._satelliteStateBeforeMission !== snapshot ) return; + // An accepted Satellites action owns visibility through mission teardown. + const restoreVisibility = snapshot.restoreVisibility !== false; + // Satellites is still busy: change nothing and keep the saved state, so + // turning Space Missions off again can finish the restore. + if (restoreVisibility && !idle) + throw new Error( + 'Space Missions could not restore the satellites layer: it did not settle', + ); layerState._satelliteStateBeforeMission = null; layerState._satelliteActivationPromise = null; manager.setLayerParams( 'satellites', parts.policyHelpers.satelliteParamsAfterSpaceMissions(snapshot.params), ); - // An accepted Satellites action owns visibility through mission teardown. - if (snapshot.restoreVisibility === false) return; - if (!idle) - throw new Error( - 'Space Missions could not restore the satellites layer: it did not settle', - ); + if (!restoreVisibility) return; const restored = await manager.setEnabled('satellites', snapshot.enabled); if ( restored === false || diff --git a/src/layers/launches/missionCycler.test.mjs b/src/layers/launches/missionCycler.test.mjs index 1f07a12cff..06bf4bf0bf 100644 --- a/src/layers/launches/missionCycler.test.mjs +++ b/src/layers/launches/missionCycler.test.mjs @@ -177,3 +177,36 @@ test('without a Satellites action the exit restores the pre-mission visibility', ['enabled', 'satellites', false], ]); }); + +test('a Satellites layer that does not settle keeps the saved state for the next exit', async () => { + const r = satelliteRig({ enabledBefore: false }); + let idle = false; + r.state._dataManager.waitForLayerIdle = async () => idle; + await assert.rejects( + r.ingestion.restoreSatelliteDependency(), + /did not settle/, + ); + assert.deepEqual(r.calls, [], 'nothing changes while Satellites is busy'); + assert.deepEqual(r.state._satelliteStateBeforeMission, { + enabled: false, + params: { mode: 'before' }, + }); + + // Turning Space Missions off again once Satellites settles finishes it. + idle = true; + await r.ingestion.restoreSatelliteDependency(); + assert.deepEqual(r.calls, [ + ['params', 'satellites', { mode: 'before' }], + ['enabled', 'satellites', false], + ]); + assert.equal(r.state._satelliteStateBeforeMission, null); +}); + +test('a Satellites action the person took still gets its parameters back when Satellites is busy', async () => { + const r = satelliteRig({ enabledBefore: false }); + r.state._dataManager.waitForLayerIdle = async () => false; + r.state._satelliteStateBeforeMission.restoreVisibility = false; + await r.ingestion.restoreSatelliteDependency(); + assert.deepEqual(r.calls, [['params', 'satellites', { mode: 'before' }]]); + assert.equal(r.state._satelliteStateBeforeMission, null); +}); From 9ac937af82293d5dd1ab447da3171452b6a66a5d Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 16:36:00 -0800 Subject: [PATCH 15/60] Let every click subscriber hear a mission-label click A click a painted overlay handled, such as a Space Missions label, returned before any click subscriber ran, so the layers that close their cards or let go of their selection on a click never heard it. Now only the picking the label replaces is skipped: subscribers still hear the click, marked as an overlay click whose hit is the label (no draw set, no id, nothing drilled), and the geometry beneath it is not picked. Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 2 +- src/input/dispatcher.js | 43 ++++++++++++++--- src/input/dispatcher.test.mjs | 62 ++++++++++++++++++++++++- src/layers/launches/labelClick.test.mjs | 15 ++++-- 4 files changed, 109 insertions(+), 13 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 7661e19e7c..3fc14cfa37 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -7493,7 +7493,7 @@ silently demoting every later lookup for the session. protected-card path. Disable tears the tier down completely. Coverage/viewshed semantics unchanged. - **Satellites**: every point moves every frame. Each satellite's SGP4 sample (position, velocity, gravity and its rate of change; `src/layers/satellites/motion.js`) is reckoned forward or back to the world time and turned into the Earth-fixed frame, so points glide at any play speed instead of stepping once a second. Core satellites take a fresh sample every second, or as soon as the world time is 30 s from their sample (fast play, a seek), which keeps every point within about 10 m of SGP4; Starlink extras are sampled round-robin, more per frame the faster time plays, and a point more than two minutes from its sample waits for the next one. Hidden points are not moved until shown. Orbit rings rotate about Earth's Z by ΔGMST every ~1s (exact inertial→ECEF compensation; no SGP4 re-runs); the tracked satellite propagates per frame with one shared epoch for dot/label/camera. Verified: ISS holds <1km perpendicular to its ring while tracked. Pass prediction (`src/data/satellitePass.js`; `getNextSatellitePass`, `getNextIssPass`) scans at 20s, bisects rise/set to ~0.2s, fits the peak with a parabola, and marks a pass visible when the satellite is outside a cylindrical Earth shadow while the observer's Sun is at or below −6°. `next_iss_pass` preserves its geometric-pass ordering and appends visibility metadata. General `next_satellite_pass` accepts a loaded NORAD ID or unambiguous name, searches 24 hours and optionally requires estimated visibility. These estimates do not account for weather or satellite brightness. -- **Space Missions (30d)**: recent launches render as bounded shared-host, horizon-occluded mission markers using Launch Library 2 v2.3 detailed records. Enabling the layer reveals its own right-rail button and roster and enables the required satellite layer; it does not touch Context. Before applying its temporary dense/hidden Satellite mode, Space Missions snapshots the complete standalone Satellite parameter set and exact enabled-layer set. Disabling Space Missions from Data Layers hides its rail button and panel and restores those parameters and the exact prior enabled state, so a Satellite layer that was already on stays on while a mode-owned dependency returns off; enabling Satellites by itself remains independent. An explicit user or voice Satellites OFF requested after Space Missions ON exits Space Missions, including after returning from Stories; scene, story, preset and other programmatic Satellites changes do not. The controls under the Space Missions row cycle through available launches. Selecting a mission isolates its launch-to-orbit transfer and dashed satellite orbit, fills the Space Missions panel with details, navigation, and replay controls, and animates a small phase-colored marker along the exact displayed Cartesian samples. Marker hit testing drill-picks through photorealistic tiles so the depth-test-free tactical dot remains reliably selectable. Clicking the launch name on the globe selects and focuses the same mission as its dot. The selected pad is the camera's zoom pivot: the overview remains centered on its launch site, wheel zoom approaches that site instead of drifting elsewhere, and camera pitch progressively changes from global nadir to an oblique close 3D view. Its protected shared-host callout remains visible and expands to include both mission and launch-site names. `FOCUS` flies directly to a 12 km oblique frame around the selected launch site and retains the same anchored zoom/orbit behavior. `REPLAY ASCENT` resets the selected marker at the pad, frames it from an oblique third-person angle, and follows it through the mission-specific compressed ascent directly into one orbital lap at the default `1×` rate. A live `0.25×`–`4×` slider changes ascent and orbit playback speed; adjusting it mid-replay preserves the current path position and historical mission timestamp. Re-entry/recovery cannot be inserted into replay. At orbit insertion the camera smoothly pulls back over the first fifth of the orbital replay and pitches to a globe-scale nadir view while continuing to target the moving replay point. Replay Cancel, mission navigation, deselection, layer disable, and data refresh all release camera ownership. Reconstructed paths are one continuous 128-sample geodetic curve: horizontal departure begins near zero while altitude rises quickly, then the climb progressively bends toward insertion without the former hard 120 km corner. Unmatched orbit fallbacks are smooth planar inclined rings rather than longitude/latitude ground-track curves. The panel lists disclosed payload names, types, operators/manufacturers, mass, multiplicity, and destination when supplied; an empty LL2 payload collection is shown as `CLASSIFIED / MULTI-PAYLOAD`. Launcher, spacecraft, and recoverable payload stages appear in a compact stage table with serial/flight/reuse details, recovery outcome/type, destination, and final coordinates when those records exist; an empty recovery collection omits the section. Stage recoveries with confirmed coordinates use those coordinates; return-to-launch-site records use the pad; downrange-only records receive an explicitly labeled estimated endpoint along the ascent azimuth. Available endpoints render as static 2 px dashed descent/recovery paths with a fixed final-position dot and an estimated atmospheric-interface segment when applicable. The ascent is geodetically densified above the ellipsoid toward the orbit's nearest insertion point, then rendered with `ArcType.NONE`, so it neither cuts through Earth nor separates from the marker. Because LL2 does not normally supply continuous ascent telemetry, pad-to-insertion paths without upstream trajectory samples are labeled `RECONSTRUCTED ESTIMATE` / `ASCENT ESTIMATE`; only supplied trajectory samples receive the replay wording. Selected-orbit framing fits the complete ring, rear-side linework uses normal scene depth occlusion, and current distance, speed, and callout data come only from a launch-year-validated satellite match. Both the loaded-catalog and active-TLE lookups read the launch year from the TLE international designator through one parser (`src/sources/tle.js`); a blank or malformed designator is an unknown year, which skips the year check rather than rejecting the match. Speed is the magnitude of the SGP4 inertial velocity vector at the same propagation epoch as position, displayed in km/s with km/h available as hover detail. Unavailable operator, site, launch-time, orbit, current-altitude, and speed values omit their detail rows instead of reserving panel space with placeholders. Newly launched payloads absent from the core operational groups use CelesTrak's cached active TLE feed as a lookup-only fallback; weak constellation-name matches are rejected. The replay callout maps compressed animation progress onto Launch Library's mission-relative timeline, showing the historical UTC date/time at the marker's current path position; unavailable timelines remain explicit. Matched live satellite positions propagate at one-second cadence and use a distinct green dot/callout with the current UTC date/time. +- **Space Missions (30d)**: recent launches render as bounded shared-host, horizon-occluded mission markers using Launch Library 2 v2.3 detailed records. Enabling the layer reveals its own right-rail button and roster and enables the required satellite layer; it does not touch Context. Before applying its temporary dense/hidden Satellite mode, Space Missions snapshots the complete standalone Satellite parameter set and exact enabled-layer set. Disabling Space Missions from Data Layers hides its rail button and panel and restores those parameters and the exact prior enabled state, so a Satellite layer that was already on stays on while a mode-owned dependency returns off; enabling Satellites by itself remains independent. An explicit user or voice Satellites OFF requested after Space Missions ON exits Space Missions, including after returning from Stories; scene, story, preset and other programmatic Satellites changes do not. The controls under the Space Missions row cycle through available launches. Selecting a mission isolates its launch-to-orbit transfer and dashed satellite orbit, fills the Space Missions panel with details, navigation, and replay controls, and animates a small phase-colored marker along the exact displayed Cartesian samples. Marker hit testing drill-picks through photorealistic tiles so the depth-test-free tactical dot remains reliably selectable. Clicking the launch name on the globe selects and focuses the same mission as its dot; what is drawn beneath the name is not picked, and the other layers still hear the click as one on the name, so they close their cards or let go of their selection as for any other click. The selected pad is the camera's zoom pivot: the overview remains centered on its launch site, wheel zoom approaches that site instead of drifting elsewhere, and camera pitch progressively changes from global nadir to an oblique close 3D view. Its protected shared-host callout remains visible and expands to include both mission and launch-site names. `FOCUS` flies directly to a 12 km oblique frame around the selected launch site and retains the same anchored zoom/orbit behavior. `REPLAY ASCENT` resets the selected marker at the pad, frames it from an oblique third-person angle, and follows it through the mission-specific compressed ascent directly into one orbital lap at the default `1×` rate. A live `0.25×`–`4×` slider changes ascent and orbit playback speed; adjusting it mid-replay preserves the current path position and historical mission timestamp. Re-entry/recovery cannot be inserted into replay. At orbit insertion the camera smoothly pulls back over the first fifth of the orbital replay and pitches to a globe-scale nadir view while continuing to target the moving replay point. Replay Cancel, mission navigation, deselection, layer disable, and data refresh all release camera ownership. Reconstructed paths are one continuous 128-sample geodetic curve: horizontal departure begins near zero while altitude rises quickly, then the climb progressively bends toward insertion without the former hard 120 km corner. Unmatched orbit fallbacks are smooth planar inclined rings rather than longitude/latitude ground-track curves. The panel lists disclosed payload names, types, operators/manufacturers, mass, multiplicity, and destination when supplied; an empty LL2 payload collection is shown as `CLASSIFIED / MULTI-PAYLOAD`. Launcher, spacecraft, and recoverable payload stages appear in a compact stage table with serial/flight/reuse details, recovery outcome/type, destination, and final coordinates when those records exist; an empty recovery collection omits the section. Stage recoveries with confirmed coordinates use those coordinates; return-to-launch-site records use the pad; downrange-only records receive an explicitly labeled estimated endpoint along the ascent azimuth. Available endpoints render as static 2 px dashed descent/recovery paths with a fixed final-position dot and an estimated atmospheric-interface segment when applicable. The ascent is geodetically densified above the ellipsoid toward the orbit's nearest insertion point, then rendered with `ArcType.NONE`, so it neither cuts through Earth nor separates from the marker. Because LL2 does not normally supply continuous ascent telemetry, pad-to-insertion paths without upstream trajectory samples are labeled `RECONSTRUCTED ESTIMATE` / `ASCENT ESTIMATE`; only supplied trajectory samples receive the replay wording. Selected-orbit framing fits the complete ring, rear-side linework uses normal scene depth occlusion, and current distance, speed, and callout data come only from a launch-year-validated satellite match. Both the loaded-catalog and active-TLE lookups read the launch year from the TLE international designator through one parser (`src/sources/tle.js`); a blank or malformed designator is an unknown year, which skips the year check rather than rejecting the match. Speed is the magnitude of the SGP4 inertial velocity vector at the same propagation epoch as position, displayed in km/s with km/h available as hover detail. Unavailable operator, site, launch-time, orbit, current-altitude, and speed values omit their detail rows instead of reserving panel space with placeholders. Newly launched payloads absent from the core operational groups use CelesTrak's cached active TLE feed as a lookup-only fallback; weak constellation-name matches are rejected. The replay callout maps compressed animation progress onto Launch Library's mission-relative timeline, showing the historical UTC date/time at the marker's current path position; unavailable timelines remain explicit. Matched live satellite positions propagate at one-second cadence and use a distinct green dot/callout with the current UTC date/time. When no mission is selected, the Space Missions panel presents a scrollable newest-first roster of every launch in the rolling window, including the smaller 5 px operator-colored marker, provider, and launch date. Hovering or keyboard-focusing a row shows four compact cyan corner brackets on both that roster row and its corresponding globe dot, rotates the globe at the current zoom to center it, and gives its label declutter priority without selecting it; the globe label remains unbracketed. Selecting a roster row invokes the same mission isolation and full-orbit framing as clicking its globe marker. The replay vehicle is one screen-space SVG/CSS HUD overlay rather than separate Cesium billboard, label, and reticle graphics. It is hidden during ordinary Focus and manual close views, where the standard selected launch-site label remains visible, and exists only while ascent replay is active. Its fixed pixel scale is shared by ascent and insertion, so camera range never resizes the rocket on screen before the phase boundary. Generic Launch Library pad names are reduced to their identifying suffix, and replay timestamps use a cyan state title over unprefixed white UTC date/time values. `REPLAY ASCENT` holds the unframed cyan/white rocket at the pad for a real-time `T−10` countdown, transitions through `LIFTOFF`, and attaches six tapered cyan/white ellipse waves directly below it from liftoff through insertion to convey thrust without adding scene geometry. While replay is active, the single start button is replaced by compact Play, Pause, and Cancel icon controls. Pause freezes countdown or mission time, vehicle/stage positions, camera target, labels, and thrust-wave animation; Play resumes from that exact frame, and Cancel releases replay camera ownership. The rocket and thrust group rotates from the path's live screen-space tangent, so its nose follows the visible ascent curve while the adjacent text remains upright. The camera begins as a close oblique launch chase, then smoothly widens between roughly 120 and 420 km vehicle altitude into a higher oblique context view that keeps the moving rocket targeted while exposing the ascent bend and orbit connection. At insertion the rocket/thrust glyph is replaced by the fixed-size cyan orbit dot, which the camera follows through the existing globe-scale orbit pullback. The chase camera limits per-frame yaw changes across heading wraps so it cannot abruptly cross in front of the vehicle and make ascent read in reverse; the replay-speed slider affects mission playback but not countdown duration. Mission world text has no native `LabelGraphics`: overview launch markers publish at most 48 ambient candidates for a 24-winner budget, while selecting a mission clears that overview source and publishes its launch-site callout, stage re-entry annotations, live/estimated payload-position readout, and orbit annotation as protected selected-lane entries. The source retains the exact former strings and colors. Static anchors reuse the Cartesian values used to build their mission geometry; the moving payload entry reads the layer's per-frame live-position cache; catalog-backed orbit annotation positions are cached in the same one-second matrix update that realigns the orbit primitive. Keyhole edge fade, horizon culling, final collision placement, and UI exclusion are owned by the shared host. Deselect restores the bounded overview, and refresh, disable, and destroy replace or clear both mission sources. A selected mission renders its orbit as four repeating tactical sectors, each containing one prominent cyan dot followed by one hundred thin translucent dashes. The bright dots act as orbit anchors while the subdued dash field remains depth-tested against the globe and is shown only for the selected mission. diff --git a/src/input/dispatcher.js b/src/input/dispatcher.js index b5c8fa86cf..32ae401c47 100644 --- a/src/input/dispatcher.js +++ b/src/input/dispatcher.js @@ -182,6 +182,9 @@ function topHitOf(hit, foreign) { * when the adapter has none. * @property {unknown} pick `native.pick`, for code still bound to the * engine's pick objects that reads it here. + * @property {boolean} overlay Whether a painted overlay target took the + * click ({@link InputDispatcher.onOverlayClick}). Its hits then name only + * that target: something drawn outside the draw port, with no id. * @property {(width: number, height: number) => unknown} pickWindow * `native.pickWindow`, the same. */ @@ -192,7 +195,9 @@ function topHitOf(hit, foreign) { * Ambient click subscription. Returns its unsubscribe. * @property {(fn: (event: ClickEvent) => boolean) => () => void} onOverlayClick * Hit-test a painted overlay before ambient clicks. Return true after - * handling its topmost target to stop delivery to the geometry beneath it. + * handling its topmost target: the geometry beneath it is not picked, and + * the click subscribers hear the click as one on that target (`overlay` + * true, `topHit` a hit with no set and no id, nothing drilled). * @property {(type: 'down'|'move'|'up'|'click'|'dblclick', fn: Function, options?: {lease?: object|(() => object|null)}) => () => void} onPointer * Raw pointer subscription: `click` gets the {@link ClickEvent}, the others * `{position}` (`move`: `{startPosition, endPosition, pickPosition}`, its @@ -331,7 +336,7 @@ function createDispatcher(viewer, { query: givenQuery, ...portOptions } = {}) { click: (ev) => { if (!unmodifiedLeft(ev)) return; const ambient = free(); - const event = createClickEvent( + const { event, cover } = createClickEvent( viewer, queryOf, xy(ev.position), @@ -340,7 +345,12 @@ function createDispatcher(viewer, { query: givenQuery, ...portOptions } = {}) { if (ambient) { for (const handle of [...overlayClicks]) { try { - if (handle(event) === true) return; + // A handled overlay target hides the geometry beneath it; every + // subscriber still hears the click, as a click on that target. + if (handle(event) === true) { + cover(); + break; + } } catch (error) { console.error('Pointer input handler failed', error); } @@ -437,6 +447,10 @@ function createDispatcher(viewer, { query: givenQuery, ...portOptions } = {}) { return self; } +/** What a click handled by a painted overlay target hits: that target, + * drawn outside the draw port and named by no pick id. */ +const OVERLAY_HIT = Object.freeze({ set: '', id: null, surface: false }); + /** A drill is run at least this deep and sliced, so callers asking for * different depths on one click share one pass. */ const DRILL_DEPTH = 16; @@ -446,7 +460,8 @@ const DRILL_DEPTH = 16; * @param {() => import('../render/contract/query').QueryPort|null} queryOf * @param {{x: number, y: number}} at Where the click is, CSS pixels. * @param {ClickGesture} gesture - * @returns {ClickEvent} + * @returns {{event: ClickEvent, cover: () => void}} The click, and how a + * handled overlay target hides the geometry beneath it from the click. */ function createClickEvent(viewer, queryOf, at, gesture) { const position = sensorPickPosition(viewer, at, canvasOf(viewer)); @@ -465,11 +480,25 @@ function createClickEvent(viewer, queryOf, at, gesture) { }; /** @type {Map} */ const drills = new Map(); + let covered = false; + const cover = () => { + covered = true; + memo.clear(); + drills.clear(); + memo.set('top', OVERLAY_HIT); + memo.set('hit', OVERLAY_HIT); + memo.set('id', null); + memo.set('ownerId', null); + memo.set('native', null); + }; - return { + const event = { screenPosition: at, position, gesture, + get overlay() { + return covered; + }, get topHit() { return once('top', () => { const hit = pick(); @@ -515,6 +544,7 @@ function createClickEvent(viewer, queryOf, at, gesture) { return !this.hit; }, windowHit(width, height) { + if (covered) return { id: null, drawHit: null, surface: false }; return once(`windowHit:${width}x${height}`, () => { const picked = pick({ width, height }); void native()?.native.pickWindow(width, height); @@ -535,7 +565,7 @@ function createClickEvent(viewer, queryOf, at, gesture) { // A deeper pass already made holds these. (One that came back short // may not hold every hit: it drops what is not a draw-set item.) if (done && limit <= done.limit) return done.hits.slice(0, limit); - const q = query(); + const q = covered ? null : query(); if (!q) return []; // Only the default window is shared between layers; round that one up. const depth = @@ -568,4 +598,5 @@ function createClickEvent(viewer, queryOf, at, gesture) { return native()?.native.pickWindow(width, height); }, }; + return { event, cover }; } diff --git a/src/input/dispatcher.test.mjs b/src/input/dispatcher.test.mjs index c88e1af8b1..965c63374d 100644 --- a/src/input/dispatcher.test.mjs +++ b/src/input/dispatcher.test.mjs @@ -145,7 +145,8 @@ test('a painted overlay can claim a click before its underlying owner', (t) => { h.input.onPointer('click', () => clicks.push('ambient pointer')); h.click(); - assert.deepEqual(clicks, ['mission label']); + // The click still reaches every subscriber, as one on the label. + assert.deepEqual(clicks, ['mission label', 'ambient pointer', null]); assert.equal(h.calls.pick, 0); h.click(11, 10); @@ -154,12 +155,71 @@ test('a painted overlay can claim a click before its underlying owner', (t) => { assert.deepEqual(clicks, [ 'mission label', 'ambient pointer', + null, + 'ambient pointer', 'satellites', 'ambient pointer', 'satellites', ]); }); +test('a click a painted overlay handles still reaches subscribers that clear selection', (t) => { + const h = harness({ + pick: () => ({ set: 'flights', id: 'abc123' }), + drillPick: () => [{ set: 'flights', id: 'abc123' }], + }); + t.after(() => h.input.destroy()); + let seenByOverlay = null; + h.input.onOverlayClick((event) => { + seenByOverlay = event; + return true; + }); + const seen = []; + h.input.onClick((event) => { + seen.push({ + same: event === seenByOverlay, + overlay: event.overlay, + topHit: event.topHit, + drawHit: event.drawHit, + hit: event.hit, + id: event.id, + ownerId: event.ownerId, + surface: event.surface, + drill: event.drill(4), + windowHit: event.windowHit(8, 8), + pick: event.pick, + }); + }); + h.click(); + assert.deepEqual(seen, [ + { + same: true, + overlay: true, + topHit: { set: '', id: null, surface: false }, + drawHit: null, + hit: { set: '', id: null, surface: false }, + id: null, + ownerId: null, + surface: false, + drill: [], + windowHit: { id: null, drawHit: null, surface: false }, + pick: undefined, + }, + ]); + assert.equal(h.calls.pick, 0, 'the geometry beneath is not picked'); + assert.equal(h.calls.drillPick, 0); + + // Without an overlay target the same click picks the geometry. + seen.length = 0; + h.input.destroy(); + const g = harness({ pick: () => ({ set: 'flights', id: 'abc123' }) }); + t.after(() => g.input.destroy()); + g.input.onClick((event) => seen.push([event.overlay, event.topHit])); + g.click(); + assert.equal(seen[0][0], false); + assert.equal(g.calls.pick, 1); +}); + test('the gesture carries summed travel and press time', (t) => { const h = harness(); t.after(() => h.input.destroy()); diff --git a/src/layers/launches/labelClick.test.mjs b/src/layers/launches/labelClick.test.mjs index 592b5ccaaf..7c50f3fdb0 100644 --- a/src/layers/launches/labelClick.test.mjs +++ b/src/layers/launches/labelClick.test.mjs @@ -118,11 +118,15 @@ const label = ( entryId, }); -test('a mission label click focuses its launch and stops the click there', (t) => { - const r = rig(t, { overlayHit: label('launch:L2') }); +test('a mission label click focuses its launch and covers the geometry beneath', (t) => { + const r = rig(t, { overlayHit: label('launch:L2'), geometryLaunchId: 'L1' }); r.click(); - assert.deepEqual(r.focused, ['L2']); - assert.equal(r.ambient.length, 0, 'the layers beneath do not see it'); + assert.deepEqual(r.focused, ['L2'], 'the mission beneath is not picked'); + // Other layers still hear it, to close their cards or clear selection, + // as a click on the label rather than on the geometry beneath. + assert.equal(r.ambient.length, 1); + assert.equal(r.ambient[0].overlay, true); + assert.equal(r.ambient[0].drawHit, null); r.setHit(label('launch:L1', ROCKET_MISSION_SELECTED_OVERLAY_SOURCE_ID)); r.click(); @@ -156,7 +160,8 @@ test('a throwing globe-pick listener does not stop the pick', (t) => { r.click(); assert.deepEqual(r.focused, ['L1']); assert.deepEqual(heard, ['L1']); - assert.equal(r.ambient.length, 0); + assert.equal(r.ambient.length, 1); + assert.equal(r.ambient[0].overlay, true); }); test('a mission label for an unknown launch falls through to other layers', (t) => { From 8675ead171d15676433695f69694531c425b709b Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 16:37:48 -0800 Subject: [PATCH 16/60] Stop roster hover and focus from moving the camera while Space Missions goes off While Space Missions was going off (its Satellites restore still running, the panel still shown), hovering or keyboard-focusing a roster row still scheduled the roster preview, which flew the camera to that launch with nothing left to end it. The preview is no longer scheduled once the layer is going off, and one already pending is dropped. Selection, focus, replay and stepping from the Data Layers row were already refused then. Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 4 +++- src/layers/launches/panel.js | 10 ++++++++-- src/layers/launches/panel.test.mjs | 24 ++++++++++++++++++++++++ 3 files changed, 35 insertions(+), 3 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 3fc14cfa37..38d838d0e2 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -5594,7 +5594,9 @@ activeCameraCardEnabled: true })` may publish it through the retained > taken while it ran is kept. Restored parameters never re-show primitives > while the Satellite layer is disabled. When Satellites is still busy after > the 30 s limit, the restore changes nothing and keeps the saved state, so -> switching Space Missions off again finishes it. +> switching Space Missions off again finishes it. While Space Missions goes +> off, its panel's roster and controls select, focus, preview and replay +> nothing, so no camera move starts that nothing would end. > - **Flights 3D/cockpit hardening:** the destination-direction cue is an > inline SVG rather than a remotely loaded Material Icons ligature, so a > blocked or late font can no longer expand the literal word `navigation` diff --git a/src/layers/launches/panel.js b/src/layers/launches/panel.js index 470adc9d9e..9dc827d5ca 100644 --- a/src/layers/launches/panel.js +++ b/src/layers/launches/panel.js @@ -380,14 +380,20 @@ export function createPanel({ state: layerState, services, parts, source }) { function scheduleMissionRosterPreview(index) { const launch = layerState._launches[index]; - if (!launch || layerState._selectedLaunchId) return; + // Once the layer is going off (its Satellites restore may still be + // running) hovering or focusing a roster row moves no camera. + if (!launch || layerState._selectedLaunchId || !layerState._enabled) return; if (layerState._missionRosterHoverTimer) clearTimeout(layerState._missionRosterHoverTimer); layerState._hoveredRosterLaunchId = launch.id; parts.overlays.syncMissionOverlayEntries(); layerState._missionRosterHoverTimer = setTimeout(() => { layerState._missionRosterHoverTimer = null; - if (layerState._hoveredRosterLaunchId !== launch.id) return; + if ( + layerState._hoveredRosterLaunchId !== launch.id || + !layerState._enabled + ) + return; const currentLaunch = resolveMissionRosterPreviewLaunch( layerState._launches, launch.id, diff --git a/src/layers/launches/panel.test.mjs b/src/layers/launches/panel.test.mjs index 9075d5e5cb..4e0a558944 100644 --- a/src/layers/launches/panel.test.mjs +++ b/src/layers/launches/panel.test.mjs @@ -9,6 +9,7 @@ function fixture() { const state = createState({ services: { overlays: {}, render: {} }, }); + state._enabled = true; const calls = []; const parts = { overlays: { @@ -194,3 +195,26 @@ test('the panel commands act on the selected mission', () => { ['select', null, undefined], ]); }); + +test('a roster row hovered or focused while the layer goes off moves no camera', async () => { + const { state, panel, calls } = fixture(); + state._launches = [launch('a'), launch('b')]; + panel.createMissionPanel(); + panel.renderMissionRoster(); + + // Hovered just before the layer goes off: the pending preview is dropped. + panel.commands.rosterPointerEnter(0); + state._enabled = false; + await new Promise((resolve) => setTimeout(resolve, 160)); + + // Hovered or focused after it went off, while the panel still shows. + panel.commands.rosterPointerEnter(1); + panel.commands.rosterFocus(1); + assert.equal(state._missionRosterHoverTimer, null, 'no preview is pending'); + await new Promise((resolve) => setTimeout(resolve, 160)); + assert.deepEqual( + calls.filter(([name]) => name === 'preview'), + [], + ); + panel.clearMissionPanel(); +}); From 8885177e2e9c72c69f19f3c4f76f5e4915f47c06 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 16:50:46 -0800 Subject: [PATCH 17/60] Keep spelled-out emails, IP addresses, recovery phrases and lower-case codes from the place service MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Place suggestions still sent "john(at)gmail.com", "10.0.0.1", a wallet's recovery phrase, a passphrase run together, "license ABC1234", lower-case codes after a code label ("otp abcdef", "cvv abc") and short phone numbers read as an address ("Jo 12345-6789", "Mo 0171 12345"), and a phone's three and four digits could still be searched as a place on purpose. They now stay in the browser. Real places that only looked private are looked up again: Akiak, Bearer Island, SSN Station, Shibuya 150-0002. A suggested house is named in its country's order ("Hauptstraße 12"), and one without a street keeps its number. Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 42 +++++++--- src/search/placeSuggestions.js | 114 ++++++++++++++++++++++++--- src/search/placeSuggestions.test.mjs | 84 ++++++++++++++++++++ 3 files changed, 218 insertions(+), 22 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 64207f325a..d52899c213 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -8043,44 +8043,64 @@ digits and "@" count, and digits of any script count as digits. It is any line with: an "@" with something right on both sides, ending a word, starting a lowercase handle ("@jdoe"), or spaced before a domain ("john @ gmail.com") (an email address or a handle, also while it is typed; spaced, as in "Nanjampeta @ -Chandambylu", it is part of a name); seven digits or more with nothing but spaces, +Chandambylu", it is part of a name); an email spelled around a filter +("john(at)gmail.com", "john[at]gmail[dot]com", "john at gmail dot de"); an +IP address ("10.0.0.1"); a wallet's recovery phrase (12, 15, 18, 21 or 24 +different lower-case words of three to eight letters); a line that is one +lower-case word of twenty letters or more (a passphrase run together); seven digits or more with nothing but spaces, punctuation, symbols or format characters between them (a phone, card, SSN or account number or its start: "+1 415 555", "4111 1111", "123 45 6789", "123456789", "4111.1111.1111.1111", "123–45–6789"; a street address's house number -and its postcode are read apart: five digits, or between the street and +and its postcode are read apart (a house number never starts with 0, and +a polite word such as "thanks" after the digits is not a city): five digits, or between the street and the city "00-950", "111 21", "125009", "1100-053", or four digits after a -comma ("Straße 120, 1070 Wien"); and so are a US ZIP+4 after a word, -a Brazilian CEP, a Japanese postcode after "〒" or before the address, and +comma ("Straße 120, 1070 Wien"); and so are a US ZIP+4 after a state's +code or name ("Alice 12345-6789" and "Jo 12345-6789" stay private), +a Brazilian CEP, a Japanese postcode after "〒", before the address or +after a place's name ("Shibuya 150-0002"), and digits on either side of "#", so "Hauptstrasse 12 10115 Berlin", "DC 20500-0003", "〒100-0001 東京都千代田区" and "Calle 100 # 19-61" are places, while a seven-digit postcode alone such as "Tel Aviv 6100000" still reads as private); a phone number written with dots; two letters, two digits and ten more letters or digits (an IBAN's shape); "password", -"passcode", "passwd", "ssn", "pw", "pwd" or "bearer" followed by anything, -"token", "secret", "api key", "key" or "pass" followed by ":" or "=", a +"passcode", "passwd", "pw" or "pwd" followed by anything, "bearer" +followed by anything but a capitalised name ("Bearer Island" is a place), +"ssn" followed by a digit ("SSN Station" is a place), "token", "secret", +"api key", "key" or "pass" followed by ":" or "=", a licence, plate, +passport, membership, account, policy, ticket, booking, confirmation or +reference number with letters and digits after its label ("license +ABC1234"), "otp", "2fa", "mfa", "cvv", "cvc" or a verification, one-time, +security, auth or login code followed by a code in any case that is not a +capitalised name ("otp abcdef"; "OTP Bank" is a place), a door, access, gate, alarm, entry or security code followed by a digit, "api key", "access token" or "secret key" followed by a word of six characters or more, the word for "password" in the interface's languages (contraseña, Passwort, mot de passe, пароль…) followed by anything, or "pin" (also "pin code", "pin number", "pin is") followed by a digit; a word starting `sk_`, `sk-`, `rk_`, `pk_live`, `ghp_` or a Slack token's `xoxb-` and the like (any case) or -`AIza`, `eyJ` or `AKIA`; or a word that may be a password or key, with letters and digits mixed +`AIza` or `eyJ`, or an AWS key id (`AKIA` and twelve capitals or digits +more; "Akiak" is a place); or a word that may be a password or key, with letters and digits mixed within one run (a number beside a word, as in "Yanino-1", "2-chōme" or "Route-66", is a name): eight characters or more, six or more with four letters and a digit ("hunter22", "Area51"), or six or more with letters, digits and a symbol ("Tr0ub4dor&3"). The password words match whole words -only ("Sachsenhausen" is a place). Over the bundled names (139,502), five -read as private: two with stray digits ("Maliga0N", "Jerónim67") and three -with number lists or codes. When the text may be private the field says +only ("Sachsenhausen" is a place). Over the bundled names (139,502), six +read as private: two with stray digits ("Maliga0N", "Jerónim67"), two +joined by "@" to a lower-case handle ("Pulipadu @Govardhanagiri") and two +with number lists or dates. When the text may be private the field says so ("Looks private, so nothing is searched or sent"), and a line whose only private sign is an address-sized run of digits (no group over six -digits, nine at most in all, counted as they fold, and no word such as +digits, nine at most in all, counted as they fold, no three digits +followed by four as a phone number writes them, and no word such as card, code, key, phone or account beside them, in English and some other European languages; compounds such as "Kreditkartennummer" and words in other scripts are not read), with words beside it, gets a row to search it as a place on purpose ("Search … as a place anyway"), which runs the ordinary place search and its online services only when picked; a bare number, an email or handle, a password, key, code or IBAN gets none. +A suggested house is named by its number and its street (or, without a +street, its locality) in the order its country writes them: "10 Downing +Street", "Hauptstraße 12". A nine-digit number or a short phone number written with no such word still gets the row: only picking it sends anything. One-time and verification codes, OTP, 2FA, MFA, CVV and CVC values, "card ending" digits, passphrases, diff --git a/src/search/placeSuggestions.js b/src/search/placeSuggestions.js index 6fa20b11b5..d65f21d9de 100644 --- a/src/search/placeSuggestions.js +++ b/src/search/placeSuggestions.js @@ -62,6 +62,7 @@ export function onlyNumbersLookPrivate(text) { // is ("card 4111 …", "phone +1 415 …", "token 12345678"). groups.every((group) => group.length <= 6) && groups.join('').length <= 9 && + !/(?]\s*[\p{L}\p{N}-]/iu.test(line) || + /\b\S+\s+at\s+\S+\s+dot\s+\p{L}{2,6}\b/iu.test(line) + ) + return 'other'; + // An IP address ("10.0.0.1"). + if (/(? /^[a-z]{3,8}$/.test(word)) + ) + return 'other'; + // A passphrase run together ("correcthorsebatterystaple"): a line that + // is one word of twenty letters or more, all lower case. A long place + // name is written with its capital ("Llanfairpwllgwyngyll"), and a long + // word inside a name ("… selskokhozyaystvennoy opytnoy stantsii") has + // others beside it. + if (words.length === 1 && /^[a-z]{20,}$/.test(words[0])) return 'other'; // Coordinates and grid references are a spot, not a number to keep: only // text the place search itself reads as coordinates, as typed ("١٢٣٤, // ٥٦٧٨" folded would read as a spot, but is not one). @@ -146,7 +172,7 @@ function privacyReason(text) { .replace( // After a street word, or before the city ("12, 10115 Berlin"); // "030 12345" alone is a phone number. - /(?<=\p{L}\.?\s)\d{1,4}[a-z]?,?\s+\d{5}(?:-\d{3})?(?=\s+\p{L}|$)|(?<=^|\s)\d{1,4}[a-z]?,?\s+\d{5}(?:-\d{3})?(?=\s+\p{L})/giu, + /(?<=\p{L}\.?\s)[1-9]\d{0,3}[a-z]?,?\s+\d{5}(?:-\d{3})?(?=\s+(?!(?:thanks|thank|thx|please|pls|ok|okay|now|asap|call|text)\b)\p{L}|$)|(?<=^|\s)[1-9]\d{0,3}[a-z]?,?\s+\d{5}(?:-\d{3})?(?=\s+(?!(?:thanks|thank|thx|please|pls|ok|okay|now|asap|call|text)\b)\p{L})/giu, ' ', ) // Other postcodes after a street's house number and before the city (a @@ -164,7 +190,7 @@ function privacyReason(text) { .replace(US_ZIP4, ' x ') .replace(/\b\d{5}-\d{3}\b/g, ' x ') .replace( - /〒\s?\d{3}-\d{4}|\b\d{3}-\d{4}(?=\s*[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])/gu, + /〒\s?\d{3}-\d{4}|\b\d{3}-\d{4}(?=\s*[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])|(?<=\p{L}{3,},?\s)\d{3}-\d{4}(?=\s*$|,)/gu, ' x ', ) .replace(/#/g, ' x ') @@ -176,9 +202,12 @@ function privacyReason(text) { // An IBAN. if (/\b[a-z]{2}\d{2}(?:\s?[a-z0-9]){10,}/i.test(line)) return 'other'; if ( - /\b(?:password|passcode|passwd|ssn|pw|pwd|bearer)\b\s*[:=#]?\s*\S/i.test( - line, - ) || + /\b(?:password|passcode|passwd|pw|pwd)\b\s*[:=#]?\s*\S/i.test(line) || + // "Bearer Island" and "SSN Station" are places: after "bearer" any value + // but a capitalised name is a token, and a social security number has + // digits. + bearerToken(line) || + /\bssn\b\s*[:=#]?\s*\d/i.test(line) || // The word for "password" in the interface's languages. // A whole word only: "Sachsenhausen" holds "senha" but is a place. /(? /^(?:sk[-_]|rk_|pk_live|ghp_|xox[abposr]-)/i.test(token) || - /^(?:AIza|eyJ|AKIA)/.test(token) || + /^(?:AIza|eyJ)/.test(token) || + /^AKIA[0-9A-Z]{12,}$/.test(token) || mayBeSecret(token), ) ) @@ -224,6 +259,12 @@ function privacyReason(text) { return longNumber ? 'number' : null; } +/** A value after "bearer" that is not a capitalised name ("Bearer Island"). */ +function bearerToken(line) { + const match = /\bbearer\b\s*[:=#]?\s*(\S+)/i.exec(line); + return Boolean(match) && !/^\p{Lu}\p{Ll}+$/u.test(match[1]); +} + /** * A code after a label that can only be a code, without a colon ("PIN * A7B2", "verification code ABCDEF", "otp 7GH2K"): holding a digit, or in @@ -231,6 +272,14 @@ function privacyReason(text) { * "GATE CODE LANE", "OTP Bank" and "Auth Code ABCD Street" stay places. */ function codeAfterLabel(line) { + // Labels that only ever name a code take one in lower case too ("otp + // abcdef", "cvv abc", "verification code abcdef"); a capitalised word + // after them is a name ("OTP Bank", "MFA Boston"). + const coded = + /\b(?:otp|2fa|mfa|cvv|cvc|(?:verification|one-time|security|auth|login) code)(?:\s+is)?\s+([a-z0-9][a-z0-9-]{2,})\s*[.!]?\s*$/i.exec( + line, + ); + if (coded && !/^\p{Lu}(?:\p{Ll}+|\p{Lu}+)$/u.test(coded[1])) return true; const match = /\b((?:pin|cvv|cvc|otp|2fa|mfa|(?:door|access|gate|alarm|entry|security|verification|one-time|auth|login) code)(?:\s+is)?)\s+([a-z0-9][a-z0-9-]{3,})\s*[.!]?\s*$/i.exec( line, @@ -292,6 +341,43 @@ export function resetPlaceSuggestions() { shared.pending.clear(); } +/** + * Countries that write a house's number before its street ("10 Downing + * Street", "12 rue de Rivoli"); elsewhere it follows ("Hauptstraße 12"). + */ +const NUMBER_FIRST = new Set([ + 'US', + 'CA', + 'GB', + 'IE', + 'AU', + 'NZ', + 'FR', + 'LU', + 'MC', + 'ZA', + 'IN', + 'PH', + 'SG', + 'MY', + 'HK', + 'TH', + 'LK', + 'NG', + 'GH', + 'KE', + 'JM', + 'TT', +]); + +/** A house's number and street as its country writes them, or ''. */ +export function houseAddress({ houseNumber, street, countryCode }) { + if (!houseNumber || !street) return ''; + return NUMBER_FIRST.has(String(countryCode || 'US').toUpperCase()) + ? `${houseNumber} ${street}` + : `${street} ${houseNumber}`; +} + /** List Photon candidates while typing. The submitted search owns navigation. */ export function createPlaceSuggester({ endpoint, @@ -384,11 +470,17 @@ export function createPlaceSuggester({ type, street, housenumber: houseNumber, + locality, + district, } = feature.properties ?? {}; - // A house has no name of its own: its street and number are its - // name, so two houses on one street stay two places. - const address = - street && houseNumber ? `${houseNumber} ${street}` : ''; + // A house has no name of its own: its street (or, without one, its + // locality) and number are its name, written in the country's own + // order, so two houses on one street stay two places. + const address = houseAddress({ + houseNumber, + street: street || locality || district || city, + countryCode, + }); const name = normalized.name || address || city || state || country; if (!name) continue; const detail = [...new Set([city, state, country])] diff --git a/src/search/placeSuggestions.test.mjs b/src/search/placeSuggestions.test.mjs index 7063008116..c2a958d2fc 100644 --- a/src/search/placeSuggestions.test.mjs +++ b/src/search/placeSuggestions.test.mjs @@ -3,8 +3,10 @@ import test from 'node:test'; import { citiesInRegion, createPlaceSuggester, + houseAddress, inExtent, mayBePrivate, + onlyNumbersLookPrivate, resetPlaceSuggestions, } from './placeSuggestions.js'; @@ -427,3 +429,85 @@ test('the same text asked again while its request is out is sent once', async () await Promise.all([service.suggest('Paris'), service.suggest('Paris')]); assert.equal(sent, 1); }); + +test('spelled-out emails, addresses, phrases, codes and short phone numbers stay private', () => { + for (const line of [ + 'john(at)gmail.com', + 'john[at]gmail[dot]com', + 'john at gmail dot de', + '10.0.0.1', + 'abandon ability able about above absent absorb abstract absurd abuse access accident', + 'correcthorsebatterystaple', + 'license ABC1234', + 'passport X1234567', + 'plate 7ABC123', + 'otp abcdef', + 'verification code abcdef', + 'cvv abc', + 'Bearer abcdef', + 'ssn 123', + 'Jo 12345-6789', + 'Joe 1234 12345 thanks', + 'Mo 0171 12345', + ]) + assert.equal(mayBePrivate(line), true, line); + // A phone's three and four digits are not offered as an address. + assert.equal(onlyNumbersLookPrivate('is 555 0100 thanks'), false); +}); + +test('places that only looked private are looked up', () => { + for (const line of [ + 'Akiak', + 'Bearer Island', + 'SSN Station', + 'Shibuya 150-0002', + 'Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch', + 'OTP Bank', + // A long request is not a recovery phrase. + 'show flights over texas near austin with altitude above thirty thousand feet please', + 'show fires near austin then show flights above texas with labels please', + ]) + assert.equal(mayBePrivate(line), false, line); +}); + +test('a house is named by its number and street in the order its country writes them', async () => { + assert.equal( + houseAddress({ + houseNumber: '10', + street: 'Downing Street', + countryCode: 'gb', + }), + '10 Downing Street', + ); + assert.equal( + houseAddress({ + houseNumber: '12', + street: 'Hauptstraße', + countryCode: 'DE', + }), + 'Hauptstraße 12', + ); + assert.equal(houseAddress({ houseNumber: '12', street: '' }), ''); + // Without a street, a house's number and its locality name it, so two + // houses in one hamlet stay two places, not the city twice. + const house = (number) => ({ + geometry: { type: 'Point', coordinates: [11.2, 47.6] }, + properties: { + housenumber: number, + locality: 'Mittenwald Au', + city: 'Mittenwald', + country: 'Germany', + countrycode: 'de', + osm_value: 'house', + }, + }); + const service = createPlaceSuggester({ + endpoint: 'https://fixture.test/api/', + fetchImpl: async () => + Response.json({ features: [house('3'), house('5')] }), + }); + assert.deepEqual( + (await service.suggest('Mittenwald Au')).map((place) => place.name), + ['Mittenwald Au 3', 'Mittenwald Au 5'], + ); +}); From 35049fd7f7b658dd408e474db5025b0d2d1f14ba Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 16:59:35 -0800 Subject: [PATCH 18/60] Keep more shapes of phones, codes, tokens, emails and IP addresses private Review found "Alice 555-0100" sent as a Japanese postcode, recovery phrases with a repeated word, a capitalised bearer token, codes after a lower-case label in other cases ("verification code Abc", "PIN aBcD"), "john at gmail.com" and "(dot)" forms, passport numbers of digits only, "ID AB123" and IPv6 addresses. They now stay in the browser, and the suggester never sends a line of more than eight words. "Bearer Island, Canada", "bearer island", a ZIP+4 after two spaces and a Japanese postcode after Japanese script are looked up again. Co-authored-by: Manjunath Paparaju --- docs/CURRENT-STATE.md | 34 +++++---- src/search/placeSuggestions.js | 102 +++++++++++++++++++++++---- src/search/placeSuggestions.test.mjs | 52 +++++++++++++- 3 files changed, 161 insertions(+), 27 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index d52899c213..e22add909e 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -8029,7 +8029,8 @@ and errors, keeping the separate Location draft intact. While typing, a short line (six words or fewer, no `?`, not a command, coordinates, a hex code, a callsign such as UAL2110 or N123AB, and nothing that may be private) is sent to -Photon for place suggestions: at most one request every 500 ms per tab, +Photon for place suggestions (the suggester itself never sends a line of +more than eight words): at most one request every 500 ms per tab, and none for a minute after a refusal. Photon is the keyless geocoder the place search already uses; a submitted search is not part of this spacing. A line that may be one name ("Satellite Beach") is looked up whole. While @@ -8044,10 +8045,13 @@ any line with: an "@" with something right on both sides, ending a word, starting a lowercase handle ("@jdoe"), or spaced before a domain ("john @ gmail.com") (an email address or a handle, also while it is typed; spaced, as in "Nanjampeta @ Chandambylu", it is part of a name); an email spelled around a filter -("john(at)gmail.com", "john[at]gmail[dot]com", "john at gmail dot de"); an -IP address ("10.0.0.1"); a wallet's recovery phrase (12, 15, 18, 21 or 24 -different lower-case words of three to eight letters); a line that is one -lower-case word of twenty letters or more (a passphrase run together); seven digits or more with nothing but spaces, +("john(at)gmail.com", "john[at]gmail[dot]com", "john at gmail dot de", +"john at gmail.com", "john at gmail (dot) com"); an IP address +("10.0.0.1", "::1", "fe80::1"); a wallet's recovery phrase (12, 15, 18, 21 +or 24 lower-case words of three to eight letters, not starting as a request +does); a line that is one lower-case word of twenty letters or more (a +passphrase run together; one written with a capital, or spaced into words, +cannot be told from a name and is not caught); seven digits or more with nothing but spaces, punctuation, symbols or format characters between them (a phone, card, SSN or account number or its start: "+1 415 555", "4111 1111", "123 45 6789", "123456789", "4111.1111.1111.1111", "123–45–6789"; a street address's house number @@ -8056,22 +8060,28 @@ a polite word such as "thanks" after the digits is not a city): five digits, or the city "00-950", "111 21", "125009", "1100-053", or four digits after a comma ("Straße 120, 1070 Wien"); and so are a US ZIP+4 after a state's code or name ("Alice 12345-6789" and "Jo 12345-6789" stay private), -a Brazilian CEP, a Japanese postcode after "〒", before the address or -after a place's name ("Shibuya 150-0002"), and +a Brazilian CEP, a Japanese postcode after "〒" or next to the address in +Japanese script ("東京都千代田区100-0001"; after a Latin name, as in +"Shibuya 150-0002", it reads as a phone number), and digits on either side of "#", so "Hauptstrasse 12 10115 Berlin", "DC 20500-0003", "〒100-0001 東京都千代田区" and "Calle 100 # 19-61" are places, while a seven-digit postcode alone such as "Tel Aviv 6100000" still reads as private); a phone number written with dots; two letters, two digits and ten more letters or digits (an IBAN's shape); "password", "passcode", "passwd", "pw" or "pwd" followed by anything, "bearer" -followed by anything but a capitalised name ("Bearer Island" is a place), +followed by anything but a short capitalised name or a place word such as +island or lake ("Bearer Island", "bearer island" are places), "ssn" followed by a digit ("SSN Station" is a place), "token", "secret", "api key", "key" or "pass" followed by ":" or "=", a licence, plate, passport, membership, account, policy, ticket, booking, confirmation or -reference number with letters and digits after its label ("license -ABC1234"), "otp", "2fa", "mfa", "cvv", "cvc" or a verification, one-time, -security, auth or login code followed by a code in any case that is not a -capitalised name ("otp abcdef"; "OTP Bank" is a place), a +reference number with a digit after its label ("license ABC1234", +"passport no. 123456"), "ID" in capitals followed by a number ("ID +AB123"), "otp", "2fa", "mfa", "cvv", "cvc" or a verification, one-time, +security, auth or login code followed by a code (any value after a label +in lower case, "verification code Abc", also before "thanks"; after a label +written as a name, any value that is not one: "OTP Bank" and "Security +Code Plaza" are places), a "pin" or door, access, gate, alarm or entry +code followed by a value in mixed case ("PIN aBcD"), a door, access, gate, alarm, entry or security code followed by a digit, "api key", "access token" or "secret key" followed by a word of six characters or more, the word for "password" in the interface's languages diff --git a/src/search/placeSuggestions.js b/src/search/placeSuggestions.js index d65f21d9de..1cacaa9d7e 100644 --- a/src/search/placeSuggestions.js +++ b/src/search/placeSuggestions.js @@ -67,6 +67,13 @@ export function onlyNumbersLookPrivate(text) { ); } +/** How a typed request starts, unlike a recovery phrase's first word. */ +const REQUEST_START = + /^(?:show|hide|turn|switch|find|search|go|fly|take|zoom|open|close|play|what|where|when|which|who|how|why|list|display|enable|disable|remove|clear|follow|track)\b/; + +/** The most words a line sent for place suggestions may have. */ +const SUGGEST_MAX_WORDS = 8; + /** * Words that say a number is an account, a card, a phone or a secret, in the * interface's languages where they differ ("Karte", "Telefon", "tarjeta"). @@ -85,7 +92,8 @@ function foldLine(text) { .normalize('NFKC') .replace(/\p{Cf}/gu, '') .replace(/[\u2018\u2019]/g, "'") - .replace(/(?![0-9])\p{Nd}/gu, '0'); + .replace(/(?![0-9])\p{Nd}/gu, '0') + .replace(/\s+/g, ' '); } /** A US ZIP+4 after a state's code or name, as an address writes it. */ @@ -122,21 +130,45 @@ function privacyReason(text) { return 'other'; // An email written around a filter: "john(at)gmail.com", // "john[at]gmail[dot]com", "john at gmail dot com". + // Also "john at gmail.com" and a "(dot)" or "[dot]" in any of them. if ( /[\p{L}\p{N}._%+-]\s*[([{<]\s*at\s*[)\]}>]\s*[\p{L}\p{N}-]/iu.test(line) || - /\b\S+\s+at\s+\S+\s+dot\s+\p{L}{2,6}\b/iu.test(line) + /\b\S+\s+at\s+\S+\s+(?:dot|[([{<]\s*dot\s*[)\]}>])\s+\p{L}{2,24}\b/iu.test( + line, + ) || + /\b\S+\s+at\s+[\p{L}\p{N}-]+\s*[([{<]\s*dot\s*[)\]}>]\s*\p{L}{2,24}\b/iu.test( + line, + ) || + /\b[\p{L}\p{N}._%+-]+\s+at\s+[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)*\.(?:com|net|org|edu|gov|mil|io|co|me|info|biz|app|dev|ai|[a-z]{2})\b/iu.test( + line, + ) ) return 'other'; // An IP address ("10.0.0.1"). if (/(? { + const bare = token.replace(/^[[(]+|[\]),.;]+$/g, '').replace(/%\w+$/, ''); + const colons = (bare.match(/:/g) || []).length; + return ( + /^[0-9a-f:.]+$/i.test(bare) && + colons >= 2 && + (bare.includes('::') || colons >= 5) + ); + }) + ) + return 'other'; + // A wallet's recovery phrase: 12, 15, 18, 21 or 24 words, all of three + // to eight letters in lower case ("abandon ability able …"), unless it + // starts as a request does ("show flights over texas …"). A line that + // long is never sent for suggestions anyway (see SUGGEST_MAX_WORDS). const words = line.trim().split(/\s+/); if ( [12, 15, 18, 21, 24].includes(words.length) && - new Set(words).size === words.length && - words.every((word) => /^[a-z]{3,8}$/.test(word)) + words.every((word) => /^[a-z]{3,8}$/.test(word)) && + !REQUEST_START.test(line) ) return 'other'; // A passphrase run together ("correcthorsebatterystaple"): a line that @@ -190,7 +222,7 @@ function privacyReason(text) { .replace(US_ZIP4, ' x ') .replace(/\b\d{5}-\d{3}\b/g, ' x ') .replace( - /〒\s?\d{3}-\d{4}|\b\d{3}-\d{4}(?=\s*[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])|(?<=\p{L}{3,},?\s)\d{3}-\d{4}(?=\s*$|,)/gu, + /〒\s?\d{3}-\d{4}|\b\d{3}-\d{4}(?=\s*[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])|(?<=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]\s*)\d{3}-\d{4}\b/gu, ' x ', ) .replace(/#/g, ' x ') @@ -221,7 +253,12 @@ function privacyReason(text) { /\b(?:token|secret|api[ _-]?key|key|pass)\s*[:=]\s*\S/i.test(line) || // A number on a document or account after its label: "license ABC1234", // "passport X1234567", "plate 7ABC123", "member no. 12345". - /\b(?:licen[cs]e|plate|passport|member(?:ship)?|account|acct|policy|ticket|booking|confirmation|ref(?:erence)?)(?:\s+(?:no\.?|number|#|is))*\s*[:=#]?\s+(?=[a-z0-9-]*\d)(?=[a-z0-9-]*[a-z])[a-z0-9-]{4,}/i.test( + /\b(?:licen[cs]e|plate|passport|member(?:ship)?|account|acct|policy|ticket|booking|confirmation|ref(?:erence)?)(?:\s+(?:no\.?|number|#|is))*\s*[:=#]?\s+(?=[a-z0-9-]*\d)[a-z0-9-]{4,}/i.test( + line, + ) || + // An identity number after "ID" in capitals ("ID AB123"); "Id" and + // "id" are words. + /\bID(?:\s+(?:no\.?|number|#|is))*\s*[:=#]?\s+(?=[A-Za-z0-9-]*\d)[A-Za-z0-9-]{4,}/.test( line, ) || /\b(?:my secret is|passphrase|mnemonic|seed phrase|recovery phrase)\b\s*[:=]?\s*\S/i.test( @@ -261,10 +298,21 @@ function privacyReason(text) { /** A value after "bearer" that is not a capitalised name ("Bearer Island"). */ function bearerToken(line) { - const match = /\bbearer\b\s*[:=#]?\s*(\S+)/i.exec(line); - return Boolean(match) && !/^\p{Lu}\p{Ll}+$/u.test(match[1]); + for (const match of line.matchAll(/\bbearer\b\s*[:=#]?\s*(\S+)/gi)) { + const value = match[1].replace(/[,.;:!?)]+$/, ''); + // A name: capitalised and short ("Bearer Island, Canada"), or a word + // a place's name is made of ("bearer island"). + if (/^\p{Lu}\p{Ll}{1,11}$/u.test(value) || PLACE_WORDS.test(value)) + continue; + return true; + } + return false; } +/** Words a place's name is made of, after a label word ("bearer island"). */ +const PLACE_WORDS = + /^(?:island|islands|isle|lake|creek|river|point|bay|mountain|mount|hill|hills|valley|station|road|street|lane|avenue|park|beach|falls|springs?|county|city|town|village)$/i; + /** * A code after a label that can only be a code, without a colon ("PIN * A7B2", "verification code ABCDEF", "otp 7GH2K"): holding a digit, or in @@ -275,11 +323,30 @@ function codeAfterLabel(line) { // Labels that only ever name a code take one in lower case too ("otp // abcdef", "cvv abc", "verification code abcdef"); a capitalised word // after them is a name ("OTP Bank", "MFA Boston"). + // After a label in lower case, any value is a code ("verification code + // Abc"); after one written as a name, only a value that is not one. const coded = - /\b(?:otp|2fa|mfa|cvv|cvc|(?:verification|one-time|security|auth|login) code)(?:\s+is)?\s+([a-z0-9][a-z0-9-]{2,})\s*[.!]?\s*$/i.exec( + /\b((?:otp|2fa|mfa|cvv|cvc|(?:verification|one-time|security|auth|login) code)(?:\s+is)?)\s+([a-z0-9][a-z0-9-]{2,})(?:\s+(?:thanks|thank you|thx|please|pls|ok))?\s*[.!]?\s*$/i.exec( line, ); - if (coded && !/^\p{Lu}(?:\p{Ll}+|\p{Lu}+)$/u.test(coded[1])) return true; + if (coded) { + const [, label, value] = coded; + const labelIsName = /\p{Lu}/u.test(label); + if (!labelIsName) return true; + if (!/^\p{Lu}(?:\p{Ll}+|\p{Lu}+)$/u.test(value)) return true; + } + // A value in mixed case that is no name ("PIN aBcD", "gate code aBcD"). + const mixed = + /\b(?:pin|(?:door|access|gate|alarm|entry) code)(?:\s+is)?\s+([a-z0-9-]{4,})\s*[.!]?\s*$/i.exec( + line, + ); + if ( + mixed && + /\p{Ll}/u.test(mixed[1]) && + /\p{Lu}/u.test(mixed[1]) && + !/^\p{Lu}\p{Ll}+$/u.test(mixed[1]) + ) + return true; const match = /\b((?:pin|cvv|cvc|otp|2fa|mfa|(?:door|access|gate|alarm|entry|security|verification|one-time|auth|login) code)(?:\s+is)?)\s+([a-z0-9][a-z0-9-]{3,})\s*[.!]?\s*$/i.exec( line, @@ -394,7 +461,14 @@ export function createPlaceSuggester({ const text = String(query ?? '') .trim() .slice(0, MAX_QUERY_CHARS); - if (!enabled || text.length < minPlaceChars(text) || mayBePrivate(text)) + // A line longer than a place's name is never sent: a pasted sentence + // or phrase is no place, and may be private in ways not read here. + if ( + !enabled || + text.length < minPlaceChars(text) || + text.split(/\s+/).length > SUGGEST_MAX_WORDS || + mayBePrivate(text) + ) return []; const language = (globalThis.document?.documentElement?.lang || 'en') .slice(0, 2) diff --git a/src/search/placeSuggestions.test.mjs b/src/search/placeSuggestions.test.mjs index c2a958d2fc..6bd93f558a 100644 --- a/src/search/placeSuggestions.test.mjs +++ b/src/search/placeSuggestions.test.mjs @@ -460,7 +460,13 @@ test('places that only looked private are looked up', () => { 'Akiak', 'Bearer Island', 'SSN Station', - 'Shibuya 150-0002', + 'Bearer Island, Canada', + 'bearer island', + 'Washington DC 20500-0003', + '東京都千代田区100-0001', + 'Security Code Plaza', + 'Idaho Falls', + 'meet at 12:30:45', 'Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch', 'OTP Bank', // A long request is not a recovery phrase. @@ -511,3 +517,47 @@ test('a house is named by its number and street in the order its country writes ['Mittenwald Au 3', 'Mittenwald Au 5'], ); }); + +test('codes, phones, tokens, emails and addresses in further shapes stay private', () => { + for (const line of [ + // A phone's three and four digits after a name, as a postcode can't be + // told from it ("Shibuya 150-0002" is refused for that). + 'Alice 555-0100', + 'Shibuya 150-0002', + `${Array(23).fill('abandon').join(' ')} art`, + 'Bearer Abcdefghijklmnopqrstuvwxyz', + 'Bearer Island bearer abcdef', + 'verification code Abc', + 'verification code ABC', + 'verification code abc thanks', + 'PIN aBcD', + 'gate code aBcD', + 'john at gmail.com', + 'john at gmail (dot) com', + 'john at gmail [dot] com', + 'john at gmail dot technology', + 'passport number 123456', + 'passport no. 123456', + 'ID AB123', + '::1', + 'fe80::1', + '2001:db8:0:0:0:0:2:1', + ]) + assert.equal(mayBePrivate(line), true, line); +}); + +test('a line longer than a place name is never sent for suggestions', async () => { + let sent = 0; + const service = createPlaceSuggester({ + endpoint: 'https://fixture.test/api/', + fetchImpl: async () => { + sent++; + return Response.json({ features: [] }); + }, + }); + assert.deepEqual( + await service.suggest('one two three four five six seven eight nine'), + [], + ); + assert.equal(sent, 0); +}); From e342149a09bb3e6fad195e003704e44704c48f64 Mon Sep 17 00:00:00 2001 From: Manjunath Paparaju Date: Wed, 18 Nov 2026 19:24:52 +0530 Subject: [PATCH 19/60] Turn the first-run launcher into a three-step welcome Replace the single dense welcome card with three short steps: an introduction to the modes, where to start (Space Missions, Environmental or Explore manually, Explore selected by default), then quick tips (the place tip points at the search bar) and links. Next and Back keep the selection, and only Enter God mode runs a mission; double clicks, Enter repeats and clicks during a step change cannot launch one. Skip and ESC close the card for the session, as before. Drop the Live Contacts tile and the old voice tip. Space Missions switches on its layer, which opens its own panel, so no first-run choice enters a Context mode or opens the Context panel any more, and that path is gone. The last step links to the repository and Halfpixel's channels, each opening in a new tab without opener or referrer. Its GEV Stories card closes the welcome and opens the in-app Stories Explore view; the Stories announcement stays hidden, and unseen, until the card has closed and Stories has loaded. The dim layer behind the card is a click-through tint with no blur. Update the 13 catalogs, CURRENT-STATE, the first-run QA harness and its mutations, and the scripts that dismissed the old card. Add a changelog fragment. Co-authored-by: Sameh Khamis --- changelog.d/4-three-step-onboarding.md | 5 + docs/CURRENT-STATE.md | 49 +- scripts/qa-firstrun-mutations.mjs | 41 +- scripts/qa-firstrun.mjs | 136 +- scripts/qa-floor-hold.mjs | 2 +- scripts/qa-street-level.mjs | 3 - src/firstRunCopy.js | 18 +- src/firstRunExperience.js | 74 +- src/firstRunExperience.test.mjs | 262 ++-- src/firstRunLauncherView.test.mjs | 242 +++- src/i18n/locales/ar.json | 41 +- src/i18n/locales/de.json | 41 +- src/i18n/locales/es.json | 41 +- src/i18n/locales/fr.json | 41 +- src/i18n/locales/he.json | 41 +- src/i18n/locales/it.json | 41 +- src/i18n/locales/ja.json | 41 +- src/i18n/locales/pt.json | 41 +- src/i18n/locales/ru.json | 41 +- src/i18n/locales/sv.json | 41 +- src/i18n/locales/uk.json | 41 +- src/i18n/locales/zh-CN.json | 41 +- src/i18n/locales/zh-Hant.json | 41 +- src/ui/stores/firstRun.js | 4 +- src/ui/styles/first-run.css | 1648 ++++++++++++++++++++++-- src/ui/styles/rtl.css | 10 +- src/ui/views/WelcomeView.vue | 295 ++++- 27 files changed, 2807 insertions(+), 515 deletions(-) create mode 100644 changelog.d/4-three-step-onboarding.md diff --git a/changelog.d/4-three-step-onboarding.md b/changelog.d/4-three-step-onboarding.md new file mode 100644 index 0000000000..ecf505719b --- /dev/null +++ b/changelog.d/4-three-step-onboarding.md @@ -0,0 +1,5 @@ +- Replace the first-run launcher with a three-step welcome: an introduction to + the modes, where to start (Space Missions, Environmental or Explore + manually), then quick tips and links. The Live Contacts starting choice is + gone. GEV Stories opens in the app from the last step, and a light tint (no + blur) sits over the globe while the card is up (manjunath22466, #4). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 64207f325a..237a5258db 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -4106,10 +4106,31 @@ which embeds the MAP_KEY. points to restrictions, quota, or connectivity. These hints do not expose keys. > **2026-08-23 — first-run mission launcher** (`src/firstRunExperience.js`, -> `#first-run-launcher`, styles at the tail of `style.css`). After startup -> settles, a fresh session gets one card offering **Live Contacts · Space -> Missions · Environmental · Explore manually**. No layer and no optional API -> call happens until a tile is clicked. The right-hand DISPLAY rail +> `#first-run-launcher`, styles in `src/ui/styles/first-run.css`). After startup +> settles, a fresh session gets three steps: mode introduction, a starting +> mission, then quick tips and links. God mode is available; Analyst is +> marked coming soon. **Space Missions · Environmental · Explore +> manually** are the starting choices, with Explore selected by default; Live +> Contacts is no longer offered as a starting mission (its Context tab is +> unchanged). The footer status line stays empty until a mission reports +> progress or an error; the old voice tip is gone. While the card is up, a +> click-through backdrop tints the globe behind it (`.first-run-backdrop`, a +> 28% dark tint with no blur); it never takes input, so the card stays +> non-modal. The last step links out to the GitHub repository and +> Halfpixel's channels (YouTube, X, Instagram, LinkedIn, bilawal.ai, +> halfpixel.ai); each opens in a new tab with `rel="noopener noreferrer"`, and +> the addresses live in `FIRST_RUN_LINKS` (`src/firstRunCopy.js`). The GEV +> Stories card's BROWSE STORIES button closes the card (a session dismissal, +> like Skip) and opens the in-app Stories Explore view, keeping the Stories +> announcement hidden while Stories loads. Next and Back preserve that selection without starting +> a mission. Only **Enter God mode** runs it; Back is inert while it is loading. +> Step changes focus the main action, announce the new heading separately from +> mission progress, and refresh the scrolling affordance after the transition. Repeated Enter keys, +> double-clicks and activation during a step transition cannot launch a mission. +> No layer and no optional API call happens until the final action is clicked. +> The Stories announcement waits, from startup until onboarding closes, without +> marking it seen. +> The right-hand DISPLAY rail > (`pp-toggles`) now starts **collapsed** on a first run rather than expanded — > a stored collapse state still wins, as before. > @@ -4157,26 +4178,28 @@ which embeds the MAP_KEY. > `localStorage['gev:first-run-mission:v1'] === 'suppressed'`, written **only** > by the "Don't show this again" checkbox → the per-session > `sessionStorage['gev:first-run-mission-session:v1'] === 'dismissed'`, written -> by **every** close path (mission, Explore, ESC, the footer dismiss button). So +> by **every** close path (a mission or Explore from ENTER GOD MODE, ESC, the +> header Skip button, BROWSE STORIES). So > it returns each fresh browser session until the visitor ticks the box; clearing > storage un-ticks it, which is accepted. Both stores fail open — an unreadable > store still shows the launcher rather than silently swallowing first launch. > -> **The footer dismiss button is the keyboardless ESC.** Phones and tablets have -> no ESC key, so the footer hint is a `data-first-run-dismiss` button that calls +> **The header Skip button is the keyboardless ESC.** Phones and tablets have +> no ESC key, so the header action is a `data-first-run-dismiss` button that calls > the same `dismiss()` as ESC. It stays visible at every width (phones used to -> hide it, leaving a mission as the only way out) and reads DISMISS on a -> `(hover: none) and (pointer: coarse)` screen, "ESC to dismiss" otherwise. Its -> 44px touch target is a `::before` outside the layout, so the footer row keeps +> hide it, leaving a mission as the only way out) and reads SKIP on a +> `(hover: none) and (pointer: coarse)` screen, "SKIP · ESC" otherwise. Its +> 44px touch target is a `::before` outside the layout, so the header row keeps > its one-line height. > > **What a mission may persist (do not "simplify" this).** Layer enablement is > durable in this app (`gev:layer-state:v2`, written by > `LayerStateCoordinator._commitExplicit` only for origin `user`/`voice`/`tool`). > A mission enables **its own** layers at `origin: 'user'` — durable, exactly as -> clicking those rows is, because picking the mission _is_ that choice. The two -> Context missions also expand the Context panel, as the visible tabs do; the -> globe missions open no panel. Everything else is off limits: detection +> clicking those rows is, because picking the mission _is_ that choice. Space +> Missions switches on its layer, which opens its own Space Missions panel; no +> mission enters a Context mode or opens the Context panel, and the globe +> missions open no panel. Everything else is off limits: detection > mode/density, `gev:detection-allocation:v1`, 3D models, feather, and above all > `_detectionUserOverridden` — setting that flag means "the operator hand-edited > detection" and would silently disable the CRT/NVG/FLIR auto-preset contract for diff --git a/scripts/qa-firstrun-mutations.mjs b/scripts/qa-firstrun-mutations.mjs index 91e303885a..2c622598fd 100644 --- a/scripts/qa-firstrun-mutations.mjs +++ b/scripts/qa-firstrun-mutations.mjs @@ -276,21 +276,21 @@ const MUTATIONS = [ }, { defect: 'the tile stops promising the fires it actually turns on', - file: 'html', + file: 'module', from: " 'Live earthquakes and active fires, from USGS and NASA',", to: " 'Live earthquakes worldwide, straight from USGS',", }, { - defect: 'the owner-authored first-run line is quietly rewritten', + defect: 'the maintainer-authored first-run line is quietly rewritten', file: 'html', from: 'It feels like a forbidden cockpit—then you realize the sources are public and the data is real.', - to: "It feels like a forbidden cockpit. It isn't — every feed is public, and every contact is live.", + to: 'A live 3D globe of public data. Pick a view to begin.', }, { defect: 'the ledgered global-chip defect loses its pointer to the real fix', file: 'module', - from: ' // means a KEY REQUIRED terminal state in src/loadingFeedback.js, a state', - to: ' // (note removed)', + from: ' // ends KEY REQUIRED (src/loadingFeedback.js), and the quakes half of the', + to: ' // ends KEY REQUIRED, and the quakes half of the', }, { defect: 'the globe missions never pull the camera out', @@ -314,7 +314,7 @@ const MUTATIONS = [ defect: 'Explore manually quietly runs a mission instead of nothing', file: 'module', from: "if (mission.kind === 'none') return { ok: true, choice };", - to: "if (mission.kind === 'none') return { ok: true, choice, ran: await setContextMode('contacts') };", + to: "if (mission.kind === 'none') return { ok: true, choice, ran: await setLayerEnabled('rocket-launches') };", }, { defect: 'an unknown choice is treated as a success', @@ -348,15 +348,14 @@ const MUTATIONS = [ { defect: 'a mission persists a 3D-models choice nobody made', file: 'module', - from: ' const result = await styleManager.setContextMode(mode);', - to: ' styleManager._setModels3dEnabled?.(true);\n const result = await styleManager.setContextMode(mode);', + from: " setLayerEnabled: (layerId) =>\n dataManager.setEnabled(layerId, true, { origin: 'user' }),", + to: " setLayerEnabled: (layerId) => {\n styleManager._setModels3dEnabled?.(true);\n return dataManager.setEnabled(layerId, true, { origin: 'user' });\n },", }, { - defect: - 'the Context panel is left collapsed, hiding the mode that just started', + defect: 'a mission writes panel chrome nobody chose', file: 'module', - from: " styleManager.setPanelCollapsed?.('global-context-panel', false, {\n explicit: true,\n });", - to: ' // panel reveal removed', + from: ' flyToGlobe: () => styleManager.resetToGlobeView(),', + to: " flyToGlobe: () => {\n styleManager.setPanelCollapsed?.('global-context-panel', false, { explicit: true });\n return styleManager.resetToGlobeView();\n },", }, { defect: @@ -371,8 +370,8 @@ const MUTATIONS = [ defect: 'disabling the focused tile drops the keyboard to mid-flight', file: 'html', - from: ':aria-disabled="launcher?.busy ?? undefined" @click="controls?.choose(\'contacts\')"', - to: ':disabled="launcher?.busy === \'true\'" @click="controls?.choose(\'contacts\')"', + from: ':aria-disabled="String(settling || launcher?.busy === \'true\')" @click="onPrimary"', + to: ':disabled="launcher?.busy === \'true\'" @click="onPrimary"', }, { defect: 'Tab escapes into an app the visitor has not seen yet', @@ -421,8 +420,8 @@ const MUTATIONS = [ defect: 'the card loses its viewport cap and clips on a short landscape phone', file: 'css', - from: ' max-height: calc(100dvh - 1.5rem);', - to: ' /* cap removed */', + from: ' body.mobile-shell #first-run-launcher {\n bottom: 5.8rem;\n max-height: calc(100vh - 6.55rem);\n max-height: calc(100dvh - 6.55rem);\n }', + to: ' body.mobile-shell #first-run-launcher {\n bottom: 5.8rem;\n /* cap removed */\n }', }, { defect: @@ -437,7 +436,7 @@ const MUTATIONS = [ // those instead and prove nothing about this feature. defect: "the launcher's reduced-motion opt-out is dropped", file: 'css', - from: ' #first-run-launcher,\n .first-run-choices button,\n .first-run-arrow {\n transition: none;\n }\n /* Scrolling a tile into view must not animate either. */\n .first-run-choices {\n scroll-behavior: auto;\n }', + from: ' #first-run-launcher,\n .first-run-backdrop,\n .first-run-back,\n .first-run-missions button,\n .first-run-link-card,\n .first-run-link-button,\n .first-run-enter {\n transition: none;\n }\n /* Scrolling a tile into view must not animate either. */\n .first-run-choices {\n scroll-behavior: auto;\n }', to: ' .first-run-nothing {\n transition: none;\n }', }, @@ -445,14 +444,14 @@ const MUTATIONS = [ { defect: 'a mission tile is dropped from the menu', file: 'html', - from: '