From a8ac8eeb9b9a0e1e1f009b480327724e521fe273 Mon Sep 17 00:00:00 2001 From: manjunath22466 Date: Mon, 16 Nov 2026 17:55:29 +0530 Subject: [PATCH 01/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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/14] 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 bb3bf9858b213aae2f43beadda56d9cbe098a7e4 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 18:23:41 -0800 Subject: [PATCH 14/14] fix(click): the card or label on top takes the click in every layer Review fixes for #1781: - One rule for cards: the world-overlay host hands its hit test to the pick registry, and every click handler reads the topmost interactive card or label once per click (`clickCard`, `isUnderOtherCard` in src/data/pickRegistry.js), so all handlers agree in any listener order. A layer whose own card or label is on top acts on it whatever is drawn under it; a layer under another layer's card neither acts nor treats the click as empty space (a tracked aircraft stays tracked, a selection stays selected); Context names nothing under a card. A selected news card over a vessel no longer opens the link and selects the vessel. - With one rule, the per-owner arbitration options are no longer read and are removed: `passive`, `expanded` and `declinesClick` pick owners, `rememberClickPickActions`, `isActedOnByOtherLayer`, card backgrounds and `cardKeepsClick`. The dispatcher is unchanged from main. - A drag that ends on a quake disc, label or card does nothing; opening the USGS page or clearing the selection needs a clean click. - A click on the map under another layer's card opens no Street Level ground image. - A CCTV card that is going away is still not the scene under it. - Docs and changelog describe the new rule. --- changelog.d/1781-earthquake-click-details.md | 8 +- docs/CURRENT-STATE.md | 91 +++------ scripts/format-scope.json | 6 +- scripts/package-boundaries.json | 3 +- src/app/layers/earthquakes.js | 3 +- src/app/layers/streetLevel.js | 4 +- src/app/layers/submarineCables.js | 4 +- src/cameraHandoff.test.mjs | 12 +- src/data/aisLiveVessels.test.mjs | 123 ++++++------ src/data/bhoteKoshiEvent.js | 11 +- src/data/bhoteKoshiEvent.test.mjs | 10 +- src/data/bhoteKoshiLocator.js | 30 +-- src/data/bhoteKoshiLocator.test.mjs | 38 ++-- src/data/cctv.test.mjs | 4 +- src/data/directions.test.mjs | 54 ++++-- src/data/firmsInteraction.test.mjs | 91 +++++---- src/data/localGeojsonCore.js | 4 + src/data/localGeojsonDraw.test.mjs | 19 ++ src/data/pickOwnerExpanded.test.mjs | 180 ------------------ src/data/pickRegistry.js | 176 +++++------------ src/data/pickRegistry.test.mjs | 171 +++++------------ src/data/pickedContext.js | 28 +-- src/data/pickedContext.test.mjs | 74 +------ src/data/trailRenderer.js | 8 +- src/input/dispatcher.js | 9 +- src/layers/alpr/presentation.js | 4 + src/layers/alpr/presentation.test.mjs | 57 ++++++ src/layers/bikeshare/selection.js | 4 + src/layers/bikeshare/selection.test.mjs | 68 +++++++ src/layers/cctv/lifecycle.js | 117 ++++-------- src/layers/cctv/lifecycle.test.mjs | 97 ++++------ src/layers/cyclones/index.js | 72 +------ src/layers/cyclones/index.test.mjs | 64 ++----- src/layers/directions/index.js | 6 +- src/layers/droneAirspace/index.js | 22 +-- src/layers/droneAirspace/ownership.test.mjs | 26 +-- src/layers/earthquakes/index.js | 85 +++------ src/layers/earthquakes/selection.test.mjs | 156 +++++++++------ src/layers/firms/selection.js | 56 ++---- src/layers/flights/lifecycle.js | 14 -- src/layers/flights/ownership.test.mjs | 46 +++++ src/layers/flights/tracking.js | 6 +- src/layers/ghostMaps/index.js | 26 +-- src/layers/ghostMaps/lifecycle.test.mjs | 16 +- src/layers/installations/selection.js | 4 + src/layers/installations/selection.test.mjs | 25 +++ src/layers/launches/clickYield.test.mjs | 13 +- src/layers/launches/lifecycle.js | 22 +-- src/layers/localAdsb/index.js | 3 + src/layers/localAdsb/index.test.mjs | 41 +++- src/layers/military/lifecycle.js | 14 -- src/layers/military/ownership.test.mjs | 46 +++++ src/layers/military/tracking.js | 6 +- src/layers/news/index.js | 17 +- src/layers/news/layer.test.mjs | 28 ++- src/layers/perimeters/index.js | 29 ++- src/layers/perimeters/ownership.test.mjs | 26 +-- src/layers/radio/interaction.js | 27 +-- src/layers/radio/interaction.test.mjs | 73 +++---- src/layers/rail/follow.test.mjs | 20 ++ src/layers/rail/selection.js | 4 + src/layers/satellites/interaction.js | 6 +- src/layers/satellites/interaction.test.mjs | 65 +++++++ src/layers/shipwrecks/index.js | 23 +-- src/layers/shipwrecks/index.test.mjs | 8 +- src/layers/streetLevel/selection.js | 30 +-- src/layers/streetLevel/selection.test.mjs | 99 ++++++---- src/layers/submarineCables/index.js | 1 - src/layers/submarineCables/interaction.js | 32 +--- .../submarineCables/interaction.test.mjs | 32 +--- src/layers/transit/lifecycle.test.mjs | 25 +++ src/layers/transit/selection.js | 4 + src/layers/vessels/lifecycle.js | 6 +- src/layers/vessels/selection.js | 94 +++------ .../wildlifeSightings/ownership.test.mjs | 2 + src/layers/wildlifeSightings/selection.js | 15 +- .../wildlifeSightings/selection.test.mjs | 36 ++-- src/overlays/worldOverlay.js | 4 + src/scenes/interactions.js | 4 + src/scenes/interactionsView.test.mjs | 38 ++++ src/ui/applicationShell.js | 1 - src/ui/cockpitOrbitalFocus.js | 8 +- src/ui/cockpitOrbitalFocus.test.mjs | 18 ++ src/ui/entityContextBridge.js | 26 +-- src/ui/entityContextBridge.test.mjs | 92 ++++----- src/ui/wildlifeSightingCard.test.mjs | 2 + src/voice/analystAccessors.test.mjs | 1 - 87 files changed, 1398 insertions(+), 1775 deletions(-) delete mode 100644 src/data/pickOwnerExpanded.test.mjs create mode 100644 src/layers/alpr/presentation.test.mjs create mode 100644 src/layers/bikeshare/selection.test.mjs create mode 100644 src/layers/satellites/interaction.test.mjs diff --git a/changelog.d/1781-earthquake-click-details.md b/changelog.d/1781-earthquake-click-details.md index 8dc909f6d0..595083a3f1 100644 --- a/changelog.d/1781-earthquake-click-details.md +++ b/changelog.d/1781-earthquake-click-details.md @@ -1,7 +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 + the selected disc shows a fading gradient and bounded contour animation. A + drag ending on a quake does nothing. The card or label painted on top now + takes a click in every layer: what is drawn under it neither acts nor loses + its selection, and the Context panel names nothing there (Manjunath, @manjunath22466, #1781). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 57f59afdaa..1179ff36b6 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2061,75 +2061,32 @@ 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, -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; 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, 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. 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 -or camera reached only as a nearby contact. The card takes that click. +A press that travels past the tracking click limit is a drag, not a pick: the +quake handler ignores it, and opening the source or clearing the selection +also needs a short press (`src/data/trackingClickGesture.js`). 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. 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`). -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, 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, -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. +space, so their near-miss taps and deselection work over a quake as before, +and a disc yields to another layer's registered pick (an aircraft) under it. +The card or label painted on top takes the click. The world-overlay host hands +its hit test to the pick registry (`setClickCardHitTest`), and every click +handler reads the topmost interactive card or label at the click through +`clickCard(click)`, once per click, so all of them agree in any listener order +(`src/data/pickRegistry.js`). A layer whose own card or label is on top acts +on it, whatever is drawn under it: an aircraft, a vessel, a fire, a camera, a +trail, a route. A layer under another layer's card or label +(`isUnderOtherCard`) does nothing: it neither acts on its item there nor +treats the click as empty space, so a tracked aircraft stays tracked and a +selection stays selected. Context (`src/ui/entityContextBridge.js`) names +nothing under a card. With no card on top, the scene rules are unchanged. +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`). A click on the map under another layer's +card opens no Street Level ground image. The Bhote Koshi trigger-record +callout (`src/data/bhoteKoshiLocator.js`) opens its source on a click, as its +keyboard action does, and ignores a drag; its evidence cards act only when +they are the card on top. 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 993e64a297..31a3d35c5e 100644 --- a/scripts/format-scope.json +++ b/scripts/format-scope.json @@ -439,7 +439,6 @@ "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", @@ -1588,5 +1587,8 @@ "src/ui/layerFinder.test.mjs", "src/data/wikidataCities.js", "src/data/wikidataCities.test.mjs", - "scripts/build-wikidata-cities.mjs" + "scripts/build-wikidata-cities.mjs", + "src/layers/bikeshare/selection.test.mjs", + "src/layers/satellites/interaction.test.mjs", + "src/layers/alpr/presentation.test.mjs" ] diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index bc2440f299..cec3ad4fa6 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -2544,7 +2544,8 @@ "src/layers/earthquakes/model.js", "src/layers/earthquakes/source.js", "src/layers/earthquakes/records.js", - "src/time/worldClock.js" + "src/time/worldClock.js", + "src/data/trackingClickGesture.js" ], "external": ["cesium"] }, diff --git a/src/app/layers/earthquakes.js b/src/app/layers/earthquakes.js index 1862f4736e..87b79743d4 100644 --- a/src/app/layers/earthquakes.js +++ b/src/app/layers/earthquakes.js @@ -1,6 +1,5 @@ import { createEarthquakesLayer } from '../../layers/earthquakes/index.js'; import { overlayHost } from './overlayHost.js'; -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'; @@ -33,7 +32,7 @@ export const earthquakeCardText = Object.freeze({ */ export function createApplicationEarthquakes(options) { return createEarthquakesLayer({ - overlayHost: { ...overlayHost, hitTest: hitTestWorldOverlay }, + overlayHost, input: (viewer) => inputFor(viewer), picking, context, diff --git a/src/app/layers/streetLevel.js b/src/app/layers/streetLevel.js index 964d495300..3b7c7cc0b9 100644 --- a/src/app/layers/streetLevel.js +++ b/src/app/layers/streetLevel.js @@ -6,7 +6,6 @@ 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; @@ -36,7 +35,6 @@ export function createApplicationStreetLevel({ }) { return createStreetLevelLayer({ providers, - // Hit-testing lets a card painted over a near miss keep its click. - services: { picking, scenePick, render, overlayHit: hitTestWorldOverlay }, + services: { picking, scenePick, render }, }); } diff --git a/src/app/layers/submarineCables.js b/src/app/layers/submarineCables.js index 5b19b8cf10..7b9299fc3c 100644 --- a/src/app/layers/submarineCables.js +++ b/src/app/layers/submarineCables.js @@ -1,12 +1,10 @@ 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({ - // Hit-testing lets a card painted over a cable keep its click. - overlayHost: { ...overlayHost, hitTest: hitTestWorldOverlay }, + overlayHost, picking, mapStackEventTarget: typeof window !== 'undefined' ? window : null, ...options, diff --git a/src/cameraHandoff.test.mjs b/src/cameraHandoff.test.mjs index 747a2f0a97..36b3380afa 100644 --- a/src/cameraHandoff.test.mjs +++ b/src/cameraHandoff.test.mjs @@ -403,10 +403,11 @@ test('vessel and fire layers announce valid clicks and never fly cameras', () => 'vessel click', ); ordered(vesselClick, [ + 'clickCard?.(event)', + 'selectAndFocusVessel(carded)', "isOwnedByOtherLayer('ais-live-vessels', pickedId)", - '_vesselOverlayHost.hitTest?.(', 'selectAndFocusVessel(record)', - ], 'vessel sibling ownership'); + ], 'vessel card on top, then sibling ownership'); const vesselFocus = body( vessels, /function selectAndFocusVessel\(record\) \{([\s\S]*?)\n \}/, @@ -419,8 +420,9 @@ test('vessel and fire layers announce valid clicks and never fly cameras', () => 'fire click', ); ordered(fireClick, [ - 'isOwnedByOtherLayer(id, pickedId)', - 'overlayHost.hitTest?.(', + 'clickCard?.(event)', 'selectAndFocusFire(carded)', - ], 'fire sibling ownership'); + 'isOwnedByOtherLayer(id, pickedId)', + 'clearFireSelection()', + ], 'fire card on top, then sibling ownership'); }); diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs index fc2c09a3f9..f2a604d359 100644 --- a/src/data/aisLiveVessels.test.mjs +++ b/src/data/aisLiveVessels.test.mjs @@ -32,7 +32,12 @@ import aisLiveVesselsLayer from './aisLiveVessels.js'; import { registerEntityContext, selectEntityContext } from './contextStore.js'; import { WORLD_FOCUS_REQUEST_EVENT } from '../worldFocus.js'; import { ensureGeoidReady, geoidHeight } from './geoid.js'; -import { registerPickOwner, unregisterPickOwner } from './pickRegistry.js'; +import { + isUnderOtherCard, + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from './pickRegistry.js'; import { applyVesselOverlayPolicy } from './vesselLabels.js'; import { fakeInput } from '../input/testDoubles.mjs'; import { layerFeedState } from './manager.js'; @@ -490,7 +495,7 @@ test('first accepted position ends grace and warm data survives later open silen const clock = makeFakeAisRuntime(7000); const record = makeRecord(); _setAisRuntimeForTest(clock.runtime); - _setVesselOverlayHostForTest({ + useVesselHost({ setEntries() {}, setVisible() {}, clearSource() {}, @@ -540,7 +545,7 @@ test('first accepted position ends grace and warm data survives later open silen assert.equal(feed.error, 'awaiting usable AIS positions…'); } finally { _setVesselStateForTest({ enabled: false }); - _setVesselOverlayHostForTest(); + useVesselHost(); _setAisRuntimeForTest(); } }); @@ -1643,7 +1648,7 @@ test('vessel host publication preserves the shipped grid winner and separation s }, }, }); - _setVesselOverlayHostForTest({ + useVesselHost({ setEntries(sourceId, entries, options) { publications.push({ sourceId, entries, options }); }, @@ -1667,7 +1672,7 @@ test('vessel host publication preserves the shipped grid winner and separation s } finally { unbind(); _setVesselStateForTest({ enabled: false }); - _setVesselOverlayHostForTest(); + useVesselHost(); } }); @@ -1694,7 +1699,7 @@ test('vessel real layer lifecycle publishes protected selection and leaves no st globalThis.window.addEventListener('gev:world-request-focus', (event) => { focusRequests.push(event.detail); }); - _setVesselOverlayHostForTest(host); + useVesselHost(host); _setVesselStateForTest({ viewer: { get canvas() { @@ -1743,7 +1748,7 @@ test('vessel real layer lifecycle publishes protected selection and leaves no st ); } finally { _setVesselStateForTest({ enabled: false }); - _setVesselOverlayHostForTest(); + useVesselHost(); if (hadWindow) globalThis.window = priorWindow; else delete globalThis.window; globalThis.document = priorDocument; @@ -1849,6 +1854,15 @@ test('vessel interaction wire: a vessel with an id and no MMSI is selected by cl } }); +/** + * Hand the vessel layer an overlay host, and answer the pick registry's + * card-on-top question from the same host, as the application does. + */ +function useVesselHost(host) { + _setVesselOverlayHostForTest(host); + setClickCardHitTest(host ? (x, y) => host.hitTest(x, y) : null); +} + /** * Overlay-host recorder whose hitTest answers with one card id. The real host * only publishes rects for `interactive` entries, so a stub returning a hit is @@ -1880,9 +1894,7 @@ test('vessel interaction wire: clicking a card selects and transfers, like the s harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -1893,7 +1905,7 @@ test('vessel interaction wire: clicking a card selects and transfers, like the s assert.equal(requests[0].kind, 'vessel'); assert.equal(requests[0].id, harness.record.mmsi); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); @@ -1908,9 +1920,7 @@ test('vessel interaction wire: clicking the selected vessel card refocuses exact harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -1921,29 +1931,31 @@ test('vessel interaction wire: clicking the selected vessel card refocuses exact assert.equal(requests[0].id, harness.record.mmsi); assert.equal(harness.trail.clearCalls, 0); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); -test('vessel interaction wire: a covered card yields while a real vessel pick still focuses', () => { +// Another layer's card on top takes the click from the vessel card under it +// and from a vessel icon under it alike. +test('vessel interaction wire: a covered card and a covered vessel pick both yield', () => { 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( + useVesselHost( 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(requests.length, 0, `own pick: ${ownPick}`); assert.equal(aisLiveVesselsLayer.getSelectedInfo()?.mmsi, harness.record.mmsi); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } } @@ -1960,7 +1972,7 @@ test('vessel interaction wire: an unknown card id preserves selection and never requests.push(event.detail), ); // An evicted vessel's card id resolves to no live record. - _setVesselOverlayHostForTest(hostWithCardHit('vessel:999999999')); + useVesselHost(hostWithCardHit('vessel:999999999')); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -1969,52 +1981,47 @@ test('vessel interaction wire: an unknown card id preserves selection and never ); assert.equal(requests.length, 0); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); -test('vessel interaction wire: a sibling-owned pick wins without selection mutation', () => { - // Another layer is already acting on this click; two camera commands is the - // worse failure, so the card is not consulted. +test('vessel interaction wire: the vessel card on top wins over a sibling-owned pick', () => { + // The card painted on top takes the click; the sibling (an aircraft) + // stands aside under it, so there is one camera command, not two. registerPickOwner('flights', (pickedId) => pickedId === 'a1b2c3'); const harness = installWireHarness({ id: 'a1b2c3' }); const requests = []; harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( aisLiveVesselsLayer.getSelectedInfo()?.mmsi, harness.record.mmsi, ); - assert.equal(requests.length, 0); + assert.equal(requests.length, 1); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); unregisterPickOwner('flights'); } }); -// 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) => { +// The aircraft layer runs first. Under the vessel's card it stands aside, so +// the card takes the click: one action. +test('vessel interaction wire: a card over an aircraft takes the click; the aircraft does not track', (t) => { let tracked = null; - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', { - expanded: true, - passive: (pickedId) => pickedId === tracked, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9'); t.after(() => unregisterPickOwner('test-planes')); const harness = installWireHarness( { id: 'plane:9' }, { selectedRecord: null }, {}, (event) => { + if (isUnderOtherCard(event)) return; if (event.hit?.id === 'plane:9') tracked = 'plane:9'; }, ); @@ -2022,16 +2029,17 @@ test('vessel interaction wire: a card yields to an aircraft that starts tracking harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(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); + assert.equal(tracked, null, 'the aircraft does not track'); + assert.equal(requests.length, 1, 'the vessel card acts'); + assert.equal( + aisLiveVesselsLayer.getSelectedInfo()?.mmsi, + harness.record.mmsi, + ); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); @@ -2048,7 +2056,7 @@ test('vessel interaction wire: a card over a trail selects; a bare trail is a no harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( + useVesselHost( hostWithCardHit(carded ? `vessel:${harness.record.mmsi}` : null), ); try { @@ -2059,16 +2067,15 @@ test('vessel interaction wire: a card over a trail selects; a bare trail is a no carded ? harness.record.mmsi : null, ); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(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) => { +// A coarse tap on the vessel's card over a fire, nearby or exact: the card on +// top keeps the tap. +test('vessel interaction wire: the card keeps a tap over a nearby or exact fire', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -2088,18 +2095,16 @@ test('vessel interaction wire: a coarse near miss of an exact-only item keeps th harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(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(requests.length, 1, `exact fire: ${exact}`); assert.equal( - aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, - exact ? null : harness.record.mmsi, + aisLiveVesselsLayer.getSelectedInfo()?.mmsi, + harness.record.mmsi, ); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } } @@ -2130,7 +2135,7 @@ for (const card of ['live', 'stale', 'absent', 'covered']) { ); return { sourceId: 'cctv', entryId: 'vessel:999999999' }; }; - _setVesselOverlayHostForTest(host); + useVesselHost(host); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -2139,7 +2144,7 @@ for (const card of ['live', 'stale', 'absent', 'covered']) { ); assert.equal(requests.length, card === 'live' ? 1 : 0); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); unregisterPickOwner('weather-cyclones'); } diff --git a/src/data/bhoteKoshiEvent.js b/src/data/bhoteKoshiEvent.js index b47dca8e2b..a2da738282 100644 --- a/src/data/bhoteKoshiEvent.js +++ b/src/data/bhoteKoshiEvent.js @@ -2959,11 +2959,12 @@ export function createBhoteKoshiEventLayer({ : Number.isFinite(clientY) && bounds ? clientY - bounds.top : Number.NaN; - const hit = overlayHost.hitTest?.(x, y, { - sourceId: BHOTE_KOSHI_OVERLAY_SOURCE_ID, - filter: (entry) => String(entry?.id || '').startsWith('evidence-card-'), - }); - if (typeof hit?.entry?.activate !== 'function') return; + // Only the card painted on top acts: an evidence card covered by + // another layer's card or label leaves the click to that card. + const hit = overlayHost.hitTest?.(x, y); + if (hit?.sourceId !== BHOTE_KOSHI_OVERLAY_SOURCE_ID) return; + if (!String(hit.entry?.id || '').startsWith('evidence-card-')) return; + if (typeof hit.entry.activate !== 'function') return; hit.entry.activate(); } diff --git a/src/data/bhoteKoshiEvent.test.mjs b/src/data/bhoteKoshiEvent.test.mjs index 5eb4b78634..d40bd9933f 100644 --- a/src/data/bhoteKoshiEvent.test.mjs +++ b/src/data/bhoteKoshiEvent.test.mjs @@ -2114,6 +2114,7 @@ test('Debris-Dammed Lake card opens its source and is armed for approved local v }; const viewer = eventViewer(); let activeCard = null; + let coveredBy = null; const layer = createBhoteKoshiEventLayer({ eventLoader: async () => event, imagerySpecFactory: async (url) => ({ url }), @@ -2131,9 +2132,11 @@ test('Debris-Dammed Lake card opens its source and is armed for approved local v }, setVisible() {}, clearSource() {}, + // As the host does: unfiltered, the topmost entry. hitTest(_x, _y, options) { + if (coveredBy && !options?.sourceId) return coveredBy; if (!activeCard || options?.filter?.(activeCard) === false) return null; - return { entry: activeCard }; + return { sourceId: 'bhote-koshi-witnesses', entry: activeCard }; }, }, renderHost: { request() {}, hold() {}, release() {} }, @@ -2160,6 +2163,11 @@ test('Debris-Dammed Lake card opens its source and is armed for approved local v } finally { releasePointer(lease); } + // Another layer's card painted over the evidence card takes the click. + coveredBy = { sourceId: 'earthquake-card', entryId: 'earthquake-card:q' }; + viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 }); + assert.equal(opened.length, 0, 'a covered evidence card does not open'); + coveredBy = null; viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 }); assert.deepEqual(opened, [[ event.evidenceSpine[1].media.sourceUrl, diff --git a/src/data/bhoteKoshiLocator.js b/src/data/bhoteKoshiLocator.js index 20598df4b7..d9aacfad4d 100644 --- a/src/data/bhoteKoshiLocator.js +++ b/src/data/bhoteKoshiLocator.js @@ -1,10 +1,9 @@ import { clearOverlaySource, - hitTestWorldOverlay, setOverlayEntries, } from '../overlays/worldOverlay.js'; import { inputFor } from '../input/dispatcher.js'; -import { isActedOnByOtherLayer, resolvePickId } from './pickRegistry.js'; +import { clickCard } from './pickRegistry.js'; import { isTrackingSelectionGesture } from './trackingClickGesture.js'; import { governorRequestRender } from '../renderGovernor.js'; import { drawOf, findCamera } from '../render/rendererOf.js'; @@ -284,7 +283,6 @@ export function createBhoteKoshiLocatorLayer({ 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. @@ -1153,9 +1151,8 @@ 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. + * does. Like the other cards, it leaves a drag alone and, on top, takes the + * click over whatever is drawn under it. */ function installCalloutClick(viewer) { if (_removeClick) return; @@ -1168,26 +1165,9 @@ export function createBhoteKoshiLocatorLayer({ _removeClick = clicks?.onClick?.((event) => { if (!_enabled || !isTrackingSelectionGesture(event.gesture)) return; - const top = hitTest?.(event.screenPosition?.x, event.screenPosition?.y); + // The card painted on top, read once per click so every layer agrees. + const top = clickCard(event); 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; } diff --git a/src/data/bhoteKoshiLocator.test.mjs b/src/data/bhoteKoshiLocator.test.mjs index 5c421ec6cb..523e669cd1 100644 --- a/src/data/bhoteKoshiLocator.test.mjs +++ b/src/data/bhoteKoshiLocator.test.mjs @@ -11,7 +11,11 @@ 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 { + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from './pickRegistry.js'; import { SceneDirector } from '../scenes/director.js'; import { createPlaybackClock } from '../director/clock.js'; import { createDefaultScenePacks } from '../scenes/packs/defaults.js'; @@ -1071,8 +1075,9 @@ test('a click on the locator callout runs its action', async () => { }; }, }), - hitTest: () => top, }); + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest(() => top); await layer.init(viewer); await layer.enable(viewer); const click = (extra = {}) => @@ -1103,34 +1108,19 @@ test('a click on the locator callout runs its action', async () => { }; 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, - }); + // On top, it takes the click over an aircraft or a camera under it, exact + // or a touch contact: those layers stand aside under a card. + registerPickOwner('test-planes', (id) => id === 'plane:1'); try { const plane = { set: 'planes:1', id: 'plane:1' }; + const cam = { set: 'cams:1', id: 'cam:1' }; click({ topHit: plane, hit: plane }); click({ topHit: null, hit: plane }); - assert.deepEqual(activated, ['trigger'], 'the aircraft takes it'); + click({ topHit: cam, hit: cam }); + assert.equal(activated.length, 4, 'the callout on top acts each time'); } 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'); + setClickCardHitTest(null); } await layer.disable(); assert.equal(onClick, null, 'disable removes the click handler'); diff --git a/src/data/cctv.test.mjs b/src/data/cctv.test.mjs index 4fb15c6903..fadac2e1d0 100644 --- a/src/data/cctv.test.mjs +++ b/src/data/cctv.test.mjs @@ -1020,7 +1020,7 @@ test('CCTV repeated in-world clicks dispatch focus only for the one real activat ); assert.match( componentFunctionSource(cctvLayer.init), - /_cctvOverlayHost\.hitTest/, + /clickCard\?\.\(event\)/, ); assert.match( componentFunctionSource(cctvLayer.init), @@ -1028,7 +1028,7 @@ test('CCTV repeated in-world clicks dispatch focus only for the one real activat ); assert.match( componentFunctionSource(cctvLayer.init), - /activateCctvCameraFromWorldClick\(cardId, setActiveCamera\)/, + /activateCctvCameraFromWorldClick\(\s*top\.entryId,/, ); }); diff --git a/src/data/directions.test.mjs b/src/data/directions.test.mjs index 6657c0a27e..1f004e1734 100644 --- a/src/data/directions.test.mjs +++ b/src/data/directions.test.mjs @@ -28,7 +28,7 @@ import { createApplicationDirectionsLayer, } from './directions.js'; import { GROUND_FLOOR_LIFT_M } from './groundFloor.js'; -import { isActedOnByOtherLayer, isOwnedByOtherLayer } from './pickRegistry.js'; +import { isOwnedByOtherLayer, setClickCardHitTest } from './pickRegistry.js'; import { fakeInput } from '../input/testDoubles.mjs'; import { instructionFor } from './routeSteps.js'; import { setLocale } from '../i18n/index.js'; @@ -467,10 +467,9 @@ 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) => { +// Directions owns its route, markers and steps while enabled: none of them +// is empty space to other layers. +test('enabled, directions owns its picks', (t) => { ownershipFixture(t); const viewer = { scene: { @@ -488,24 +487,45 @@ test('enabled, directions owns its picks and acts only on its steps', (t) => { '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); }); +// The card or label painted on top takes the click: directions does not even +// pick under another layer's card, so no step is selected or cleared there. +test("another layer's card over directions keeps the click", (t) => { + ownershipFixture(t); + let picks = 0; + const viewer = { + scene: { + pick: () => { + picks++; + return null; + }, + canvas: { clientWidth: 100, clientHeight: 100 }, + }, + }; + const input = fakeInput(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => { + setClickCardHitTest(null); + input.destroy(); + }); + directionsLayer.enable(viewer); + try { + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); + } finally { + directionsLayer.disable(viewer); + } +}); + test('placing an endpoint takes the pointer, and every exit path gives it back', (t) => { ownershipFixture(t); diff --git a/src/data/firmsInteraction.test.mjs b/src/data/firmsInteraction.test.mjs index 026be0a877..a04b172a23 100644 --- a/src/data/firmsInteraction.test.mjs +++ b/src/data/firmsInteraction.test.mjs @@ -11,7 +11,12 @@ import { buildCellCard, } from './firmsHeatmap.js'; import { fireDetectionKey } from './firmsLabels.js'; -import { registerPickOwner, unregisterPickOwner } from './pickRegistry.js'; +import { + isUnderOtherCard, + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from './pickRegistry.js'; import { getSelectedEntityContext } from './contextStore.js'; import { setLocale } from '../i18n/index.js'; import { shownEntityLabel } from '../voice/speech.js'; @@ -80,21 +85,24 @@ function harness({ }; const published = []; + const overlayHost = { + setEntries: (sourceId, entries) => published.push(...entries), + setVisible() {}, + clearSource() {}, + hitTest: (_x, _y, { sourceId } = {}) => + !sourceId && topCard + ? topCard + : cardHit + ? { sourceId: 'firms', entryId: cardHit } + : null, + }; + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest((x, y) => overlayHost.hitTest(x, y)); const layer = createFirmsHeatmapLayer({ ...(feed ? { feed } : {}), id: 'firms-test', name: 'Fires', - overlayHost: { - setEntries: (sourceId, entries) => published.push(...entries), - setVisible() {}, - clearSource() {}, - hitTest: (_x, _y, { sourceId } = {}) => - !sourceId && topCard - ? topCard - : cardHit - ? { sourceId: 'firms', entryId: cardHit } - : null, - }, + overlayHost, }); const draw = fakeDrawPort(); @@ -171,6 +179,7 @@ function harness({ picked = next; }, cleanup() { + setClickCardHitTest(null); Cesium.SceneTransforms.worldToWindowCoordinates = priorProjection; if (hadWindow) globalThis.window = priorWindow; else delete globalThis.window; @@ -331,6 +340,10 @@ test('clicking a fire sprite selects it and requests the camera transfer', () => topCard: { sourceId: 'earthquakes', entryId: 'quake:cover' }, }); try { + // Under another layer's card the sprite is that card's click. + h.click(); + assert.equal(h.requests.length, 0, 'covered: the card takes it'); + h.cover(null); h.click(); assert.equal(h.requests.length, 1); assert.equal(h.requests[0].kind, 'fire'); @@ -435,9 +448,9 @@ test('a click on neither sprite nor card clears without moving the camera', () = } }); -// Sibling layers surface heterogeneous pick shapes. Reading `picked.id` -// directly recognized only bare strings, so an AIS sprite (or satellite, or -// entity) under a fire card let BOTH layers issue a camera command. +// Sibling layers surface heterogeneous pick shapes. Whatever is drawn under +// it, the fire card painted on top takes the click (those layers stand aside +// under another layer's card, so one click does one thing). const SIBLING_PICKS = [ ['flights', 'a1b2c3', { id: 'a1b2c3' }], ['flights', 'a1b2c3', { primitive: { id: 'a1b2c3' } }], @@ -447,7 +460,7 @@ const SIBLING_PICKS = [ ]; for (const [layerId, ownedId, picked] of SIBLING_PICKS) { - test(`a ${layerId} pick shaped ${JSON.stringify(picked)} wins over a card hit`, () => { + test(`a fire card wins over a ${layerId} pick shaped ${JSON.stringify(picked)}`, () => { const fire = makeFire(); registerPickOwner(layerId, (pickedId) => pickedId === ownedId); const h = harness({ @@ -457,11 +470,7 @@ for (const [layerId, ownedId, picked] of SIBLING_PICKS) { }); try { h.click(); - assert.equal( - h.requests.length, - 0, - `the ${layerId} layer is already acting on this click`, - ); + assert.equal(h.requests.length, 1, 'the card on top acts'); } finally { h.cleanup(); unregisterPickOwner(layerId); @@ -474,9 +483,7 @@ for (const [layerId, ownedId, picked] of SIBLING_PICKS) { // 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, - }); + registerPickOwner('test-route', (pickedId) => pickedId === 'route:line'); const carded = harness({ fires: [fire], picked: { id: 'route:line' }, @@ -505,9 +512,8 @@ test('a fire card acts over a passive pick; the bare pick leaves the selection', }); // 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) => { +// touch contact. The card on top takes it; the aircraft layer stands aside. +test('a fire card takes a tap over a touch contact its layer acts on', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -515,9 +521,7 @@ test('a fire card yields to a touch contact its layer acts on', (t) => { else delete globalThis.matchMedia; }); const fire = makeFire(); - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1', { - expanded: true, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1'); t.after(() => unregisterPickOwner('test-planes')); const h = harness({ fires: [fire], @@ -526,8 +530,8 @@ test('a fire card yields to a touch contact its layer acts on', (t) => { }); try { h.click(); - assert.equal(h.requests.length, 0, 'the aircraft takes the tap'); - assert.equal(h.layer.getSelectedInfo(), null); + assert.equal(h.requests.length, 1, 'the card takes the tap'); + assert.ok(h.layer.getSelectedInfo()); } finally { h.cleanup(); } @@ -544,9 +548,7 @@ test('a fire card keeps a tap whose contact does not act; bare taps still clear' }); const fire = makeFire(); registerPickOwner('test-cameras', (pickedId) => pickedId === 'cam:1'); - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1', { - expanded: true, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1'); t.after(() => { unregisterPickOwner('test-cameras'); unregisterPickOwner('test-planes'); @@ -579,30 +581,27 @@ 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) => { +// The aircraft layer runs first. Under the fire card painted over its plane +// it stands aside, so the card takes the click: one action, in either order. +test('a fire card over an aircraft takes the click; the aircraft does not track', (t) => { const fire = makeFire(); let tracked = null; - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', { - expanded: true, - passive: (pickedId) => pickedId === tracked, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9'); t.after(() => unregisterPickOwner('test-planes')); const h = harness({ fires: [fire], picked: { id: 'plane:9' }, cardHit: `fire:${fireDetectionKey(fire)}`, firstClick: (event) => { + if (isUnderOtherCard(event)) return; 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); + assert.equal(tracked, null, 'the aircraft does not track'); + assert.equal(h.requests.length, 1, 'the fire card acts'); + assert.ok(h.layer.getSelectedInfo()); } finally { h.cleanup(); } diff --git a/src/data/localGeojsonCore.js b/src/data/localGeojsonCore.js index 88566bc6e5..da6028ed2a 100644 --- a/src/data/localGeojsonCore.js +++ b/src/data/localGeojsonCore.js @@ -22,6 +22,7 @@ import { import { createInfrastructureOverlayEntry } from './infrastructureOverlayEntry.js'; import { createGeojsonPins } from './geojsonPins.js'; import { inputFor as defaultInputFor } from '../input/dispatcher.js'; +import { isUnderOtherCard } from './pickRegistry.js'; import { selectInfraLod, applyInfraEvictionGrace, @@ -1114,6 +1115,9 @@ export function createLocalGeoJsonLayer( const input = inputFor(viewer); _clickSubscription = input.onClick((event) => { if (!_enabled || !_drawn) return; + // Another layer's card or label on top takes the click: the + // item under it neither acts nor reads as empty space. + if (isUnderOtherCard(event)) return; const hit = event.drawHit; if (!hit || !hit.set.startsWith(`${setPrefix}:`)) return; const part = _drawn.parts.get(hit.id); diff --git a/src/data/localGeojsonDraw.test.mjs b/src/data/localGeojsonDraw.test.mjs index bbb993f042..255fb5d522 100644 --- a/src/data/localGeojsonDraw.test.mjs +++ b/src/data/localGeojsonDraw.test.mjs @@ -6,6 +6,7 @@ import { } from './localGeojsonCore.js'; import { localGeoJsonServices } from '../app/localGeojsonServices.js'; import { getContextStore } from './contextStore.js'; +import { setClickCardHitTest } from './pickRegistry.js'; import { readEntityRecord } from './entityRecords.js'; import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs'; const feature = (id, geometry, properties = { name: `Feature ${id}` }) => ({ @@ -161,6 +162,24 @@ test('polygons fill the ground, lines drape, points stand on pins, all shown', a assert.equal(record?.label, 'Feature p'); }); +// The card or label painted on top takes the click: a feature under another +// layer's card is not selected. +test("another layer's card over a drawn part keeps the click", async (t) => { + const env = await enabledLayer(t, [ + feature('p', { type: 'Polygon', coordinates: square(0, 0) }), + ]); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const fills = env.fake.set('fills'); + const at = { x: 5, y: 5 }; + env.click({ screenPosition: at, drawHit: { set: fills.spec.id, id: 'p' } }); + assert.equal(env.fake.flights.length, 0, 'covered: not selected'); + top = null; + env.click({ screenPosition: at, drawHit: { set: fills.spec.id, id: 'p' } }); + assert.equal(env.fake.flights.length, 1); +}); + test('a click on a drawn part selects its feature and flies above it', async (t) => { const env = await enabledLayer(t, [ feature('p', { type: 'Polygon', coordinates: square(0, 0) }), diff --git a/src/data/pickOwnerExpanded.test.mjs b/src/data/pickOwnerExpanded.test.mjs deleted file mode 100644 index ea013e7ef6..0000000000 --- a/src/data/pickOwnerExpanded.test.mjs +++ /dev/null @@ -1,180 +0,0 @@ -/** - * 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, { cockpit = () => false } = {}) { - const previous = globalThis.document; - globalThis.document = { - body: { - classList: { contains: (name) => name === 'cockpit-mode' && cockpit() }, - }, - 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) => { - let cockpit = false; - withDocument(t, { cockpit: () => cockpit }); - 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); - // 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); - }); -} - -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 815aac0536..f11f6e8553 100644 --- a/src/data/pickRegistry.js +++ b/src/data/pickRegistry.js @@ -26,29 +26,6 @@ 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(); -/** 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(); -/** - * 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' @@ -70,30 +47,11 @@ 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, 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, declinesClick } = {}, -) { +export function registerPickOwner(layerId, predicate) { 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') - _passive.set(layerId, passive); - else _passive.delete(layerId); } /** @@ -103,9 +61,6 @@ export function registerPickOwner( */ export function unregisterPickOwner(layerId) { _owners.delete(layerId); - _expanded.delete(layerId); - _declines.delete(layerId); - _passive.delete(layerId); } /** @@ -144,67 +99,6 @@ export function isOwnedByOtherLayer(layerId, pickedId) { return false; } -/** - * @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; - 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, click)]); - } -} - -/** - * 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, 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, click } = {}, -) { - if (!pickedId) return false; - const owners = - clickActions.get(click)?.get(pickedId) ?? actingPickOwners(pickedId, click); - for (const [ownerId, selectsNearby] of owners) { - if (ownerId !== layerId && (!expanded || selectsNearby)) return true; - } - 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 @@ -253,41 +147,57 @@ export function pickContact(query, position, options = {}) { } /** - * 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. + * The world overlay's hit test: the topmost interactive card or label painted + * at CSS-pixel coordinates, or null. Set by the overlay host while it runs. + * @type {((x: number, y: number) => {sourceId: string, entryId: string}|null)|null} + */ +let _overlayHitTest = null; +/** @type {WeakMap} */ +const clickCards = new WeakMap(); + +/** + * Sets (or with null, clears) the hit test that names the card or label + * painted at a click. The world-overlay host sets it while it runs. + * @param {((x: number, y: number) => object|null)|null} hitTest * @returns {void} */ -export function registerCardBackground(layerId, predicate) { - if (!layerId || typeof predicate !== 'function') return; - _cardBackgrounds.set(layerId, predicate); +export function setClickCardHitTest(hitTest) { + _overlayHitTest = typeof hitTest === 'function' ? hitTest : null; } /** - * Removes a layer's card-background predicate (call when its clicks stop). - * @param {string} layerId - Registering layer id. - * @returns {void} + * The topmost interactive card or label painted at a click, read once per + * click so every handler of it sees the same one whatever ran first. + * @param {{screenPosition?: {x: number, y: number}}|null|undefined} click + * @returns {{sourceId: string, entryId: string}|null} */ -export function unregisterCardBackground(layerId) { - _cardBackgrounds.delete(layerId); +export function clickCard(click) { + if (!click || typeof click !== 'object') return null; + if (clickCards.has(click)) return clickCards.get(click); + const at = click.screenPosition; + let card = null; + try { + card = _overlayHitTest?.(at?.x, at?.y) ?? null; + } catch { + // a broken hit test must never break click handling + } + clickCards.set(click, card); + return card; } /** - * 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 + * True when another layer's card or label is painted on top at a click. The + * card on top takes the click: a scene item under it does not act, and is + * not empty space either, so the layer leaves its selection alone. + * @param {object} click The shared dispatcher event. + * @param {Iterable} [ownSourceIds] The asking layer's overlay + * sources: its own card on top is its click. * @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; +export function isUnderOtherCard(click, ownSourceIds = []) { + const card = clickCard(click); + if (!card) return false; + for (const sourceId of ownSourceIds) + if (card.sourceId === sourceId) return false; + return true; } diff --git a/src/data/pickRegistry.test.mjs b/src/data/pickRegistry.test.mjs index 1a27752646..eb3347fe8c 100644 --- a/src/data/pickRegistry.test.mjs +++ b/src/data/pickRegistry.test.mjs @@ -15,13 +15,11 @@ import { registerPickOwner, unregisterPickOwner, isOwnedByOtherLayer, - isActedOnByOtherLayer, resolvePickId, pickContact, - findPickOwner, - registerCardBackground, - unregisterCardBackground, - isCardBackground, + clickCard, + isUnderOtherCard, + setClickCardHitTest, } from './pickRegistry.js'; // --------------------------------------------------------------------------- @@ -54,11 +52,8 @@ 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); @@ -66,15 +61,9 @@ 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 @@ -87,9 +76,7 @@ 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); @@ -137,83 +124,6 @@ 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('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, - '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); @@ -234,14 +144,10 @@ 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]]); }); @@ -274,13 +180,7 @@ 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) => { @@ -301,22 +201,39 @@ 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'); +test("the card on top is read once per click, and only another layer's card counts", () => { + let top = { sourceId: 'quake-card', entryId: 'q1' }; + let reads = 0; + setClickCardHitTest((x, y) => { + reads++; + assert.deepEqual([x, y], [4, 5]); + return top; }); 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'); + const click = { screenPosition: { x: 4, y: 5 } }; + assert.equal(isUnderOtherCard(click, ['vessel-card']), true); + assert.equal(isUnderOtherCard(click, ['quake-card']), false, 'own card'); + // A card published later in the same click does not change it. + top = { sourceId: 'vessel-card', entryId: 'v1' }; + assert.equal(clickCard(click).sourceId, 'quake-card'); + assert.equal(reads, 1); + assert.equal(isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), true); + top = null; + assert.equal(isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), false); } finally { - unregisterCardBackground('test-zones'); - unregisterCardBackground('test-broken'); + setClickCardHitTest(null); + } + assert.equal( + isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), + false, + 'no host', + ); + setClickCardHitTest(() => { + throw new Error('broken'); + }); + try { + assert.equal(clickCard({ screenPosition: { x: 1, y: 1 } }), null); + } finally { + setClickCardHitTest(null); } - assert.equal(isCardBackground(shape), false); }); diff --git a/src/data/pickedContext.js b/src/data/pickedContext.js index 803075244a..8957c5a24b 100644 --- a/src/data/pickedContext.js +++ b/src/data/pickedContext.js @@ -1,10 +1,6 @@ import { getContextStore, isContextRecordActive } from './contextStore.js'; import { readEntityRecord } from './entityRecords.js'; -import { - findPickOwner, - isActedOnByOtherLayer, - resolvePickId, -} from './pickRegistry.js'; +import { findPickOwner, resolvePickId } from './pickRegistry.js'; /** * Resolve a pick (the contract's `Hit`, as `pickAt` in @@ -127,25 +123,3 @@ 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, click }); -} diff --git a/src/data/pickedContext.test.mjs b/src/data/pickedContext.test.mjs index 6d147bfeaa..4b452e0cab 100644 --- a/src/data/pickedContext.test.mjs +++ b/src/data/pickedContext.test.mjs @@ -11,8 +11,8 @@ globalThis.CustomEvent ||= class CustomEvent { globalThis.dispatchEvent ||= () => true; const { registerEntityContext } = await import('./contextStore.js'); -const { registerPickOwner, unregisterPickOwner, findPickOwner, rememberClickPickActions } = await import('./pickRegistry.js'); -const { resolvePickedContext, pickedKindForLayer, cardKeepsClick } = await import('./pickedContext.js'); +const { registerPickOwner, unregisterPickOwner, findPickOwner } = await import('./pickRegistry.js'); +const { resolvePickedContext, pickedKindForLayer } = await import('./pickedContext.js'); function manager({ enabled = new Set(['flights', 'local-datacenters']), modules = {} } = {}) { return { @@ -97,73 +97,3 @@ 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); -}); - -// 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/data/trailRenderer.js b/src/data/trailRenderer.js index 1c8f6dc598..06c8581318 100644 --- a/src/data/trailRenderer.js +++ b/src/data/trailRenderer.js @@ -36,12 +36,8 @@ 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. -// 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 }, +registerPickOwner('trails', (pickedId) => + String(pickedId).startsWith('gev-trail:'), ); /** @type {number} Uniquifier for trail set and line ids. */ diff --git a/src/input/dispatcher.js b/src/input/dispatcher.js index 6387a7a1c2..7d4ea04606 100644 --- a/src/input/dispatcher.js +++ b/src/input/dispatcher.js @@ -51,7 +51,6 @@ import { import { findPickOwner, pickContact, - rememberClickPickActions, resolvePickId, } from '../data/pickRegistry.js'; import { isPickedWorldPosition } from '../data/scenePick.js'; @@ -457,9 +456,7 @@ 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; - const top = topHitOf(hit, () => native()?.foreign() ?? null); - rememberClickPickActions(this, top); - return top; + return topHitOf(hit, () => native()?.foreign() ?? null); }); }, get drawHit() { @@ -470,7 +467,7 @@ function createClickEvent(viewer, queryOf, at, gesture) { return once('hit', () => { const q = query(); if (!q) return this.topHit; - const hit = pickContact(q, position, { + return 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 @@ -483,8 +480,6 @@ function createClickEvent(viewer, queryOf, at, gesture) { : this.drill(limit, width, height); }, }); - rememberClickPickActions(this, hit); - return hit; }); }, get id() { diff --git a/src/layers/alpr/presentation.js b/src/layers/alpr/presentation.js index 72aa334c5c..4df9f28305 100644 --- a/src/layers/alpr/presentation.js +++ b/src/layers/alpr/presentation.js @@ -1,5 +1,6 @@ import { isFollowing } from '../../data/followed.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { distance, fromDegrees, toLonLatH } from '../../geo/index.js'; import { LAYER_ID, @@ -581,6 +582,9 @@ export function createAlprPresentation({ state, services, source }) { if (state.clickSubscription) return; state.clickSubscription = inputFor(viewer).onClick((event) => { if (!state.enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; // The painted overlay answers first; the scene is picked only if not. const hit = event.drawHit; const id = diff --git a/src/layers/alpr/presentation.test.mjs b/src/layers/alpr/presentation.test.mjs new file mode 100644 index 0000000000..1232de5665 --- /dev/null +++ b/src/layers/alpr/presentation.test.mjs @@ -0,0 +1,57 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createAlprPresentation } from './presentation.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; + +// The card or label painted on top takes the click: ALPR does not even pick +// under another layer's card, so no camera is selected or released there. +test("another layer's card over an ALPR camera keeps the click", (t) => { + let picks = 0; + const viewer = { + scene: { + canvas: new EventTarget(), + pick: () => { + picks++; + return null; + }, + }, + }; + const input = fakeInput(viewer); + const noop = () => {}; + const state = { + enabled: true, + viewer, + clickSubscription: null, + markers: { icons: null }, + recordById: new Map(), + selectedId: null, + }; + const presentation = createAlprPresentation({ + state, + services: { + render: { governorRequestRender: noop }, + context: { + clearSelectedEntityContextForLayer: noop, + getSelectedEntityContext: () => null, + registerEntityContext: noop, + removeEntityContextsForLayer: noop, + selectEntityContext: noop, + }, + groundFloor: { cachedGroundFloor: () => null }, + }, + }); + presentation.installInteraction(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => { + setClickCardHitTest(null); + state.clickSubscription?.(); + input.destroy(); + }); + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); +}); diff --git a/src/layers/bikeshare/selection.js b/src/layers/bikeshare/selection.js index bbf962d8d3..caa3620717 100644 --- a/src/layers/bikeshare/selection.js +++ b/src/layers/bikeshare/selection.js @@ -1,5 +1,6 @@ import { t } from '../../i18n/index.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { BIKESHARE_SELECTED_OVERLAY_SOURCE_ID, BIKESHARE_SELECTED_OVERLAY_SOURCE_OPTIONS, @@ -143,6 +144,9 @@ export function createSelection({ if (layerState._clickSubscription) return; layerState._clickSubscription = inputFor(viewer).onClick((event) => { + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; const hit = event.drawHit; if (hit) { diff --git a/src/layers/bikeshare/selection.test.mjs b/src/layers/bikeshare/selection.test.mjs new file mode 100644 index 0000000000..e75dc93050 --- /dev/null +++ b/src/layers/bikeshare/selection.test.mjs @@ -0,0 +1,68 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createSelection } from './selection.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; + +/** A station layer's selection on a viewer whose pick is scripted. */ +function harness(t) { + const previousDocument = globalThis.document; + globalThis.document = new EventTarget(); + let picked = null; + const viewer = { scene: { canvas: new EventTarget(), pick: () => picked } }; + const input = fakeInput(viewer); + const noop = () => {}; + const state = { + _selectedKey: null, + _clickSubscription: null, + _stationRenderMap: new Map([['nyc:1', { position: { x: 1, y: 0, z: 0 } }]]), + _stationSet: { id: 'bikeshare:stations', upsert: noop }, + _selectedSet: { + id: 'bikeshare:selected', + set: noop, + size: () => 0, + clear: noop, + }, + _overlayHost: { setEntries: noop, clearSource: noop }, + }; + const selection = createSelection({ + state, + services: {}, + parts: { rendering: { stationItem: () => ({}) } }, + }); + selection._installClickHandler(viewer); + t.after(() => { + state._clickSubscription?.(); + input.destroy(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + return { + state, + click(hit) { + picked = hit ? { id: hit } : null; + input.tap({ x: 10, y: 10 }); + }, + }; +} + +// The card or label painted on top takes the click: a station under another +// layer's card is neither selected nor let go. +test("another layer's card over a station keeps the click", (t) => { + const h = harness(t); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const station = { set: 'bikeshare:stations', id: 'nyc:1' }; + h.click(station); + assert.equal(h.state._selectedKey, null, 'covered: not selected'); + top = null; + h.click(station); + assert.equal(h.state._selectedKey, 'nyc:1'); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + h.click(null); + assert.equal(h.state._selectedKey, 'nyc:1', 'covered: kept'); + top = null; + h.click(null); + assert.equal(h.state._selectedKey, null, 'open map lets it go'); +}); diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index cd704d2617..e49b8a85bb 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -5,7 +5,6 @@ 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, @@ -24,14 +23,8 @@ export function createLifecycle({ source, }) { const { activateCctvCameraFromWorldClick } = services.activation; - const { - resolvePickId, - registerPickOwner, - unregisterPickOwner, - isOwnedByOtherLayer, - isActedOnByOtherLayer, - isCardBackground, - } = services.picking; + const { resolvePickId, registerPickOwner, unregisterPickOwner, clickCard } = + services.picking; const { onFocusTargetAppear } = services.focus; const { releaseContinuousRender } = services.render; @@ -398,6 +391,20 @@ export function createLifecycle({ (event) => { if (!layerState._enabled) return; const picked = event.topHit; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: a live card of ours acts whatever + // is drawn under it; another layer's is that layer's click. + const top = clickCard?.(event) ?? null; + if (top && top.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; + if (top) { + // A card of ours that is going away is still not the scene. + if (layerState._recordById.has(top.entryId)) + activateCctvCameraFromWorldClick( + top.entryId, + parts.selection.setActiveCamera, + ); + return; + } const cameraId = parts.selection.extractPickedCameraId( event.drawHit ?? null, ); @@ -408,60 +415,11 @@ export function createLifecycle({ ); return; } - // 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, - {}, - ); - 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)); - // 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, { 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 - // click, even under a card of ours. - const contactId = resolvePickId(event.hit ?? null); - if ( - cardId && - contactId && - contactId !== pickedId && - isActedOnByOtherLayer?.('cctv', contactId, { - expanded: true, - click: event, - }) - ) - return; - if (cardHit && cardHit.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; - if (cardId) { - activateCctvCameraFromWorldClick( - cardId, - parts.selection.setActiveCamera, - ); - 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 the CCTV selection while ID-less globe, terrain + // and tile surfaces remain eligible for empty-space deselection. + if (resolvePickId(picked) !== null) return; if ( parts.selection.cctvEmptyClickDeselects(picked, { activeCameraId: layerState._activeCameraId, @@ -510,26 +468,19 @@ 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])); - }, - // 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) }, - ); + 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])); + }); 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 2ff86b0fff..a95c0b9ecd 100644 --- a/src/layers/cctv/lifecycle.test.mjs +++ b/src/layers/cctv/lifecycle.test.mjs @@ -77,7 +77,7 @@ test('the view listeners follow the camera port and let go on teardown', () => { assert.equal(state._viewListenerCamera, null); }); -test('world clicks respect the painted top card and registered card backgrounds', async (t) => { +test('the card painted on top takes world clicks, whatever is drawn under it', async (t) => { const noop = () => {}; const { viewer } = viewerWithCamera(); let picked = null; @@ -88,10 +88,11 @@ 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. + // An aircraft layer that runs before ours and tracks the plane it was + // clicked on, standing aside under another layer's card. let tracked = null; input.input.onClick((event) => { + if (picking.isUnderOtherCard(event)) return; if (event.hit?.id === 'plane:9') tracked = 'plane:9'; }); const ownCard = { sourceId: CCTV_OVERLAY_SOURCE_ID, entryId: 'cam-1' }; @@ -101,6 +102,8 @@ test('world clicks respect the painted top card and registered card backgrounds' }; let painted = []; const actions = []; + // The card on top at a click, as the host answers the pick registry. + picking.setClickCardHitTest(() => painted[0] ?? null); const state = { _cctvOverlayHost: { hitTest: (_x, _y, options = {}) => @@ -148,12 +151,12 @@ test('world clicks respect the painted top card and registered card backgrounds' state._clickSubscription?.(); lifecycle.detachViewListeners(); input.destroy(); + picking.setClickCardHitTest(null); picking.unregisterPickOwner('area-control'); 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); state._enabled = true; @@ -184,36 +187,32 @@ test('world clicks respect the painted top card and registered card backgrounds' 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], []); } + // The live top card acts over anything drawn under it; with no card an + // identified object is not empty map. 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], []); - // 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. + ]) { + click(hit, [ownCard], ['cam-1']); + click(hit, [], []); + } + // A trail under the live top card: the card keeps the click, and with no + // card the owned 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, - }); + picking.registerPickOwner('test-trails', (id) => id === trail.id); 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. + // nearby contacts) under a live CCTV card is the card's. const previousMatch = globalThis.matchMedia; const restoreMatch = () => { if (previousMatch) globalThis.matchMedia = previousMatch; @@ -223,11 +222,9 @@ test('world clicks respect the painted top card and registered card backgrounds' // 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, - }); + picking.registerPickOwner('test-planes', (id) => id === 'plane:1'); drilled = ['plane:1']; - click(null, [ownCard], []); + click(null, [ownCard], ['cam-1']); // 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. @@ -239,49 +236,29 @@ test('world clicks respect the painted top card and registered card backgrounds' click(null, [ownCard], ['cam-1']); picking.unregisterPickOwner('test-planes'); 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', { - 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'); + // The live card over an aircraft takes the click; the aircraft layer, + // run first, stands aside and does not track. + picking.registerPickOwner('test-tracking', (id) => id === 'plane:9'); + click( + { set: 'flights:1', id: 'plane:9', surface: false }, + [ownCard], + ['cam-1'], + ); + assert.equal(tracked, null, 'the aircraft did not track'); picking.unregisterPickOwner('test-tracking'); picking.registerPickOwner('area-control', (id) => id === drone.id); - click(drone, [ownCard], []); + click(drone, [ownCard], ['cam-1']); 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'], - ); - // 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'); + // A card of ours that is going away is still not the scene under it: no + // camera beneath it activates, and nothing clears. + const staleCard = { ...ownCard, entryId: 'stale-camera' }; + click({ set: 'cctv:fixture', id: 'cam-1' }, [staleCard], []); + click(null, [staleCard], []); + // A camera icon under another layer's card is that card's click. + click({ set: 'cctv:fixture', id: 'cam-1' }, [foreignCard, ownCard], []); + click({ set: 'cctv:fixture', id: 'cam-1' }, [], ['cam-1']); }); diff --git a/src/layers/cyclones/index.js b/src/layers/cyclones/index.js index 02c3b5cad3..1d81f94274 100644 --- a/src/layers/cyclones/index.js +++ b/src/layers/cyclones/index.js @@ -1,7 +1,6 @@ -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; -import { VESSEL_OVERLAY_SOURCE_ID } from '../../data/vesselLabels.js'; import { inputFor } from '../../input/dispatcher.js'; import { + clickCard, registerPickOwner, unregisterPickOwner, } from '../../data/pickRegistry.js'; @@ -79,7 +78,6 @@ const intensityText = (storm) => { /** Advisory status and coherent forecast geometry; selected through the shared row list. */ export function createCyclonesLayer({ feed, - hitTestOverlay = hitTestWorldOverlay, overlayHost, context = null, createRendering = createCycloneRendering, @@ -97,8 +95,7 @@ export function createCyclonesLayer({ selectionIntent = 'auto', navigationGeneration = 0, selectionOwner = null, - selectedContextStormId = null, - removeClickCapture = null; + selectedContextStormId = null; let enabled = false, loading = false, error = null, @@ -169,75 +166,28 @@ export function createCyclonesLayer({ rendering?.setSelection(id); } function installSelection() { - const canvas = canvasOf(viewer); - if (selectionOwner || !canvas) return; + if (selectionOwner || !canvasOf(viewer)) return; const owner = {}; selectionOwner = owner; - // Snapshot before sibling bubble listeners can rebuild the overlay hit - // rectangles. A vessel selection does that synchronously in the same click. - let capturedHit = null; - const overlayHit = (x, y) => { - const hit = hitTestOverlay(x, y); - return { sourceId: hit?.sourceId, entryId: hit?.entryId }; - }; - const capture = (event) => { - capturedHit = null; - const point = event.changedTouches?.[0] || event; - if (!Number.isFinite(point.clientX) || !Number.isFinite(point.clientY)) - return; - const rect = canvas.getBoundingClientRect(); - const x = point.clientX - rect.left, - y = point.clientY - rect.top; - capturedHit = { x, y, ...overlayHit(x, y) }; - }; - const resetCapture = () => { - capturedHit = null; - }; - const resetEvents = [ - 'pointerdown', - 'mousedown', - 'touchstart', - 'pointercancel', - 'touchcancel', - ]; - for (const type of resetEvents) - canvas.addEventListener?.(type, resetCapture, { capture: true }); - const events = ['pointerup', 'mouseup', 'touchend']; - for (const type of events) - canvas.addEventListener?.(type, capture, { capture: true }); - removeClickCapture = () => { - for (const type of events) - canvas.removeEventListener?.(type, capture, { capture: true }); - for (const type of resetEvents) - canvas.removeEventListener?.(type, resetCapture, { capture: true }); - capturedHit = null; - }; const unsubscribe = inputFor(viewer).onClick((event) => { - const nativeHit = capturedHit; - capturedHit = null; // Ambient selection yields to draw tools and Director (the dispatcher // skips a held pointer); it never claims the pointer, camera, or // tracking state. const position = event.screenPosition; if (!enabled || destroyed || selectionOwner !== owner || !position) return; - // AIS cards paint above the globe on a pointer-events:none canvas. The - // vessel handler resolves this same topmost hit before cyclone geometry. - const captureMatches = - nativeHit && - Math.abs(nativeHit.x - position.x) < 1 && - Math.abs(nativeHit.y - position.y) < 1; - const hit = captureMatches - ? nativeHit - : overlayHit(position.x, position.y); - if (hit.sourceId === VESSEL_OVERLAY_SOURCE_ID) return; + // The card or label painted on top, as it was when the click landed. + const card = clickCard(event); // Storm cards and lead-hour labels paint on the same canvas; a click on // one selects its storm. An id from a superseded advisory changes nothing. - if (hit.sourceId === CYCLONE_OVERLAY_SOURCE_ID) { - const id = cycloneStormIdFromEntryId(hit.entryId); + if (card?.sourceId === CYCLONE_OVERLAY_SOURCE_ID) { + const id = cycloneStormIdFromEntryId(card.entryId); if (id) layer.setParams({ stormId: id }); return; } + // Another layer's card on top takes the click: the storm under it does + // not act, and the click is not empty map either. + if (card) return; // A storm's own drawing names it; empty map (the globe, or 3D tiles) // clears the selection. const id = rendering?.pickStorm(event.drawHit); @@ -249,8 +199,6 @@ export function createCyclonesLayer({ function removeSelection() { const owner = selectionOwner; selectionOwner = null; - removeClickCapture?.(); - removeClickCapture = null; owner?.unsubscribe?.(); } const layer = { diff --git a/src/layers/cyclones/index.test.mjs b/src/layers/cyclones/index.test.mjs index a053531dc8..c6b64a6e1e 100644 --- a/src/layers/cyclones/index.test.mjs +++ b/src/layers/cyclones/index.test.mjs @@ -6,7 +6,10 @@ import { releasePointer, isPointerFree, } from '../../data/inputOwnership.js'; -import { isOwnedByOtherLayer } from '../../data/pickRegistry.js'; +import { + isOwnedByOtherLayer, + setClickCardHitTest, +} from '../../data/pickRegistry.js'; import { fakeInput } from '../../input/testDoubles.mjs'; import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs'; @@ -77,7 +80,7 @@ const deferred = () => { return { promise, resolve }; }; -test('map selection yields to pointer owners and owns only its enabled handler', async () => { +test('map selection yields to pointer owners and owns only its enabled handler', async (t) => { const handlers = [], // A pick of an item in one of the layer's draw sets, and one of another // layer's set: the dispatcher hands each to pickStorm as a draw hit. @@ -109,11 +112,12 @@ test('map selection yields to pointer owners and owns only its enabled handler', const layer = createCyclonesLayer({ feed: { getSnapshot: async () => snapshot([storm(), storm('ep162026')]) }, createRendering: () => rendering, - hitTestOverlay: () => { - overlayTests++; - return overlayHit; - }, }); + setClickCardHitTest(() => { + overlayTests++; + return overlayHit; + }); + t.after(() => setClickCardHitTest(null)); const canvas = new EventTarget(); canvas.getBoundingClientRect = () => ({ left: 100, top: 200 }); const viewer = { @@ -180,41 +184,15 @@ test('map selection yields to pointer owners and owns only its enabled handler', 'foreground AIS card wins before scene picking', ); assert.equal(layer.getDiagnostics().selectedId, 'ep152026'); - // A native capture runs before an earlier sibling handler clears hit rects. - const up = new Event('pointerup'); - Object.assign(up, { clientX: 110, clientY: 220 }); - canvas.dispatchEvent(up); - overlayHit = null; + // Any other layer's card on top takes the click, not only a vessel's. + overlayHit = { sourceId: 'cctv', entryId: 'camera:1' }; handlers[0].click(click); assert.equal( layer.getDiagnostics().selectedId, 'ep152026', - 'captured AIS hit survives synchronous sibling overlay rebuild', + 'a camera card over the storm keeps the click', ); - // A captured background hit remains background even if a sibling adds a card. - canvas.dispatchEvent(up); - overlayHit = { sourceId: 'ais-live-vessels', entryId: 'vessel:123' }; - handlers[0].click(click); - assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); - layer.setParams({ stormId: 'ep152026' }); - // A new gesture clears an unconsumed release snapshot. - canvas.dispatchEvent(up); - canvas.dispatchEvent(new Event('pointerdown')); overlayHit = null; - handlers[0].click(click); - assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); - layer.setParams({ stormId: 'ep152026' }); - overlayHit = { sourceId: 'ais-live-vessels', entryId: 'vessel:123' }; - canvas.dispatchEvent(up); - overlayHit = null; - handlers[0].click({ position: { x: 15, y: 25 } }); - assert.equal( - layer.getDiagnostics().selectedId, - 'ep162026', - 'a different click cannot reuse the captured card', - ); - layer.setParams({ stormId: 'ep152026' }); - overlayHit = { sourceId: 'cctv', entryId: 'camera:1' }; const before = notices; handlers[0].click(click); assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); @@ -264,13 +242,12 @@ test('map selection yields to pointer owners and owns only its enabled handler', assert.equal(layer.getDiagnostics().selectionActive, false); const afterDisable = picks; const afterDisableOverlay = overlayTests; - canvas.dispatchEvent(up); + handlers[0].click(click); assert.equal( overlayTests, afterDisableOverlay, - 'disable removes native capture listeners', + 'a disabled layer reads no card', ); - handlers[0].click(click); assert.equal(picks, afterDisable, 'queued disabled callback is inert'); layer.enable(); await layer.update(); @@ -289,7 +266,7 @@ test('map selection yields to pointer owners and owns only its enabled handler', ); assert.equal(handlers[1].destroyed, true); }); -test('a click on a storm card or lead-hour label selects that storm without picking', async () => { +test('a click on a storm card or lead-hour label selects that storm without picking', async (t) => { const handlers = []; let picks = 0, overlayHit = null, @@ -309,8 +286,9 @@ test('a click on a storm card or lead-hour label selects that storm without pick getDiagnostics: () => ({}), }; }, - hitTestOverlay: () => overlayHit, }); + setClickCardHitTest(() => overlayHit); + t.after(() => setClickCardHitTest(null)); const canvas = new EventTarget(); canvas.getBoundingClientRect = () => ({ left: 0, top: 0 }); const viewer = { @@ -343,15 +321,11 @@ test('a click on a storm card or lead-hour label selects that storm without pick overlayHit = { sourceId: 'weather-cyclones', entryId: 'storm:al019999' }; handlers[0].click(click); assert.equal(layer.getDiagnostics().selectedId, 'ep152026'); - // The native release snapshot carries the card identity too. - const up = new Event('pointerup'); - Object.assign(up, { clientX: 10, clientY: 20 }); overlayHit = { sourceId: 'weather-cyclones', entryId: 'storm:ep162026' }; - canvas.dispatchEvent(up); - overlayHit = null; handlers[0].click(click); assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); assert.equal(picks, 0, 'card clicks never fall through to the scene'); + overlayHit = null; handlers[0].click(click); assert.equal(picks, 1); assert.equal(layer.getDiagnostics().selectedId, null, 'empty map clears'); diff --git a/src/layers/directions/index.js b/src/layers/directions/index.js index 873eac5041..53a68aa720 100644 --- a/src/layers/directions/index.js +++ b/src/layers/directions/index.js @@ -1584,6 +1584,9 @@ export function createDirectionsLayer({ services, source }) { // yields the moment a tool (this one included) owns the click. const offSelect = input.onClick((event) => { if (!_enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (services.picking?.isUnderOtherCard?.(event)) return; let hit = null; try { hit = event.drawHit; @@ -1672,13 +1675,10 @@ 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 1e359b8d9b..b83ccdaaf1 100644 --- a/src/layers/droneAirspace/index.js +++ b/src/layers/droneAirspace/index.js @@ -129,23 +129,12 @@ 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, - ); - // 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; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: this area's shapes are background to + // another layer's card or label painted over them, and a click on our + // own card leaves the selection as it is. + if (picking.clickCard?.(event)) return; const picked = event.topHit; const zoneId = picked ? pickedZoneId(event.drawHit) : null; if (zoneId) { @@ -167,7 +156,6 @@ 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 306fd32c55..30045280a6 100644 --- a/src/layers/droneAirspace/ownership.test.mjs +++ b/src/layers/droneAirspace/ownership.test.mjs @@ -17,7 +17,6 @@ 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); @@ -48,9 +47,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), + // The card on top at a click, as the registry answers from the host. + clickCard: (click) => + cardHit(click.screenPosition?.x, click.screenPosition?.y, {}), }, }); layer.init(viewer); @@ -65,7 +64,6 @@ function harness(source, { pick = () => null, cardHit = () => null } = {}) { overlay, clicks, owners, - backgrounds, }; } @@ -284,21 +282,3 @@ 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 1389662a74..58a657c901 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -1,6 +1,10 @@ import { fromDegrees } from '../../geo/ellipsoid.js'; import { drawOf } from '../../render/rendererOf.js'; import { worldClock } from '../../time/worldClock.js'; +import { + isTrackingClickGesture, + isTrackingSelectionGesture, +} from '../../data/trackingClickGesture.js'; import { EARTHQUAKE_OVERLAY_SOURCE_ID, EARTHQUAKE_OVERLAY_COHORT_LIMIT, @@ -58,15 +62,13 @@ let instances = 0; * 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 {object} options.overlayHost World-overlay host. * @param {(viewer: object) => {onClick: Function}} [options.input] The * viewer's click dispatcher. * @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. + * clickCard?: Function}} [options.picking] The pick + * registry; `clickCard` names the card or label painted on top of a + * click, which takes it (the quake card and labels need it to act). * @param {{registerEntityContext: Function, selectEntityContext: Function, * clearSelectedEntityContextForLayer: Function, * getContextStore: Function}} [options.context] Shared selection store. @@ -351,63 +353,39 @@ 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; - // 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 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); - const actedOn = - picking.isActedOnByOtherLayer ?? picking.isOwnedByOtherLayer; - // 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, click })) - return; - const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { - sourceId: EARTHQUAKE_CARD_SOURCE_ID, - }); - if (cardHit && cardHit.entryId === _selectedCardId) { + // A pan that ends near where it began still raises a click. As for the + // tracking layers and Context, a press that travelled is a drag, not a + // pick; opening the source and clearing also need a short press. + if (!isTrackingSelectionGesture(click.gesture)) return; + const clean = isTrackingClickGesture(click.gesture); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: another layer's is that layer's click + // (the disc under it is background), and ours acts whatever is drawn + // under it. + const top = picking.clickCard?.(click) ?? null; + if (top?.sourceId === EARTHQUAKE_CARD_SOURCE_ID) { // 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) + if (top.entryId !== _selectedCardId) return; + if (_selectedLink) { + if (clean) openExternal(_selectedLink); + } else if (focus?.requestWorldFocus && _selectedId) selectAndFocus(_selectedId); 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); + if (top?.sourceId === EARTHQUAKE_OVERLAY_SOURCE_ID) { + if (_eventById.has(top.entryId)) selectAndFocus(top.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 (top) return; + // Another layer's pick (an aircraft, a camera, a flight trail) is not + // empty space and not this layer's: leave the selection alone. + const hit = click.hit; + const pickId = picking.resolvePickId(hit); if (pickId && picking.isOwnedByOtherLayer(EARTHQUAKES_LAYER_ID, pickId)) return; const event = pickedEvent(hit); @@ -416,7 +394,7 @@ export function createEarthquakesLayer({ publishCard({ user: true }); return; } - clearSelection(); + if (clean) clearSelection(); }); } @@ -443,7 +421,6 @@ 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 496908b19a..f336eaee0a 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -83,6 +83,8 @@ function harness( return hit && entry?.interactive === true ? hit : null; }, }; + // The card on top at a click, as the host answers the pick registry. + picking.setClickCardHitTest((x, y) => overlayHost.hitTest(x, y)); const layer = createEarthquakesLayer({ source: { getSnapshot: async () => snapshot }, overlayHost, @@ -128,13 +130,14 @@ function harness( snapshot = next; }, /** Click a quake's disc (by stable id), something else, or the map. */ - click(hit, resolvedHit = hit) { + click(hit, resolvedHit = hit, gesture = { travelPx: 0, durationMs: 0 }) { for (const { callback } of live()) callback({ screenPosition: { x: 10, y: 10 }, topHit: hit, hit: resolvedHit, drawHit: hit && !hit.surface ? hit : null, + gesture, }); }, clickDisc(id) { @@ -276,17 +279,12 @@ test('a refresh keeps the selected quake while it is in the feed', async () => { h.layer.destroy(); }); -test('disable removes the click handler, card background and the card', async () => { +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'); - // 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), @@ -673,7 +671,8 @@ test('a feed refresh neither retakes the selection nor restarts the contours', a h.layer.destroy(); }); -test("another layer's object over a magnitude label takes the click", async () => { +// The label painted on top takes the click: the object drawn under it does not. +test("a magnitude label takes the click over another layer's object", async () => { const h = harness([quake('ak1')]); h.layer.enable(h.viewer); await h.layer.update(h.viewer); @@ -684,12 +683,11 @@ test("another layer's object over a magnitude label takes the click", async () = 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); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1', 'selected'); + assert.equal(h.focused.length, 1, 'and the camera flies'); + // The plane alone, with no label over it, is not empty space. + h.click({ set: 'flights:1', id: 'plane-9' }); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1', 'kept'); } finally { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -709,21 +707,19 @@ test('a touch-expanded quake hit selects its disc without flying', async () => { } }); -test('a touch-expanded sibling hit takes precedence over a quake label', async () => { +test('a quake label takes the click over a touch-expanded sibling hit', 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', { - expanded: true, - }); + 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); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak2'); + assert.equal(h.focused.length, 1); } finally { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -751,7 +747,7 @@ test("another layer's card over a quake disc takes the click, and the disc yield }); for (const coarse of [false, true]) { - test(`a quake card yields while an aircraft starts tracking (${coarse ? 'coarse' : 'exact'} hit)`, async (t) => { + test(`a quake card takes the click over an aircraft, which does not track (${coarse ? 'coarse' : 'exact'} hit)`, async (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: coarse }); t.after(() => { @@ -771,9 +767,10 @@ for (const coarse of [false, true]) { drillPick: () => (nearby ? [{ id: nearby }] : []), }; input = fakeInput(viewer); - // The aircraft layer runs first and changes its passive predicate - // synchronously after reading the dispatched hit. + // The aircraft layer runs first; like every layer, it leaves a + // click under another layer's card to that card. input.input.onClick((event) => { + if (picking.isUnderOtherCard(event)) return; const id = event.hit?.id; if (id !== plane.id || tracked === id) return; tracked = id; @@ -782,10 +779,7 @@ for (const coarse of [false, true]) { return input.input; }, }); - picking.registerPickOwner('test-plane', (id) => id === plane.id, { - expanded: true, - passive: (id) => id === tracked, - }); + picking.registerPickOwner('test-plane', (id) => id === plane.id); t.after(() => { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -804,15 +798,18 @@ for (const coarse of [false, true]) { 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'); - - input.click(); - assert.equal(tracks, 1, 'already tracking the aircraft'); + assert.equal(tracks, 0, 'the aircraft under the card does not track'); assert.deepEqual(h.opened, [ 'https://earthquake.usgs.gov/earthquakes/eventpage/ak1', ]); + assert.equal(h.lastCard()[0].id, card.id, 'the card stays'); + + // Without the card the aircraft takes it, and the quake stays selected. + h.overlayHits.clear(); + input.click(); + assert.equal(tracks, 1, 'the bare aircraft tracks'); + assert.equal(h.opened.length, 1); + assert.equal(h.lastCard()[0].id, card.id); }); } @@ -853,6 +850,7 @@ for (const kind of ['card', 'label']) { paint(); input.click(); }; + picking.setClickCardHitTest((x, y) => host.hitTest(x, y)); const q = createEarthquakesLayer({ source: { getSnapshot: async () => [quake('ak1')] }, overlayHost: host, @@ -983,15 +981,12 @@ test('quake card and label work over pickable items no layer acts on', async () } }); -// 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 () => { +// The quake card or a magnitude label on top takes the click over whatever is +// drawn under it: a flight trail, a route, a route step or an aircraft. +test('quake card and label act over trails, routes, steps and aircraft', 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-directions', (id) => + String(id).startsWith('directions:'), ); picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); try { @@ -1006,19 +1001,19 @@ test('quake card and label act over a flight trail and a directions route', asyn 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; + // A route step under the label: the label still takes it. 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. + assert.equal(h.focused.at(-1)?.id, 'earthquake:ak1', 'over a step'); + // So does the card over an aircraft. + h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', null); h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, 'earthquake-card:ak2', { set: 'flights:1', id: 'plane-9', }); - assert.equal(h.opened.length, 2); + assert.equal(h.opened.length, 3, 'over an aircraft'); // 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'); @@ -1029,7 +1024,7 @@ test('quake card and label act over a flight trail and a directions route', asyn } }); -test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits act once', async (t) => { +test('quake overlays take the click over a nearby or exact fire; a bare fire acts once', async (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -1094,8 +1089,12 @@ test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits 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'); + assert.equal(fireFocus.length, 0, 'an exact fire under the card does not'); + assert.equal(h.opened.length, 2, 'the card on top acts'); + h.overlayHits.clear(); + input.click(); + assert.equal(fireFocus.length, 1, 'the bare fire acts'); + assert.equal(h.opened.length, 2); } finally { selection.removeClickHandler(); picking.unregisterPickOwner('firms'); @@ -1104,9 +1103,9 @@ test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits } }); -// 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) => { +// A tap that drifts more than the tracking click travel is a drag: the quake +// card ignores it, as the aircraft layers do. +test('a quake card takes a still tap beside an aircraft but not a dragged one', async (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -1127,10 +1126,7 @@ test('a quake card keeps a dragged tap beside an aircraft that declines it', asy return input.input; }, }); - picking.registerPickOwner('test-plane', (id) => id === plane.id, { - expanded: true, - declinesClick: (click) => (click?.gesture?.travelPx ?? 0) > 6, - }); + picking.registerPickOwner('test-plane', (id) => id === plane.id); t.after(() => { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -1147,15 +1143,57 @@ test('a quake card keeps a dragged tap beside an aircraft that declines it', asy }); sceneHit = null; nearby = plane; - // A still tap: the aircraft acts on its contact, so the card yields. + // A still tap: the card on top takes it over the aircraft's contact. input.tap({ x: 10, y: 10 }); - assert.deepEqual(h.opened, []); + assert.equal(h.opened.length, 1); // 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'); + assert.equal(h.opened.length, 1, 'a drag opens nothing'); +}); + +// A pan that ends near where it began still raises a click: it must not +// select a quake, fly to one, open its source or clear the selection. +test('a drag that ends on a quake does nothing; a long press selects but neither opens nor clears', async () => { + const drag = { travelPx: 12, durationMs: 120 }; + const hold = { travelPx: 0, durationMs: 900 }; + const h = harness([quake('ak1'), quake('ak2')]); + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + const disc = (id) => ({ set: h.discs().spec.id, id: `earthquake:${id}` }); + h.click(disc('ak1'), disc('ak1'), drag); + assert.equal(h.cards.length, 0, 'a drag over a disc selects nothing'); + h.overlayHits.set(EARTHQUAKE_OVERLAY_SOURCE_ID, { + sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID, + entryId: 'ak2', + }); + h.click(null, null, drag); + h.overlayHits.clear(); + assert.equal(h.focused.length, 0, 'a drag over a label does not fly'); + h.click(disc('ak1'), disc('ak1'), hold); + const card = h.lastCard()[0]; + assert.ok(card, 'a long press on a disc selects it'); + h.overlayHits.set(EARTHQUAKE_CARD_SOURCE_ID, { + sourceId: EARTHQUAKE_CARD_SOURCE_ID, + entryId: card.id, + }); + h.click(null, null, hold); + h.overlayHits.clear(); + assert.deepEqual(h.opened, [], 'a long press does not open the source'); + const cardsBefore = h.cards.length; + h.click(null, null, drag); + h.click(null, null, hold); + assert.equal( + h.cards.length, + cardsBefore, + 'a drag or hold on the map keeps it', + ); + assert.ok(h.lastCard().length, 'still selected'); + h.click(null); + assert.deepEqual(h.lastCard(), [], 'a clean click on the map clears it'); + h.layer.destroy(); }); // A refresh that no longer carries the selected quake evicts it, as other diff --git a/src/layers/firms/selection.js b/src/layers/firms/selection.js index 6788cf64f4..54622bb4a2 100644 --- a/src/layers/firms/selection.js +++ b/src/layers/firms/selection.js @@ -13,8 +13,7 @@ export function createSelection({ config, feed, }) { - const { resolvePickId, isOwnedByOtherLayer, isActedOnByOtherLayer } = - services.picking; + const { resolvePickId, isOwnedByOtherLayer, clickCard } = services.picking; const { requestWorldFocus } = services.focus; const { selectEntityContext, @@ -22,7 +21,7 @@ export function createSelection({ getContextStore, registerEntityContext, } = services.context; - const { id, name, overlayHost } = config; + const { id, name } = config; /** * Install the LEFT_CLICK handler for fire selection (enable-time only, @@ -35,48 +34,25 @@ export function createSelection({ if (layerState._clickSubscription || !layerState._viewer) return; const input = inputFor(layerState._viewer); layerState._clickSubscription = input.onClick((event) => { - const picked = event.topHit; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours acts whatever is drawn under it; + // another layer's is that layer's click. + const top = clickCard?.(event) ?? null; + if (top) { + if (top.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; + const carded = layerState._fireByCardId.get(top.entryId); + if (carded) selectAndFocusFire(carded); + return; + } const fire = pickedFire(event.drawHit); if (fire) { selectAndFocusFire(fire); return; } - // 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)) { - passivePick = - Boolean(isActedOnByOtherLayer) && - !isActedOnByOtherLayer(id, pickedId, { click: event }); - 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, click: event }) - ) - return; - if (cardHit) { - if (cardHit.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; - const carded = layerState._fireByCardId.get(cardHit.entryId); - if (carded) selectAndFocusFire(carded); - return; - } + // A pick that belongs to a sibling layer (an aircraft, a flight trail) + // is not "empty space": leave the selection alone. + const pickedId = resolvePickId(event.topHit ?? null); + if (pickedId && isOwnedByOtherLayer(id, pickedId)) return; clearFireSelection(); }); } diff --git a/src/layers/flights/lifecycle.js b/src/layers/flights/lifecycle.js index fa25261e83..790aad1495 100644 --- a/src/layers/flights/lifecycle.js +++ b/src/layers/flights/lifecycle.js @@ -1,4 +1,3 @@ -import { isTrackingSelectionGesture } from '../../data/trackingClickGesture.js'; import { findCamera, findFrame } from '../../render/rendererOf.js'; import { loadFleetModelSet } from '../../data/fleetModels.js'; import { forgetPlacedAircraft } from './placed.js'; @@ -135,19 +134,6 @@ 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, - // 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); if (!flightState._preRenderRemove && frame) { diff --git a/src/layers/flights/ownership.test.mjs b/src/layers/flights/ownership.test.mjs index 3947a6999f..c5a7d1a340 100644 --- a/src/layers/flights/ownership.test.mjs +++ b/src/layers/flights/ownership.test.mjs @@ -4,6 +4,8 @@ import { createCivilFlightLayer } from './index.js'; import { createFlightState } from './state.js'; import { createEnrichment } from './enrichment.js'; import { createTracking } from './tracking.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; import { LiveSourceError } from '../../sources/live/contract.js'; function services() { @@ -608,3 +610,47 @@ test('a route answer for a callsign the plane no longer flies is dropped', async assert.equal(meta.routeCallsign, 'UAL10'); flightState.lifetime.abort(); }); + +// The card or label painted on top takes the click: an aircraft under another +// layer's card is not even picked, so it is neither tracked nor released. +test("another layer's card over an aircraft keeps the click", (t) => { + const previousDocument = globalThis.document; + globalThis.document = Object.assign(new EventTarget(), { + body: { classList: { contains: () => false } }, + }); + let picks = 0; + const viewer = { + scene: { + canvas: new EventTarget(), + pick: () => { + picks++; + return null; + }, + }, + }; + const input = fakeInput(viewer); + const flightState = createFlightState({ services: services() }); + flightState._trackedEntityChangedRemove = () => {}; + const tracking = createTracking({ + flightState, + services: { ...services(), picking }, + parts: {}, + layer: {}, + }); + tracking._installClickHandler(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + picking.setClickCardHitTest(() => top); + t.after(() => { + picking.setClickCardHitTest(null); + flightState._clickSubscription?.(); + input.destroy(); + flightState.lifetime.abort(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); +}); diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js index 8017e05170..93c2d61b84 100644 --- a/src/layers/flights/tracking.js +++ b/src/layers/flights/tracking.js @@ -86,7 +86,8 @@ export function createTracking({ const { trackedLabelModelFromText, refreshTrackedReadout } = services.readout; const { FOLLOW_MIN_RANGE_M, SELECTION_FOLLOW_TRANSITION_S, followViewFrom } = services.camera; - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isUnderOtherCard } = + services.picking; const flightsLayer = layer; /** The tracked contact's billboard (an icon set on the draw port). */ const trackedIcon = createTrackedAircraftIcon({ @@ -1272,6 +1273,9 @@ export function createTracking({ // first-person reference. A globe click must not fall through to the // normal empty-space deselection path; cockpit has explicit exit controls. if (document.body.classList.contains('cockpit-mode')) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard?.(event)) return; const picked = event.hit; if (picked) { diff --git a/src/layers/ghostMaps/index.js b/src/layers/ghostMaps/index.js index d2378de613..216e51b9b4 100644 --- a/src/layers/ghostMaps/index.js +++ b/src/layers/ghostMaps/index.js @@ -707,15 +707,19 @@ export function createGhostMapsLayer({ typeof pickedId === 'string' && pickedId.startsWith(PICK_PREFIX), ); _clickSubscription = inputFor(_viewer).onClick((event) => { - const cardHit = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ); - if ( - cardHit?.sourceId === GHOSTMAPS_OVERLAY_SOURCE_ID && - cardHit.entryId === _selectedCardId - ) { - if (_selectedLink && openExternal) openExternal(_selectedLink); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours opens its source whatever is drawn + // under it; another layer's is that layer's click, so the maps under + // it do not act and the selection stays. + const cardHit = picking.clickCard?.(event) ?? null; + if (cardHit) { + if ( + cardHit.sourceId === GHOSTMAPS_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId && + _selectedLink && + openExternal + ) + openExternal(_selectedLink); return; } const picked = event.topHit; @@ -731,10 +735,6 @@ 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 ea4f99bed7..dd07ad4f96 100644 --- a/src/layers/ghostMaps/lifecycle.test.mjs +++ b/src/layers/ghostMaps/lifecycle.test.mjs @@ -664,7 +664,11 @@ test('a covered selected card yields while genuine GhostMaps markers still selec hitTest: (_x, _y, { sourceId } = {}) => painted.find((hit) => !sourceId || hit.sourceId === sourceId) ?? null, }, - picking: { resolvePickId: (picked) => picked }, + picking: { + resolvePickId: (picked) => picked, + // The card on top at a click, as the registry answers from the host. + clickCard: () => painted[0] ?? null, + }, openExternal: (url) => opened.push(url), }, }); @@ -679,13 +683,13 @@ test('a covered selected card yields while genuine GhostMaps markers still selec click(null); assert.deepEqual(opened, []); assert.equal(cards.at(-1)[0].id, first.id); + // A marker under another layer's card is that card's click too. + click('ghostmaps:cip:1:0'); + assert.equal(cards.at(-1)[0].id, first.id, 'a covered marker yields'); + painted = []; 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', - ); + assert.notEqual(second.id, first.id, 'a bare marker selects'); painted = [{ sourceId: 's2-ghostmaps', entryId: second.id }]; click(null); assert.deepEqual(opened, ['https://example.com/second']); diff --git a/src/layers/installations/selection.js b/src/layers/installations/selection.js index 323b7a1549..28a9301d0b 100644 --- a/src/layers/installations/selection.js +++ b/src/layers/installations/selection.js @@ -1,4 +1,5 @@ import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { LAYER_ID } from './policy.js'; export function createSelection({ @@ -52,6 +53,9 @@ export function createSelection({ const input = inputFor(viewer); layerState.clickSubscription = input.onClick((event) => { if (!layerState.enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; // A site's dot, outline or fill, or a named marker: each draw item // names its installation in its `meta`. const hit = event.drawHit; diff --git a/src/layers/installations/selection.test.mjs b/src/layers/installations/selection.test.mjs index ae6cc71fda..7844afb3ba 100644 --- a/src/layers/installations/selection.test.mjs +++ b/src/layers/installations/selection.test.mjs @@ -7,6 +7,7 @@ import { createRendering } from './rendering.js'; import { createNamedMarkers, namedPointId } from './namedMarkers.js'; import { bindFakeCesiumScene } from '../../testSupport/fakeCesiumScene.mjs'; import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; function harness(t) { const previousWindow = globalThis.window; @@ -186,6 +187,30 @@ test('a click on a named marker point selects its site; again releases it', (t) h.assertSelected(false); }); +// The card or label painted on top takes the click: a site under another +// layer's card neither selects nor releases. +test("another layer's card over a site keeps the click", (t) => { + const h = harness(t); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const setId = h.parts.namedMarkers.setId; + const item = h.draw.set(setId).items.get(namedPointId('base')); + const pointPick = { id: { set: setId, id: item.id, meta: item.meta } }; + h.click(pointPick); + h.assertSelected(true); + h.click(undefined); + h.assertSelected(true); + h.state.selectedId = null; + context.clearSelectedEntityContextForLayer('military-installations'); + h.parts.rendering.renderRecords(); + h.click(pointPick); + h.assertSelected(false); + top = null; + h.click(pointPick); + h.assertSelected(true); +}); + test('a click on a site dot or its outline selects the site; another set does not', (t) => { const h = harness(t); h.state.selectedId = null; diff --git a/src/layers/launches/clickYield.test.mjs b/src/layers/launches/clickYield.test.mjs index 9004e10c19..62dc8c31d4 100644 --- a/src/layers/launches/clickYield.test.mjs +++ b/src/layers/launches/clickYield.test.mjs @@ -28,8 +28,8 @@ test('a card painted over a launch marker keeps its click; with none the mission state, services: { render: { holdContinuousRender() {}, releaseContinuousRender() {} }, - overlays: { hitTestWorldOverlay: () => top }, - picking, + // The card on top at a click, as the registry answers from the host. + picking: { ...picking, clickCard: () => top }, }, parts: { panel: stubs(), @@ -61,15 +61,6 @@ test('a card painted over a launch marker keeps its click; with none the mission ['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 dd9950dc96..77a999e047 100644 --- a/src/layers/launches/lifecycle.js +++ b/src/layers/launches/lifecycle.js @@ -4,8 +4,6 @@ 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 @@ -206,29 +204,12 @@ 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; + if (services.picking?.clickCard?.(event)) return; // The click's pick position (CSS px), as the click picked it. const launchId = parts.rendering.launchIdFromPicks( parts.rendering.missionHitsAt(event.position, 12), @@ -248,7 +229,6 @@ 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/localAdsb/index.js b/src/layers/localAdsb/index.js index 22cd4a12f4..b30357865c 100644 --- a/src/layers/localAdsb/index.js +++ b/src/layers/localAdsb/index.js @@ -684,6 +684,9 @@ export function createLocalAdsbLayer({ if (clickSubscription || !viewer) return; clickSubscription = inputFor(viewer).onClick((event) => { if (!enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (services.picking.isUnderOtherCard?.(event)) return; const target = clickTarget(event); // Clicking a local aircraft always (re)selects it and republishes its // card, including the one already selected: its card may have been diff --git a/src/layers/localAdsb/index.test.mjs b/src/layers/localAdsb/index.test.mjs index 5b29e91a2f..c2e05d9c3e 100644 --- a/src/layers/localAdsb/index.test.mjs +++ b/src/layers/localAdsb/index.test.mjs @@ -14,7 +14,11 @@ import { } from './index.js'; import { createLocalAdsbModels } from './models.js'; import { entityRecord, readEntityRecord } from '../../data/entityRecords.js'; -import { resolvePickId } from '../../data/pickRegistry.js'; +import { + isUnderOtherCard, + resolvePickId, + setClickCardHitTest, +} from '../../data/pickRegistry.js'; import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js'; import { fakeInput } from '../../input/testDoubles.mjs'; import { hexColor } from '../../render/color.js'; @@ -1172,6 +1176,41 @@ test('clicking the selected aircraft keeps it selected and republishes its card' assert.deepEqual(calls.cleared, []); }); +// The card or label painted on top takes the click: a local aircraft under +// another layer's card is neither selected nor released. +test("another layer's card over a local aircraft keeps the click", async (t) => { + const receiver = fakeReceiver({ mode: 'adsb', connected: true }); + const clock = { now: 100_000 }; + const harness = clickHarness(); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const { layer, calls, draw } = await enabledLayer(receiver, clock, null, { + viewer: harness.viewer, + services: { + picking: { + registerPickOwner() {}, + unregisterPickOwner() {}, + resolvePickId, + isUnderOtherCard, + }, + }, + }); + t.after(() => layer.destroy()); + receiver.set({ aircraft: [record()] }); + await layer.update(); + harness.scene.pickResult = iconPick(draw, 'local-adsb:abc123'); + harness.click(); + assert.deepEqual(calls.selected, [], 'covered: not selected'); + top = null; + harness.click(); + assert.deepEqual(calls.selected, ['local-adsb:abc123']); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + harness.scene.pickResult = null; + harness.click(); + assert.deepEqual(calls.cleared, [], 'covered: the selection stays'); +}); + test('a click on a local aircraft under an unowned or trail pick still selects it', async (t) => { const receiver = fakeReceiver({ mode: 'adsb', connected: true }); const clock = { now: 100_000 }; diff --git a/src/layers/military/lifecycle.js b/src/layers/military/lifecycle.js index c7e667d4ff..0389ef3f02 100644 --- a/src/layers/military/lifecycle.js +++ b/src/layers/military/lifecycle.js @@ -1,4 +1,3 @@ -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'; @@ -116,19 +115,6 @@ 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 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 setMilitaryLayerActive(true); diff --git a/src/layers/military/ownership.test.mjs b/src/layers/military/ownership.test.mjs index 3915f5d785..c8f90d0385 100644 --- a/src/layers/military/ownership.test.mjs +++ b/src/layers/military/ownership.test.mjs @@ -3,6 +3,8 @@ import assert from 'node:assert/strict'; import { createMilitaryFlightLayer } from './index.js'; import { createFlightState } from './state.js'; import { createTracking } from './tracking.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; function services() { const names = [ @@ -294,3 +296,47 @@ test('a military layer without an icon set declines contact refreshes', () => { assert.equal(layer.refreshTr3b('abc123'), false); assert.equal(layer.trackById('abc123'), false); }); + +// The card or label painted on top takes the click: an aircraft under another +// layer's card is not even picked, so it is neither tracked nor released. +test("another layer's card over an aircraft keeps the click", (t) => { + const previousDocument = globalThis.document; + globalThis.document = Object.assign(new EventTarget(), { + body: { classList: { contains: () => false } }, + }); + let picks = 0; + const viewer = { + scene: { + canvas: new EventTarget(), + pick: () => { + picks++; + return null; + }, + }, + }; + const input = fakeInput(viewer); + const flightState = createFlightState({ services: services() }); + flightState._trackedEntityChangedRemove = () => {}; + const tracking = createTracking({ + flightState, + services: { ...services(), picking }, + parts: {}, + layer: {}, + }); + tracking._installClickHandler(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + picking.setClickCardHitTest(() => top); + t.after(() => { + picking.setClickCardHitTest(null); + flightState._clickSubscription?.(); + input.destroy(); + flightState.lifetime.abort(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); +}); diff --git a/src/layers/military/tracking.js b/src/layers/military/tracking.js index ef8e7d8673..2998369c79 100644 --- a/src/layers/military/tracking.js +++ b/src/layers/military/tracking.js @@ -87,7 +87,8 @@ export function createTracking({ const { clearFocusTarget } = services.focus; const { FOLLOW_MIN_RANGE_M, SELECTION_FOLLOW_TRANSITION_S, followViewFrom } = services.camera; - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isUnderOtherCard } = + services.picking; /** The tracked contact's billboard (an icon set on the draw port). */ const trackedIcon = createTrackedAircraftIcon({ viewer: () => flightState._viewer, @@ -1191,6 +1192,9 @@ export function createTracking({ // first-person reference. Empty globe clicks are inert until the user // exits with C, Escape, or the dedicated button. if (document.body.classList.contains('cockpit-mode')) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard?.(event)) return; const picked = event.hit; if (picked) { diff --git a/src/layers/news/index.js b/src/layers/news/index.js index 7e5e9a7eae..3c228d32c0 100644 --- a/src/layers/news/index.js +++ b/src/layers/news/index.js @@ -8,8 +8,8 @@ import { findFrame, rendererOf, } from '../../render/rendererOf.js'; -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; import { + clickCard, isOwnedByOtherLayer, registerPickOwner, resolvePickId, @@ -203,7 +203,6 @@ export function createNewsLayer({ inputFor = defaultInputFor, matchMedia = globalThis.matchMedia?.bind(globalThis), now = () => Date.now(), - hitTestOverlay = hitTestWorldOverlay, openUrl = (url) => globalThis.open?.(url, '_blank', 'noopener,noreferrer'), getViewCentre = viewCentre, registerCredit = registerDynamicCredit, @@ -1348,11 +1347,13 @@ export function createNewsLayer({ clickOff = inputFor(viewer).onClick((event) => { const at = event?.screenPosition; if (!enabled || destroyed || !isPointerFree() || !at) return; - // 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(); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: our own card acts whatever is drawn + // under it; another layer's is that layer's click, so the pins under + // it do not act and the selection stays. + const card = clickCard(event); + if (card) { + if (card.sourceId === NEWS_OVERLAY_SOURCE_ID) card.entry?.activate?.(); return; } // What is on top under the click: a draw-set item, or null for the @@ -1408,8 +1409,6 @@ 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 7ad0d9a8a1..9a31dd9474 100644 --- a/src/layers/news/layer.test.mjs +++ b/src/layers/news/layer.test.mjs @@ -5,7 +5,12 @@ 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 } from '../../data/pickRegistry.js'; +import { + findPickOwner, + registerPickOwner, + setClickCardHitTest, + 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'; @@ -141,11 +146,12 @@ function fixture( for (const fn of [...clickHandlers]) fn({ screenPosition: { x: 10, y: 10 }, topHit }); }; + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest((x, y) => hitTestOverlay(x, y)); const layer = createNewsLayer({ source, overlayHost, inputFor: () => input, - hitTestOverlay, now, matchMedia: () => ({ matches: reduced }), getViewCentre: () => centre(), @@ -162,6 +168,7 @@ function fixture( layer.attachShellServices({ runNavigation: (navigate) => navigate() }); t.after(() => { layer.destroy(); + setClickCardHitTest(null); unbind(); if (originalWindow === undefined) delete globalThis.window; else globalThis.window = originalWindow; @@ -1289,7 +1296,7 @@ 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) => { +test('a covered news card and pin yield; the top news card acts over a trail or a vessel', async (t) => { let hits = []; const { layer, items, entries, click, flights } = fixture(t, { height: 500_000, @@ -1322,10 +1329,14 @@ test('a covered news card yields; the top news card acts over a flight trail', a assert.equal(layer.getRowControls().feed.selected.id, 'major'); assert.deepEqual(layer.getRowControls().feed.filters, before.filters); assert.equal(flights.length, flightCount); + // A news pin under another layer's card is that card's click too. layer.setParams({ clear: true }); click({ set: 'news:1:points', id: marker.id, surface: false }); + assert.equal(layer.getRowControls().feed.selected, null, 'covered pin'); + hits = []; + click({ set: 'news:1:points', id: marker.id, surface: false }); assert.equal(layer.getRowControls().feed.selected.id, 'major'); - hits.shift(); + hits = [{ sourceId: 'news', entry: card }]; 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 @@ -1338,6 +1349,15 @@ test('a covered news card yields; the top news card acts over a flight trail', a surface: false, }); assert.equal(activations, 2, 'the news card acts over a flight trail'); + // Over a vessel (a layer that acts on its pick) the card on top acts too; + // the vessel layer stands aside under it, so one click does one thing. + registerPickOwner('test-vessels', (id) => id === '353136000'); + try { + click({ set: 'vessels:1', id: '353136000', surface: false }); + assert.equal(activations, 3, 'the news card acts over a vessel'); + } finally { + unregisterPickOwner('test-vessels'); + } }); test('zoomed out, a hotspot is one beacon; off, nothing draws; destroyed, the sets go', async (t) => { diff --git a/src/layers/perimeters/index.js b/src/layers/perimeters/index.js index d973f8d6d7..8d0e1ab7ed 100644 --- a/src/layers/perimeters/index.js +++ b/src/layers/perimeters/index.js @@ -215,25 +215,21 @@ 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, - ); - // 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); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: this area's shapes are background to + // another layer's card or label painted over them. + const cardHit = picking.clickCard?.(event) ?? null; + if (cardHit) { + if ( + cardHit.sourceId === PERIMETER_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId && + _selectedLink && + openExternal + ) + openExternal(_selectedLink); return; } const picked = event.topHit; @@ -261,7 +257,6 @@ 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 bd0533a28b..25584f535c 100644 --- a/src/layers/perimeters/ownership.test.mjs +++ b/src/layers/perimeters/ownership.test.mjs @@ -27,7 +27,6 @@ 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); @@ -59,9 +58,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), + // The card on top at a click, as the registry answers from the host. + clickCard: (click) => + cardHit(click.screenPosition?.x, click.screenPosition?.y, {}), }, inciwebSource: inciwebIndex ? { getIndex: async () => inciwebIndex } @@ -81,7 +80,6 @@ function harness( overlay, clicks, owners, - backgrounds, opened, }; } @@ -694,21 +692,3 @@ 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/radio/interaction.js b/src/layers/radio/interaction.js index 154652aed3..41674fcf84 100644 --- a/src/layers/radio/interaction.js +++ b/src/layers/radio/interaction.js @@ -15,6 +15,7 @@ export function createInteraction({ const { resolvePickId, isOwnedByOtherLayer, + isUnderOtherCard, registerPickOwner, unregisterPickOwner, } = services.picking; @@ -29,6 +30,9 @@ export function createInteraction({ */ function pickedRadioStationAt(event) { if (!event) return null; + // Another layer's card or label painted on top is that layer's click, + // read once per click so every layer agrees: no station under it acts. + if (isUnderOtherCard?.(event, [RADIO_OVERLAY_SOURCE_ID])) return null; const stationFromPick = (picked) => { const stationId = parts.rendering.radioStationIdFromPick(picked); @@ -48,28 +52,11 @@ export function createInteraction({ RADIO_PICK_WINDOW_PX, )) { const stationId = stationFromPick(picked); - 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. 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; + if (stationId) 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 ( @@ -97,9 +84,7 @@ export function createInteraction({ function installInteraction() { if (!layerState._viewer || layerState._clickSubscription) return; - registerPickOwner('radio', (id) => id.startsWith(RADIO_PREFIX), { - expanded: true, - }); + registerPickOwner('radio', (id) => id.startsWith(RADIO_PREFIX)); 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 e11dd61bdf..c776180f43 100644 --- a/src/layers/radio/interaction.test.mjs +++ b/src/layers/radio/interaction.test.mjs @@ -63,73 +63,48 @@ 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', () => { +// Another layer's card or label painted on top takes the click: no station +// under it acts, whether radio found it through its window, as the tap's touch +// contact or as the exact pick. Radio's own card on top is radio's click. +test("a station under another layer's card does not act", () => { let top = null; const radio = createInteraction({ - state: { _stationById: new Map([['kexp', {}]]) }, + state: { + _stationById: new Map([ + ['kexp', {}], + ['kuow', {}], + ]), + }, services: { picking: { resolvePickId: (picked) => picked?.id ?? null, isOwnedByOtherLayer: () => false, + // The card on top at a click, as the registry answers from the host. + isUnderOtherCard: (_click, own = []) => + Boolean(top) && !own.includes(top.sourceId), registerPickOwner() {}, unregisterPickOwner() {}, }, - overlays: { - setOverlaySourceVisible() {}, - hitTestWorldOverlay: () => top, - }, + overlays: { setOverlaySourceVisible() {} }, }, parts: { rendering: { radioStationIdFromPick } }, }); const station = hit('radio:kexp'); - const near = (contact = null) => ({ - ...clickEvent({ windowHits: [station] }), + const tap = (contact = null, pick = null) => ({ + ...clickEvent({ pick, windowHits: [station] }), hit: contact, screenPosition: { x: 5, y: 5 }, }); - assert.equal(radio.pickedRadioStationAt(near()), 'kexp', 'open map'); + assert.equal(radio.pickedRadioStationAt(tap()), '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(tap()), null, 'window only'); + assert.equal(radio.pickedRadioStationAt(tap(station)), null, 'contact'); assert.equal( - radio.pickedRadioStationAt(near(station)), - 'kexp', - 'the touch contact: the card yielded to the station', + radio.pickedRadioStationAt(tap(hit('radio:kuow'))), + null, + 'another contact station', ); + assert.equal(radio.pickedRadioStationAt(tap(null, station)), null, 'exact'); 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'); + assert.equal(radio.pickedRadioStationAt(tap()), 'kexp', 'our own card'); }); diff --git a/src/layers/rail/follow.test.mjs b/src/layers/rail/follow.test.mjs index 3d6aa1e1f2..2130bacebc 100644 --- a/src/layers/rail/follow.test.mjs +++ b/src/layers/rail/follow.test.mjs @@ -10,6 +10,7 @@ import { SELECTION_FOLLOW_TRANSITION_S, } from '../../data/trackedCamera.js'; import { fromDegrees } from '../../geo/ellipsoid.js'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; import { distance } from '../../geo/vector.js'; import { ACTIVATION_EXIT_ALTITUDE_M, @@ -203,6 +204,25 @@ test('a click on a train selects it; a click on the map lets it go', async (t) = assert.equal(app.state()._selectedKey, key); }); +// The card or label painted on top takes the click: a train under another +// layer's card is neither selected nor let go. +test("another layer's card over a train keeps the click", async (t) => { + const app = harness(t); + const key = await bringToMotion(app, 'mbta-rail', 'T1', BOSTON); + const icons = app.drawn('icons'); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + app.click({ set: icons.spec.id, id: key, surface: false }); + assert.equal(app.state()._selectedKey ?? null, null, 'covered: not selected'); + top = null; + app.click({ set: icons.spec.id, id: key, surface: false }); + assert.equal(app.state()._selectedKey, key); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + app.click(null); + assert.equal(app.state()._selectedKey, key, 'covered: kept'); +}); + test('a parked train, or one known from a single report, is flown to once', async (t) => { const app = harness(t); await bringToMotion(app, 'mbta-rail', 'T1', BOSTON); diff --git a/src/layers/rail/selection.js b/src/layers/rail/selection.js index 0fdee59bc8..d2663cf200 100644 --- a/src/layers/rail/selection.js +++ b/src/layers/rail/selection.js @@ -7,6 +7,7 @@ import { } from './policy.js'; import { getRegisteredRailFeed } from '../../data/railFeeds.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { t } from '../../i18n/index.js'; /** @@ -173,6 +174,9 @@ export function createSelection({ state, services, parts }) { if (!state._enabled) return; // A held train keeps the selection until its view lets it go. if (state._cockpitSubjectKey) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; const key = trainKeyOf(event.drawHit); if (key) selectAndFocusTrain(key); else if (state._selectedKey) clearSelection(); diff --git a/src/layers/satellites/interaction.js b/src/layers/satellites/interaction.js index 643f637798..393fc072e7 100644 --- a/src/layers/satellites/interaction.js +++ b/src/layers/satellites/interaction.js @@ -7,7 +7,8 @@ export function createInteraction({ parts, source, }) { - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isUnderOtherCard } = + services.picking; function _onKeyDown(e) { // The Cockpit owns Escape while it rides the tracked satellite. @@ -50,6 +51,9 @@ export function createInteraction({ // The Cockpit camera rides the tracked satellite: a click on the // picture below must not untrack it or switch satellites. if (parts.cockpit?._cockpitHeld()) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard?.(event)) return; const picked = event.topHit; const hit = event.drawHit; diff --git a/src/layers/satellites/interaction.test.mjs b/src/layers/satellites/interaction.test.mjs new file mode 100644 index 0000000000..163078e9ca --- /dev/null +++ b/src/layers/satellites/interaction.test.mjs @@ -0,0 +1,65 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createInteraction } from './interaction.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; + +// The card or label painted on top takes the click: a satellite under another +// layer's card is neither tracked nor let go. +test("another layer's card over a satellite keeps the click", (t) => { + const previousDocument = globalThis.document; + globalThis.document = new EventTarget(); + let picked = null; + const viewer = { scene: { canvas: new EventTarget(), pick: () => picked } }; + const input = fakeInput(viewer); + const calls = []; + const state = { + _enabled: true, + _trackedNorad: null, + _clickSubscription: null, + _trackedEntityChangedRemove: () => {}, + _catalog: new Map([[25544, {}]]), + }; + const interaction = createInteraction({ + state, + services: { picking }, + parts: { + rendering: { + _hitIsTracked: () => false, + _hitPointId: (hit) => + hit?.set === 'satellites:dots' ? Number(hit.id) : null, + }, + tracking: { + _cancelPendingTrackingRestore() {}, + _trackSatellite: (id) => calls.push(['track', id]), + _clearTracking: () => calls.push(['clear']), + }, + }, + }); + interaction._installClickHandler(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + picking.setClickCardHitTest(() => top); + t.after(() => { + picking.setClickCardHitTest(null); + state._clickSubscription?.(); + input.destroy(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + const click = (hit) => { + picked = hit ? { id: hit } : null; + input.tap({ x: 10, y: 10 }); + }; + const dot = { set: 'satellites:dots', id: '25544' }; + click(dot); + assert.deepEqual(calls, [], 'covered: not tracked'); + state._trackedNorad = 1; + click(null); + assert.deepEqual(calls, [], 'covered: tracking kept'); + top = null; + click(null); + assert.deepEqual(calls, [['clear']], 'open map lets it go'); + state._trackedNorad = null; + click(dot); + assert.deepEqual(calls.at(-1), ['track', 25544]); +}); diff --git a/src/layers/shipwrecks/index.js b/src/layers/shipwrecks/index.js index c8eff42cb7..8dcbe4bb7e 100644 --- a/src/layers/shipwrecks/index.js +++ b/src/layers/shipwrecks/index.js @@ -277,13 +277,18 @@ export function createShipwrecksLayer({ if (!clicks) return; _clickHandler = clicks.onClick((click) => { if (pointer && !pointer.isPointerFree()) return; - const at = click.screenPosition; - const cardHit = overlayHost.hitTest?.(at?.x, at?.y); - if ( - cardHit?.sourceId === SHIPWRECKS_OVERLAY_SOURCE_ID && - cardHit.entryId === _selectedCardId - ) { - if (_selectedLink) openExternal(_selectedLink); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours opens its source whatever is drawn + // under it; another layer's is that layer's click, so the markers + // under it do not act and the selection stays. + const cardHit = picking.clickCard?.(click) ?? null; + if (cardHit) { + if ( + cardHit.sourceId === SHIPWRECKS_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId && + _selectedLink + ) + openExternal(_selectedLink); return; } // A marker's item id is its pick id, `shipwreck:`. Read from what is @@ -300,10 +305,6 @@ 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 6209129caa..69e80f4eb2 100644 --- a/src/layers/shipwrecks/index.test.mjs +++ b/src/layers/shipwrecks/index.test.mjs @@ -47,6 +47,8 @@ function harness({ snapshots, now = () => 1, cardHit = () => null } = {}) { const { draw } = bindFakeDraw(viewer); const queue = [...(snapshots || [])]; const requests = []; + // The card on top at a click, as the host answers the pick registry. + picking.setClickCardHitTest((x, y) => cardHit(x, y)); const layer = createShipwrecksLayer({ source: { getSnapshot({ signal }) { @@ -394,7 +396,7 @@ 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 () => { +test('a covered selected card and covered markers yield; bare markers select', async () => { let painted = []; const h = harness({ snapshots: [ @@ -421,8 +423,12 @@ test('a covered selected card yields while genuine wreck markers still select', click(); assert.deepEqual(h.opened, []); assert.equal(h.lastCard()[0].id, first.id); + // A marker under another layer's card is that card's click too. h.pick('b'); click(); + assert.equal(h.lastCard()[0].id, first.id, 'a covered marker yields'); + painted = []; + click(); assert.equal(h.lastCard()[0].id, 'shipwreck-card:b'); painted = [{ sourceId: 'shipwrecks', entryId: 'shipwreck-card:b' }]; h.pick(null); diff --git a/src/layers/streetLevel/selection.js b/src/layers/streetLevel/selection.js index 9a7cfea8f5..409b0a9dce 100644 --- a/src/layers/streetLevel/selection.js +++ b/src/layers/streetLevel/selection.js @@ -23,29 +23,22 @@ export function createSelection({ state, parts }) { /** The id carries a provider's prefix: that provider handles the pick. */ function onClick(event) { if (!state.viewer || !state.enabled) return; + // Another layer's card or label painted on top takes the click, read once + // per click so every layer agrees: no image, sequence or ground under it + // opens. Street Level paints no cards of its own. + if (picking?.isUnderOtherCard?.(event)) return; const hit = event.windowHit(CLICK_PICK_WINDOW_PX, CLICK_PICK_WINDOW_PX); 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. + // window: an item of ours there is still 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. - // 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)) { - route = contactId ? parts.router.resolve(contactId) : null; - if (!route) return; - } - } - if (!route && contactId) route = parts.router.resolve(contactId); + const route = + parts.router.resolve(windowId) ?? + (contactId ? parts.router.resolve(contactId) : null); // Not ours: the ground handler decides whether it is the map itself. if (!route) { parts.openAtGround?.({ surface: hit.surface, ground: groundOf(event) }); @@ -92,12 +85,7 @@ 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, { - 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, - }); + picking?.registerPickOwner?.(STREET_LEVEL_LAYER_ID, parts.router.ownsPick); } function uninstall() { diff --git a/src/layers/streetLevel/selection.test.mjs b/src/layers/streetLevel/selection.test.mjs index db5304b8a0..f7647ec8e4 100644 --- a/src/layers/streetLevel/selection.test.mjs +++ b/src/layers/streetLevel/selection.test.mjs @@ -48,11 +48,13 @@ function harness({ ...sceneExtras, }, }; + // The card on top at a click, as the host answers the pick registry. + pickRegistry.setClickCardHitTest(services.overlayHit ?? null); const state = { viewer, enabled: true, clickSubscription: null, - services: { picking: null, input: null, ...services }, + services: { picking: pickRegistry, input: null, ...services }, providers: new Map([ [ 'mapillary', @@ -106,6 +108,7 @@ function harness({ return event; }, restore() { + pickRegistry.setClickCardHitTest(null); selection.uninstall(); globalThis.document = saved; }, @@ -315,26 +318,48 @@ test('an item found only in our window yields to a card painted over it', () => } }); -// 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) => { +// The map itself under another layer's card or label is that card's click: +// a ground click there must not also open the nearest street image. +test("a click on the map under another layer's card opens no ground image", () => { + let top = null; + const h = harness({ services: { overlayHit: () => top } }); + try { + h.click(); + assert.equal( + h.groundClicks.length, + 1, + 'open map: the ground handler decides', + ); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + h.click(); + assert.equal(h.groundClicks.length, 1, 'under a card: the card keeps it'); + assert.deepEqual(h.opened, []); + } finally { + h.restore(); + } +}); + +// A coarse tap's touch contact reaches farther than this window: on open map +// Street Level takes it; under another layer's card the card does. +test('a coarse touch contact beyond our window is ours to open, unless a card is on top', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { if (previous) globalThis.matchMedia = previous; else delete globalThis.matchMedia; }); + let top = { sourceId: 'earthquake-card', entryId: 'q' }; const h = harness({ - services: { - picking: pickRegistry, - overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), - }, + services: { picking: pickRegistry, overlayHit: () => top }, sceneExtras: { pick: () => null, drillPick: () => [{ id: 'mly:img:contact' }], }, }); try { + h.click(); + assert.deepEqual(h.opened, [], 'under a card: the card keeps it'); + top = null; h.click(); assert.deepEqual(h.opened, ['contact']); assert.equal(h.groundClicks.length, 0); @@ -343,22 +368,27 @@ test('a coarse touch contact beyond our window is ours to open', (t) => { } }); -// 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) => { +// The exact hit or the touch contact on our line part under another layer's +// card is that card's click; on open map it selects the sequence its part +// picks as. +test('an exact or contact hit on our line part acts only with no card on top', (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' }); + let top = { sourceId: 'earthquake-card', entryId: 'q' }; + const card = () => top; const exact = harness({ services: { overlayHit: card } }); try { exact.scene.under = part; exact.click(); + assert.deepEqual(exact.sequences.selects, [], 'under a card'); + top = null; + exact.click(); assert.deepEqual(exact.sequences.selects, ['abc'], 'mouse, exact part'); } finally { + top = { sourceId: 'earthquake-card', entryId: 'q' }; exact.restore(); } const previous = globalThis.matchMedia; @@ -375,6 +405,9 @@ test('an exact or contact hit on our line part acts under a card', (t) => { }, }); try { + contact.click(); + assert.deepEqual(contact.sequences.selects, [], 'coarse, under a card'); + top = null; contact.click(); assert.deepEqual(contact.sequences.selects, ['abc'], 'coarse contact'); } finally { @@ -383,7 +416,7 @@ test('an exact or contact hit on our line part acts under a card', (t) => { }); // Our window catching another layer's item says nothing about our own touch -// contact beyond it: that contact is still ours under a card. +// contact beyond it: that contact is still ours. test('a contact of ours acts even when our window finds another item', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); @@ -392,10 +425,7 @@ test('a contact of ours acts even when our window finds another item', (t) => { else delete globalThis.matchMedia; }); const h = harness({ - services: { - picking: pickRegistry, - overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), - }, + services: { picking: pickRegistry }, sceneExtras: { pick: (_position, width = 3) => width >= 9 ? { id: { set: 'flights:1', id: 'flight:9' } } : null, @@ -410,36 +440,18 @@ test('a contact of ours acts even when our window finds another item', (t) => { } }); -// 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(); - } -}); - -// 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) => { +// Under another layer's card nothing of ours opens, whatever our window or the +// tap's touch contact names; on open map our window's item opens. +test('under a card, neither our window item nor our touch contact opens', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { if (previous) globalThis.matchMedia = previous; else delete globalThis.matchMedia; }); + let top = { sourceId: 'earthquake-card', entryId: 'q' }; const h = harness({ - services: { - picking: pickRegistry, - overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), - }, + services: { picking: pickRegistry, overlayHit: () => top }, sceneExtras: { pick: (_position, width = 3) => width >= 9 ? { id: 'mly:img:window' } : null, @@ -448,8 +460,11 @@ test('under a card, the touch contact item is ours even when the window names an }); try { h.click(); - assert.deepEqual(h.opened, ['contact']); + assert.deepEqual(h.opened, []); assert.equal(h.groundClicks.length, 0); + top = null; + h.click(); + assert.deepEqual(h.opened, ['window']); } finally { h.restore(); } diff --git a/src/layers/submarineCables/index.js b/src/layers/submarineCables/index.js index de47082b0f..1f17a3d9de 100644 --- a/src/layers/submarineCables/index.js +++ b/src/layers/submarineCables/index.js @@ -24,7 +24,6 @@ export function createSubmarineCableLayer({ parts, source, inputFor, - overlayHost, picking, mapStackEventTarget, }; diff --git a/src/layers/submarineCables/interaction.js b/src/layers/submarineCables/interaction.js index 823020e16e..0ff20ddd7a 100644 --- a/src/layers/submarineCables/interaction.js +++ b/src/layers/submarineCables/interaction.js @@ -1,40 +1,18 @@ import { toRadians } from '../../geo/vector.js'; import { cameraOf } from '../../render/rendererOf.js'; -const CARD_BACKGROUND_ID = 'submarine-cables'; - -export function createInteraction({ - state, - parts, - inputFor, - overlayHost, - picking, -}) { +export function createInteraction({ state, parts, inputFor, picking }) { function beginInteraction(viewer) { if (state._clickSubscription) return; - // 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) => { + state._clickSubscription = 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; + // Cable labels are not interactive, so any card or label painted on + // top is another layer's, painted over the cable: its click. + if (picking?.clickCard?.(event)) 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 index 79282c02e8..44d9599610 100644 --- a/src/layers/submarineCables/interaction.test.mjs +++ b/src/layers/submarineCables/interaction.test.mjs @@ -25,6 +25,8 @@ function harness({ overlayTop = null } = {}) { }, }), overlayHost: { hitTest: () => top }, + // The card on top at a click, as the registry answers from the host. + picking: { clickCard: () => top }, }); interaction.beginInteraction({}); return { @@ -57,33 +59,3 @@ test('a card painted over a cable keeps its click; with none the cable reads the '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?.(); - } -}); diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index 49a3e7f17a..441f049bf7 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -44,6 +44,7 @@ import { uninstallRenderGovernor, } from '../../renderGovernor.js'; import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs'; import { bindRenderer, rendererOf } from '../../render/rendererOf.js'; @@ -3696,6 +3697,30 @@ test('click handler selects a migrated scripted billboard and prepares its drape assert.equal(entry.marker.show, true); }); +// The card or label painted on top takes the click: a vehicle under another +// layer's card is neither selected nor released. +test("another layer's card over a vehicle keeps the click", async (t) => { + const app = harness(t, { floorAt: () => undefined }); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + app.layer.enable(app.viewer); + app.layer._loadTransitFleetForTest(4, BOSTON, 70); + const [first, second] = app.vehicles(); + app.viewer.scene.pick = () => app.pickOf(first); + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, null, 'covered: not selected'); + top = null; + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, first.key); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + app.viewer.scene.pick = () => app.pickOf(second); + app.input.click(new Cesium.Cartesian2(500, 400)); + app.viewer.scene.pick = () => undefined; + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, first.key, 'covered: kept'); +}); + test('intercepted scripted reports resolve their explicit floor and wake without a preRender bootstrap', async (t) => { const app = harness(t, { floorAt: () => undefined }); app.layer._setTransitFixtureFloorsForTest(['mbta:sim-straight'], 20); diff --git a/src/layers/transit/selection.js b/src/layers/transit/selection.js index 9566272eef..75a1c2b744 100644 --- a/src/layers/transit/selection.js +++ b/src/layers/transit/selection.js @@ -7,6 +7,7 @@ import { } from './policy.js'; import { getRegisteredTransitFeed } from '../../data/transitFeeds.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { t } from '../../i18n/index.js'; /** @@ -151,6 +152,9 @@ export function createSelection({ state, services, parts }) { collection: set === 'moving' ? 'animated' : set === 'still' ? 'stationary' : null, }; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; if (key) { selectVehicle(key, { byUser: true }); return; diff --git a/src/layers/vessels/lifecycle.js b/src/layers/vessels/lifecycle.js index 5ebebd0970..c9c7d3e344 100644 --- a/src/layers/vessels/lifecycle.js +++ b/src/layers/vessels/lifecycle.js @@ -192,10 +192,8 @@ 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), - { expanded: true }, + registerPickOwner('ais-live-vessels', (pickedId) => + state.records.byId.has(pickedId), ); // 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 1aba2248b5..369054e3a8 100644 --- a/src/layers/vessels/selection.js +++ b/src/layers/vessels/selection.js @@ -10,8 +10,7 @@ export function createSelection({ options, }) { const { state } = vesselState; - const { isOwnedByOtherLayer, isActedOnByOtherLayer, resolvePickId } = - services.picking; + const { isOwnedByOtherLayer } = services.picking; const { requestWorldFocus } = services.worldFocus; const { selectEntityContext, @@ -31,8 +30,23 @@ export function createSelection({ // The bridge view owns the selection: a click on open water must not // deselect the vessel the camera is riding. if (state.cockpitSubjectId) return; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: a card of ours acts whatever is drawn + // under it; another layer's is that layer's click. + const top = services.picking.clickCard?.(event) ?? null; + if (top) { + if (top.sourceId !== VESSEL_OVERLAY_SOURCE_ID) return; + const id = String(top.entryId || '').startsWith('vessel:') + ? top.entryId.slice('vessel:'.length) + : null; + const carded = id ? state.records.byId.get(id) || null : null; + // A stale card id is not empty terrain and must not clear a newer + // selection. The next paint will evict its hit rectangle. + if (carded) selectAndFocusVessel(carded); + return; + } const pickedId = event.id; - let record = pickedId ? state.records.byId.get(pickedId) : null; + const record = pickedId ? state.records.byId.get(pickedId) : null; // A vessel icon's pick is an item of the layer's icon set, whose id is // its row id: the record's id, or an unkeyed row's. Removing a row // removes its item, so an evicted vessel cannot be picked at all; a @@ -45,76 +59,18 @@ export function createSelection({ // An own-layer row without a live map key is a strict no-op (FB-1 // residual). Trails carry no layer identity and hug their contacts, so any - // `gev-trail:*` pick is also a no-op. Every other non-vessel pick — sibling - // unowned scene picks dismiss the current vessel inspection. + // `gev-trail:*` pick is also a no-op. A pick a sibling layer owns (an + // aircraft, a route, a cyclone) is that layer's: preserve the current + // vessel selection and do not compete with its camera command. Every + // other non-vessel pick dismisses the current vessel inspection. if (ownRecordPick && (!pickedId || !record)) 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, { - click: event, - }))); - 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 = - !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) { - // 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, - click: event, - }); - 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 - // actionable hit rectangles before treating the click as empty space. - const cardHit = !record - ? vesselState._vesselOverlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ) - : null; if ( - (cardHit && cardHit.sourceId !== VESSEL_OVERLAY_SOURCE_ID) || - (cycloneBackground && !cardHit) + !record && + pickedId && + (String(pickedId).startsWith('gev-trail:') || + isOwnedByOtherLayer('ais-live-vessels', pickedId)) ) return; - if (!record && cardHit) { - const id = String(cardHit.entryId || '').startsWith('vessel:') - ? cardHit.entryId.slice('vessel:'.length) - : null; - record = id ? state.records.byId.get(id) || null : null; - // A stale card id is not empty terrain and must not clear a newer - // selection. The next paint will evict its hit rectangle. - if (!record) return; - } if (record) { // A valid sprite or card click always transfers the camera exactly once, diff --git a/src/layers/wildlifeSightings/ownership.test.mjs b/src/layers/wildlifeSightings/ownership.test.mjs index ebe4b75e58..46e5b13b9d 100644 --- a/src/layers/wildlifeSightings/ownership.test.mjs +++ b/src/layers/wildlifeSightings/ownership.test.mjs @@ -221,6 +221,8 @@ function harness( unregisterPickOwner: (id) => owners.delete(id), resolvePickId: (pick) => pick?.id ?? pick?.primitive?.id, isOwnedByOtherLayer: (_layerId, id) => id?.startsWith('other:'), + // The card on top at a click, as the registry answers from the host. + clickCard: () => cardHit, }, sprites: { spriteDrawOrder: () => -9 }, render: { governorRequestRender: (reason) => renders.push(reason) }, diff --git a/src/layers/wildlifeSightings/selection.js b/src/layers/wildlifeSightings/selection.js index 368497c539..5156d6035a 100644 --- a/src/layers/wildlifeSightings/selection.js +++ b/src/layers/wildlifeSightings/selection.js @@ -482,12 +482,13 @@ export function createSelection({ state, services, parts }) { state.clickHandler = input.onClick((click) => { if (!state.enabled || services.pointer?.isPointerFree?.() === false) return; - const at = click.screenPosition; - // 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?.(); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours acts whatever is drawn under it; + // another layer's is that layer's click, so the sightings under it do + // not act and the selection stays. + const hit = services.picking?.clickCard?.(click) ?? null; + if (hit) { + if (sourceIds.includes(hit.sourceId)) hit.entry?.activate?.(); return; } // A sighting icon's item id is its pick id, `wildlife:`. @@ -509,8 +510,6 @@ 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 f7da089369..ccd4c11ad0 100644 --- a/src/layers/wildlifeSightings/selection.test.mjs +++ b/src/layers/wildlifeSightings/selection.test.mjs @@ -43,20 +43,17 @@ function fixture(sighting = row, extraServices = {}) { }, }; bindWildlifeViewer(state.viewer); + const overlayHost = { + setEntries: (id, value) => entries.set(id, value), + clearSource: (id) => entries.delete(id), + setVisible() {}, + hitTest: (_x, _y, { sourceId } = {}) => + sourceId ? (hit?.sourceId === sourceId ? hit : null) : coveringHit || hit, + }; const selection = createSelection({ state, services: { - overlayHost: { - setEntries: (id, value) => entries.set(id, value), - clearSource: (id) => entries.delete(id), - setVisible() {}, - hitTest: (_x, _y, { sourceId } = {}) => - sourceId - ? hit?.sourceId === sourceId - ? hit - : null - : coveringHit || hit, - }, + overlayHost, now: () => row.observedAt + 60_000, project: (_scene, anchor) => { projections++; @@ -71,6 +68,12 @@ function fixture(sighting = row, extraServices = {}) { }), eventTarget: new EventTarget(), ...extraServices, + // The card on top at a click, as the registry answers from the host. + picking: { + clickCard: (c) => + overlayHost.hitTest(c.screenPosition?.x, c.screenPosition?.y), + ...extraServices.picking, + }, }, parts: { rendering: { @@ -187,7 +190,7 @@ 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', () => { +test('a covered sighting label and icon yield; 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). @@ -205,15 +208,16 @@ test('a covered sighting label yields; the top label acts over trails and other f.click(null); assert.equal(f.flights.length, 1); assert.equal(f.state.selectedRow, row); + // A sighting icon under another layer's card is that card's click too. f.click(); - assert.equal(f.flights.length, 2, 'an actual sighting remains selectable'); + assert.equal(f.flights.length, 1, 'a covered sighting does not act'); 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. + assert.equal(f.flights.length, 2, 'the label acts over a flight trail'); + // And over another layer's scene item. f.click('other:aircraft'); - assert.equal(f.flights.length, 4, 'the top label acts'); + assert.equal(f.flights.length, 3, 'the top label acts'); assert.equal(f.state.selectedRow, row); f.selection.remove(); }); diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js index bb0d2d33f1..31c31ec31f 100644 --- a/src/overlays/worldOverlay.js +++ b/src/overlays/worldOverlay.js @@ -1,4 +1,5 @@ import { WORLD_OVERLAY_OCCLUDER_SELECTORS } from './worldOverlayChrome.js'; +import { setClickCardHitTest } from '../data/pickRegistry.js'; export { WORLD_OVERLAY_OCCLUDER_SELECTORS } from './worldOverlayChrome.js'; import { createCyberSonarSampler, @@ -2869,6 +2870,8 @@ export function initWorldOverlay(viewer) { }; window.addEventListener('gev:cockpit-mode-changed', _cockpitModeHandler); _removePostRender = frame.on('postRender', () => drawWorldOverlay()); + // Click handlers read the card painted on top through the pick registry. + setClickCardHitTest(hitTestWorldOverlay); _removeMoveEnd = camera.on('moveEnd', () => invalidateHost()); installUiOccluderObservers(); // The backing store and the occluder inventory are both deferred to the @@ -2954,6 +2957,7 @@ export function destroyWorldOverlay() { _paintCount = 0; _paintRectCount = 0; _hitRectCount = 0; + setClickCardHitTest(null); _uiOcclusionRects.length = 0; _uiOcclusionRectPool.length = 0; _destroyed = hadHost || _destroyed; diff --git a/src/scenes/interactions.js b/src/scenes/interactions.js index a7c2d09eef..35d76b10bd 100644 --- a/src/scenes/interactions.js +++ b/src/scenes/interactions.js @@ -1,6 +1,7 @@ import { nextTick } from 'vue'; import { isPointerFree } from '../data/inputOwnership.js'; import { inputFor } from '../input/dispatcher.js'; +import { isUnderOtherCard } from '../data/pickRegistry.js'; import { createInteractionSession } from '../director/interactions/session.js'; import { t } from '../i18n/index.js'; import { useSceneInteractionsStore } from '../ui/stores/sceneInteractions.js'; @@ -119,6 +120,9 @@ export function createSceneInteractions( session.activate(items); unsubscribeClick = inputFor(viewer).onClick((event) => { if (panel?.owner !== owner || !shown() || !available()) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; // A pack feature is its draw set's item (see dataPacks/presentation.js). const hit = event.drawHit; if (!hit) return; diff --git a/src/scenes/interactionsView.test.mjs b/src/scenes/interactionsView.test.mjs index 04b1e18262..99cb576766 100644 --- a/src/scenes/interactionsView.test.mjs +++ b/src/scenes/interactionsView.test.mjs @@ -10,6 +10,8 @@ import { createPinia } from 'pinia'; import { useSceneInteractionsStore } from '../ui/stores/sceneInteractions.js'; import SceneInteractions from '../ui/views/panels/SceneInteractions.vue'; import { createSceneInteractions } from './interactions.js'; +import { fakeInput } from '../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../data/pickRegistry.js'; const target = (featureId) => ({ packId: 'qa', featureId }); const key = (featureId) => JSON.stringify(['qa', featureId]); @@ -192,3 +194,39 @@ test("an earlier owner leaves a later owner's panel alone", async (t) => { await settle(); assert.equal(later.getState().selected, 'fly'); }); + +// The card or label painted on top takes the click: a pack feature under +// another layer's card is not selected for its actions. +test("another layer's card over a pack feature keeps the click", async (t) => { + document.body.replaceChildren(); + const container = document.body.appendChild(document.createElement('div')); + const canvas = container.appendChild(document.createElement('canvas')); + const pinia = createPinia(); + const app = createApp(SceneInteractions).use(pinia); + app.mount(document.body.appendChild(document.createElement('div'))); + let picked = null; + const viewer = { container, scene: { canvas, pick: () => picked } }; + const input = fakeInput(viewer); + const store = useSceneInteractionsStore(pinia); + const interactions = createSceneInteractions(viewer, { + execute: async () => true, + store, + }); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => { + setClickCardHitTest(null); + interactions.destroy(); + input.destroy(); + app.unmount(); + }); + const feature = { set: 'qa:points', id: 'point' }; + interactions.activate(SHOT, new Map([[key('point'), feature]])); + await nextTick(); + picked = { id: feature, primitive: {} }; + input.tap({ x: 10, y: 10 }); + assert.deepEqual(store.panel?.outlined ?? [], [], 'covered: not selected'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.deepEqual(store.panel.outlined, ['card', 'fly']); +}); diff --git a/src/ui/applicationShell.js b/src/ui/applicationShell.js index 3546f38008..3577513e07 100644 --- a/src/ui/applicationShell.js +++ b/src/ui/applicationShell.js @@ -199,7 +199,6 @@ export class StyleManager extends ShellFacade { pinia: applicationPinia(), pickWorld: services.pickWorldFromScreen, regionalBrief: services.fetchRegionalBrief, - overlayHit: services.hitTestWorldOverlay, }); this.mapStackController = mapStackController; this.placeSearch = placeSearch; diff --git a/src/ui/cockpitOrbitalFocus.js b/src/ui/cockpitOrbitalFocus.js index 5b97c34838..a7790ab102 100644 --- a/src/ui/cockpitOrbitalFocus.js +++ b/src/ui/cockpitOrbitalFocus.js @@ -10,6 +10,7 @@ */ import { fromDegrees } from '../geo/ellipsoid.js'; import { inputFor } from '../input/dispatcher.js'; +import { isUnderOtherCard } from '../data/pickRegistry.js'; import { findQuery } from '../render/rendererOf.js'; import { clampOrbitalLook, easeLook } from '../cockpitLook.js'; import { ORBITAL_EARTH_RADIUS_M } from '../cockpitOrbital.js'; @@ -286,7 +287,12 @@ export function routeSceneClick() { // A viewer with no input (headless tools, partial stubs) has no clicks. return () => {}; } - return input.onClick((event) => this.onOrbitalClick(event?.position)); + return input.onClick((event) => { + // Another layer's card or label painted on top takes the click: the site + // under it does not focus, and the click does not end a held focus. + if (isUnderOtherCard(event)) return; + this.onOrbitalClick(event?.position); + }); } /** diff --git a/src/ui/cockpitOrbitalFocus.test.mjs b/src/ui/cockpitOrbitalFocus.test.mjs index 73cc3505c7..e32c6f0fac 100644 --- a/src/ui/cockpitOrbitalFocus.test.mjs +++ b/src/ui/cockpitOrbitalFocus.test.mjs @@ -30,6 +30,7 @@ import CockpitView from './views/CockpitView.vue'; import ContextView from './views/ContextView.vue'; import IntelHudView from './views/IntelHudView.vue'; import { claimPointer, releasePointer } from '../data/inputOwnership.js'; +import { setClickCardHitTest } from '../data/pickRegistry.js'; import { ORBITAL_FOCUS_EASE_TAU_MS } from '../cockpitOrbitalFocus.js'; import { ORBITAL_HOP_MS } from '../cockpitOrbitalSatellites.js'; @@ -635,6 +636,23 @@ test('a click a tool owns is left alone', async (t) => { assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id, 'kept while drawing'); }); +// The card or label painted on top takes the click: a site under another +// layer's card does not focus, and a click there does not end a held focus. +test('another layer\'s card over the orbital view keeps the click', async (t) => { + const scene = await inOrbit(t); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + scene.click(SITES.alpha.at); + assert.equal(scene.cockpit.orbital.focus ?? null, null, 'covered: no focus'); + top = null; + scene.click(SITES.alpha.at); + assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + scene.click(EMPTY_GROUND); + assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id, 'covered: kept'); +}); + test('a double-click on a site focuses it and keeps the orbital view', async (t) => { const scene = await inOrbit(t); const { cockpit, viewer, handler } = scene; diff --git a/src/ui/entityContextBridge.js b/src/ui/entityContextBridge.js index cb1906f233..5c145ea842 100644 --- a/src/ui/entityContextBridge.js +++ b/src/ui/entityContextBridge.js @@ -1,4 +1,5 @@ -import { cardKeepsClick, resolvePickedContext } from '../data/pickedContext.js'; +import { resolvePickedContext } from '../data/pickedContext.js'; +import { clickCard } from '../data/pickRegistry.js'; import { followedOf, onFollowChanged } from '../data/followed.js'; import { fromDegreesInto } from '../geo/ellipsoid.js'; import { inputFor } from '../input/dispatcher.js'; @@ -45,8 +46,6 @@ const FOLLOWABLE = new Set(['flights', 'military', 'satellites']); * to the point under the camera without it. * @param {(lat: number, lon: number) => Promise} [options.regionalBrief] * The app's regional brief service, for the weather and news Context shows. - * @param {(x: number, y: number) => object|null} [options.overlayHit] - * The overlay card under a screen point, if any (a vessel's, a fire's). * @returns {() => void} disconnects */ export function installEntityContext({ @@ -55,7 +54,6 @@ export function installEntityContext({ pinia, pickWorld, regionalBrief, - overlayHit, }) { const store = useEntityCardStore(pinia); const omnibar = useOmnibarStore(pinia); @@ -311,16 +309,14 @@ export function installEntityContext({ // Cockpit has its own picks, and Context is hidden while it runs. A // camera drag never selects, even if it ends over something. if (inCockpit() || !isTrackingSelectionGesture(event.gesture)) return; + // A card or label painted on top is its layer's click, read once per + // click so every layer agrees: Context names nothing under it and keeps + // its own card as it is. + if (clickCard(event)) return; const identity = resolvePickedContext(event.hit, { 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). @@ -330,14 +326,8 @@ export function installEntityContext({ // A click on open ground, sea or sky lets go of what was selected. A // click on something else Context cannot describe (a label, a trail) // leaves the card as it is. - // Only a clean click lets go, as the layers' own clicks do; a card - // painted on the overlay (a vessel's, a fire's) is not open map. - if ( - event.surface && - isTrackingClickGesture(event.gesture) && - !overlayHit?.(event.screenPosition?.x, event.screenPosition?.y) - ) - store.clear(); + // Only a clean click lets go, as the layers' own clicks do. + if (event.surface && isTrackingClickGesture(event.gesture)) store.clear(); }); // Layers that select through the context store (GeoJSON sites, fires, diff --git a/src/ui/entityContextBridge.test.mjs b/src/ui/entityContextBridge.test.mjs index 541350bd5a..025b23df57 100644 --- a/src/ui/entityContextBridge.test.mjs +++ b/src/ui/entityContextBridge.test.mjs @@ -6,14 +6,14 @@ import { useEntityCardStore } from './stores/entityCard.js'; import { fakeInput } from '../input/testDoubles.mjs'; import { registerPickOwner, + setClickCardHitTest, 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) => { +// The card or label painted on top takes the click: Context names nothing +// under it, exact or nearby, an acting owner's item or a passive one, and +// keeps its own card. On open map it names what the click found. +test('Context names nothing under a card painted on top, and keeps its card', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -21,17 +21,31 @@ test('Context leaves a near-missed exact-only item to a card painted over it', ( else delete globalThis.matchMedia; }); const fire = { set: 'test-fires:1', id: 'fire:1' }; + const plane = { set: 'test-planes:1', id: 'plane:1' }; + const route = { set: 'test-route:1', id: 'route:line' }; registerPickOwner('test-fires', (id) => id === fire.id); - t.after(() => unregisterPickOwner('test-fires')); - let exact = false; + registerPickOwner('test-planes', (id) => id === plane.id); + registerPickOwner('test-route', (id) => id.startsWith('route:')); + let cardOnTop = false; + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest(() => + cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, + ); + t.after(() => { + setClickCardHitTest(null); + unregisterPickOwner('test-fires'); + unregisterPickOwner('test-planes'); + unregisterPickOwner('test-route'); + }); + let exact = null; + let near = null; const viewer = { scene: { - pick: () => (exact ? { id: fire } : null), - drillPick: () => [{ id: fire }], + pick: () => (exact ? { id: exact } : null), + drillPick: () => (near ? [{ id: near }] : []), }, }; const input = fakeInput(viewer); - let cardOnTop = false; const pinia = createPinia(); const disconnect = installEntityContext({ viewer, @@ -41,8 +55,6 @@ test('Context leaves a near-missed exact-only item to a card painted over it', ( getAll: () => [], }), pinia, - overlayHit: () => - cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, }); t.after(() => { disconnect(); @@ -50,52 +62,24 @@ test('Context leaves a near-missed exact-only item to a card painted over it', ( }); const store = useEntityCardStore(pinia); const named = []; + let clears = 0; store.select = (identity) => named.push(identity.id); - const tap = () => { + store.clear = () => clears++; + const tap = (hitExact, hitNear) => { + exact = hitExact; + near = hitNear; named.length = 0; input.click(); return [...named]; }; - assert.deepEqual(tap(), ['fire:1'], 'open map: Context names the fire'); + assert.deepEqual(tap(null, fire), ['fire:1'], 'open map: a near fire'); + assert.deepEqual(tap(route, null), ['route:line'], 'open map: a route'); 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'); + assert.deepEqual(tap(null, fire), [], 'under a card: a near fire'); + assert.deepEqual(tap(fire, fire), [], 'under a card: an exact fire'); + assert.deepEqual(tap(plane, plane), [], 'under a card: an aircraft'); + assert.deepEqual(tap(route, null), [], 'under a card: a route'); + const cleared = clears; + tap(null, null); + assert.equal(clears, cleared, 'a card over open map is not open map'); }); diff --git a/src/ui/wildlifeSightingCard.test.mjs b/src/ui/wildlifeSightingCard.test.mjs index 96f9d06c33..e38a6c4852 100644 --- a/src/ui/wildlifeSightingCard.test.mjs +++ b/src/ui/wildlifeSightingCard.test.mjs @@ -140,6 +140,8 @@ function fixture( }, }), focus: { requestWorldFocus: (value) => flights.push(value) }, + // The card on top at a click, as the registry answers from the host. + picking: { clickCard: () => hit }, }, parts: { rendering: { refreshSelection() {}, requestRender() {} }, diff --git a/src/voice/analystAccessors.test.mjs b/src/voice/analystAccessors.test.mjs index 05d9cd9735..ff50cba6cb 100644 --- a/src/voice/analystAccessors.test.mjs +++ b/src/voice/analystAccessors.test.mjs @@ -194,7 +194,6 @@ test('cyclones flatten the storm position and stay empty while off', async () => ownsPickId: () => false, getDiagnostics: () => ({}), }), - hitTestOverlay: () => null, }); const viewer = { scene: { canvas: new EventTarget(), pick: () => null },