Merge main through #1591 into the renderer seam

Brings in the wildlife sightings layer (#1591, iNaturalist and Acartia
sightings). Its badges, density glow and privacy cells draw through the
draw port: the badges and the glow are icons sets (iconCollection.js
batches point writes into one upsert per task), and the privacy cells are
ground-clamped shapes and lines sets swapped whole. The eye, the view
rectangle, clicks, projection, ground readiness and frames come from the
camera, query, input, globe and frame ports, so the layer, its card and
its placement no longer import Cesium.

Differences from main: the density glow is drawn as pixel-sized splats
(56 px) instead of metre-sized ones with a near fade; the card's pan eases
with cubicOut, the contract's nearest ease-out; ground heights are
resampled when the globe's load progress settles or its surface changes,
rather than on tileset load events.

Also fixes two things the last merge left: a double-click that starts on
the followed track and ends off it reaches the renderer's own follow again
(a press that cannot end a double-click on the track gives its hold back
at its release), and the Active Fires heat drapes under the weather
imagery, so weather turned on after it stacks above. CURRENT-STATE notes
that the 2D and Columbus scene-mode checks are gone.
This commit is contained in:
Sameh Khamis committed 2026-11-09 23:06:26 -08:00
commit 020a433b51
129 files changed
+22143 -336

No files matched your search

+793
View File
@@ -0,0 +1,793 @@
import '../testSupport/registerDom.mjs';
import assert from 'node:assert/strict';
import test from 'node:test';
import { fromDegrees, toLonLatH } from '../geo/ellipsoid.js';
import { bindWildlifeViewer } from '../testSupport/wildlifeViewer.mjs';
import { nextTick } from 'vue';
import { readFileSync } from 'node:fs';
import { getLocale, setLocale, t } from '../i18n/index.js';
import { LOCALES } from '../i18n/locale.js';
import { createSelection } from '../layers/wildlifeSightings/selection.js';
import { buildWildlifeThumbnailEntry } from '../layers/wildlifeSightings/cards.js';
import { createWildlifeSightingCard } from './wildlifeSightingCard.js';
import {
panWildlifeSighting,
placeWildlifeSightingCard,
readWildlifeCardSafeArea,
} from './wildlifeSightingPlacement.js';
import { createUiRuntime } from './vueRuntime.js';
import { PANEL_RAIL_ITEMS } from './panelRailCatalog.js';
import { sheetForPanelId } from './mobileShell.js';
const NOW = Date.parse('2026-11-04T13:00:00Z');
const square =
'https://inaturalist-open-data.s3.amazonaws.com/photos/456/square.jpg';
const row = {
stableId: 'inat:456',
origin: 'inaturalist',
lat: 0,
lon: 0,
commonName: 'Synthetic bird',
scientificName: 'Avis imaginaria',
iconic: 'Aves',
observedAt: NOW - 3_600_000,
observedOn: '2026-11-04',
obscured: false,
photo: {
square,
attribution: '(c) Synthetic Photographer, some rights reserved (CC BY-SA)',
licence: 'cc-by-sa',
},
link: 'https://www.inaturalist.org/observations/456',
};
const rect = (left, top, width, height) => ({
left,
top,
width,
height,
right: left + width,
bottom: top + height,
});
const events = () => {
const listeners = new Set();
return {
addEventListener(fn) {
listeners.add(fn);
return () => listeners.delete(fn);
},
emit() {
for (const fn of listeners) fn();
},
size: () => listeners.size,
};
};
const settle = async () => {
await nextTick();
await Promise.resolve();
await nextTick();
};
// All scene rows, media events and rectangles are synthetic. Browser image
// requests are disabled; decode resolution below proves the photo is exposed
// only after it has loaded into the compact card.
function fixture(
context,
initialRow = row,
point = { x: 600, y: 450 },
extraWindow = {},
) {
document.body.replaceChildren();
const opener = document.body.appendChild(document.createElement('button'));
opener.textContent = 'Globe';
opener.focus();
const canvas = document.body.appendChild(document.createElement('canvas'));
canvas.getBoundingClientRect = () => rect(0, 0, 1200, 900);
const windowRef = {
innerWidth: 1200,
innerHeight: 900,
getComputedStyle: window.getComputedStyle.bind(window),
addEventListener() {},
removeEventListener() {},
matchMedia: () => ({ matches: false }),
...extraWindow,
};
const ui = createUiRuntime();
const overlays = new Map();
const moveStart = events();
const moveEnd = events();
const changed = events();
const preRender = events();
const viewer = {
scene: { canvas, preRender },
camera: { moveStart, moveEnd, changed },
};
bindWildlifeViewer(viewer);
const state = {
enabled: true,
destroyed: false,
selectedId: null,
selectedRow: null,
ambientRows: [],
rowById: new Map([[initialRow.stableId, initialRow]]),
positions: new Map([[initialRow.stableId, { x: 1, y: 2, z: 3 }]]),
contextIds: new Set(),
viewer,
};
let picked;
let hit = null;
let onClick;
let clears = 0;
let staleListener;
const subscriptions = new Set();
const flights = [];
const pans = [];
const selection = createSelection({
state,
services: {
now: () => NOW,
overlayHost: {
setEntries: (id, entries) => overlays.set(id, entries),
hitTest: (_x, _y, { sourceId }) =>
hit?.sourceId === sourceId ? hit : null,
},
input: () => ({
onClick(fn) {
onClick = fn;
return () => (onClick = null);
},
}),
focus: { requestWorldFocus: (value) => flights.push(value) },
},
parts: {
rendering: { refreshSelection() {}, requestRender() {} },
},
});
const layer = {
getParams: () => ({ taxa: 'all' }),
subscribeSelection(listener) {
staleListener = listener;
subscriptions.add(listener);
const off = selection.subscribe(listener);
return () => {
subscriptions.delete(listener);
off();
};
},
clearSightingSelection() {
clears++;
selection.clearAndRebuild();
},
};
let currentPoint = point;
let projections = 0;
const card = createWildlifeSightingCard({
layer,
ui,
viewer,
documentRef: document,
windowRef,
now: () => NOW,
project: () => {
projections++;
return currentPoint;
},
pan: (_viewer, from, to, reduced) => {
pans.push({ from, to, reduced });
currentPoint = to;
return true;
},
});
selection.install();
context.after(() => {
card.destroy();
selection.destroy();
ui.destroy();
});
return {
state,
selection,
layer,
card,
viewer,
windowRef,
overlays,
flights,
pans,
projections: () => projections,
subscriptions,
opener,
canvas,
moveStart,
moveEnd,
preRender,
cardElement: () => document.querySelector('[data-wildlife-sighting-card]'),
host: () => document.querySelector('[data-wildlife-sighting-card-host]'),
staleListener: () => staleListener,
clears: () => clears,
async click(kind = 'dot', target = initialRow) {
// Dots and icons alike are picked by their item id.
picked = `wildlife:${target.stableId}`;
hit =
kind === 'ambient photo card'
? {
sourceId: 'wildlife-sightings',
entry: buildWildlifeThumbnailEntry(target, NOW, {
select: selection.selectAndFocus,
}),
}
: null;
onClick({ screenPosition: { x: 50, y: 50 }, id: picked });
await settle();
},
async publish(next) {
if (next) {
state.rowById.set(next.stableId, next);
if (state.selectedId === next.stableId) state.selectedRow = next;
}
selection.notify();
await settle();
},
obstacle(selector, bounds) {
const element = document.body.appendChild(document.createElement('div'));
if (selector.startsWith('#')) element.id = selector.slice(1);
else element.className = selector.slice(1);
element.getBoundingClientRect = () => bounds;
return element;
},
setPoint(next) {
currentPoint = next;
},
};
}
test('dot, icon and ambient photo clicks open one contained medium-photo card at the sighting', async (context) => {
for (const kind of ['dot', 'icon', 'ambient photo card'])
await context.test(kind, async (context) => {
const f = fixture(context);
await f.click(kind);
const card = f.cardElement();
const image = card.querySelector('img');
assert.equal(f.state.selectedId, row.stableId);
assert.equal(
document.querySelector('dialog'),
null,
'there is no fullscreen or modal dialog',
);
assert.equal(image.src, square.replace('/square.', '/medium.'));
assert.equal(image.referrerPolicy, 'no-referrer');
assert.equal(card.querySelector('h2').textContent, row.commonName);
assert.equal(card.querySelector('i').textContent, row.scientificName);
assert.equal(card.querySelector('time').textContent, 'observed 1h ago');
assert.ok(
card.textContent.includes('© Synthetic Photographer · CC BY-SA'),
);
const link = card.querySelector('a');
assert.equal(link.href, row.link);
assert.equal(link.target, '_blank');
assert.equal(link.rel, 'noopener noreferrer');
assert.equal(
link.getAttribute('aria-label'),
`Open ${row.commonName} on iNaturalist`,
);
assert.equal(
link.querySelector('.wildlife-sighting-card-source').textContent,
'iNaturalist ↗',
);
assert.ok(
link.contains(image),
'the photograph and text are one external action',
);
assert.equal(f.flights.length, 1);
assert.equal(f.flights[0].kind, 'sighting');
assert.deepEqual(
f.flights[0].position,
f.state.positions.get(row.stableId),
);
assert.equal(f.pans.length, 0);
assert.equal(
f.preRender.size(),
0,
'an idle card installs no frame work',
);
let decoded;
image.decode = () =>
new Promise((resolve) => {
decoded = resolve;
});
image.dispatchEvent(new Event('load'));
await settle();
assert.equal(
image.classList.contains('loaded'),
false,
'a request alone does not expose an empty frame',
);
decoded();
await settle();
assert.equal(
image.classList.contains('loaded'),
true,
'the loaded medium photo is painted inside the card',
);
assert.equal(card.querySelector('[role=status]'), null);
const style = readFileSync(
new URL('./views/panels/WildlifeSightingCard.vue', import.meta.url),
'utf8',
);
assert.match(style, /object-fit: contain/);
assert.match(style, /height: 180px/);
});
});
test('missing, restricted, obscured and Acartia photos all use the same compact text card', async (context) => {
for (const [label, extra] of [
['missing', { photo: null }],
['restricted', { photo: { ...row.photo, licence: 'cc-by-nd' } }],
[
'untrusted',
{ photo: { ...row.photo, square: 'https://other.example/square.jpg' } },
],
['uncredited', { photo: { ...row.photo, attribution: '' } }],
['obscured', { obscured: true }],
[
'Acartia',
{
origin: 'acartia',
stableId: 'acartia:456',
provider: { name: 'Synthetic network' },
link: 'https://acartia.io',
},
],
])
await context.test(label, async (context) => {
const f = fixture(context, { ...row, ...extra });
await f.click();
const card = f.cardElement();
assert.equal(card.querySelector('img'), null);
assert.equal(card.querySelector('[role=status]'), null);
assert.equal(card.querySelector('h2').textContent, row.commonName);
assert.equal(card.querySelector('i').textContent, row.scientificName);
assert.equal(document.querySelector('dialog'), null);
if (extra.obscured) {
assert.doesNotMatch(card.textContent, /ago|Photographer/);
assert.ok(
card.textContent.includes('Location obscured to a 0.2° cell'),
);
assert.equal(
card.querySelector('time').getAttribute('datetime'),
row.observedOn,
);
}
if (extra.origin === 'acartia') {
assert.ok(card.textContent.includes('seen 1h ago'));
assert.ok(card.textContent.includes('Reported by Synthetic network'));
assert.ok(
card.textContent.includes('Acartia · CC BY 4.0 · Salish Sea'),
);
assert.ok(card.querySelector('a[href="https://www.bewhalewise.org"]'));
assert.equal(
card.querySelector('a').getAttribute('aria-label'),
`Open ${row.commonName} on Acartia`,
);
}
});
});
test('an Acartia card labels only the Acartia site as Acartia', async (context) => {
for (const link of [
'https://provider.example/photos/synthetic.jpg',
'https://acartia.io.attacker.example/',
'https://acartia.io/',
])
await context.test(link, async (context) => {
const f = fixture(context, {
...row,
origin: 'acartia',
stableId: 'acartia:456',
provider: { name: 'Synthetic network' },
link,
});
await f.click();
const card = f.cardElement();
const hrefs = [...card.querySelectorAll('a')].map((a) =>
a.getAttribute('href'),
);
assert.deepEqual(hrefs, [
'https://acartia.io/',
'https://www.bewhalewise.org',
]);
assert.equal(
card.querySelector('.wildlife-sighting-card-source').textContent,
'Acartia ↗',
);
});
});
test('safe placements near each viewport edge exclude actual HUD, toolbar and rail rects', () => {
const obstacles = [
rect(0, 0, 260, 160),
rect(450, 0, 300, 80),
rect(1050, 200, 150, 500),
rect(0, 760, 300, 140),
];
const safe = { bounds: rect(6, 6, 1188, 888), obstacles };
for (const point of [
{ x: 7, y: 450 },
{ x: 1193, y: 750 },
{ x: 850, y: 7 },
{ x: 600, y: 893 },
]) {
const result = placeWildlifeSightingCard(
point,
{ width: 258, height: 300 },
safe,
);
assert.ok(result);
assert.deepEqual(result.pan, { x: 0, y: 0 });
assert.ok(
result.left >= safe.bounds.left && result.right <= safe.bounds.right,
);
assert.ok(
result.top >= safe.bounds.top && result.bottom <= safe.bounds.bottom,
);
assert.ok(
obstacles.every(
(r) =>
!(
result.left < r.right &&
result.right > r.left &&
result.top < r.bottom &&
result.bottom > r.top
),
),
);
}
});
test('a selected dot flies to its true position and its card pans clear of chrome', async (context) => {
const f = fixture(context, row, { x: 100, y: 100 });
const hud = f.obstacle('.hud-top-left', rect(0, 0, 260, 160));
f.obstacle('#right-context-rail', rect(1040, 200, 160, 700));
f.windowRef.matchMedia = () => ({ matches: true });
await f.click();
assert.equal(f.pans.length, 1);
assert.equal(f.pans[0].reduced, true);
assert.deepEqual(
f.pans[0].to,
{ x: 100, y: 178 },
'nearest clear point follows the measured HUD bottom',
);
const safe = readWildlifeCardSafeArea({
documentRef: document,
viewer: f.viewer,
windowRef: f.windowRef,
});
assert.equal(
safe.obstacles[0].bottom,
hud.getBoundingClientRect().bottom + 6,
);
assert.equal(f.flights.length, 1);
assert.deepEqual(f.flights[0].position, f.state.positions.get(row.stableId));
f.moveEnd.emit();
await settle();
assert.equal(f.pans.length, 1);
f.layer.clearSightingSelection();
await settle();
f.setPoint({ x: -20, y: 400 });
await f.click();
assert.equal(f.pans.length, 2);
assert.deepEqual(f.pans[1].to, { x: 18, y: 400 });
});
test('the camera correction preserves altitude and orientation and honors reduced motion', () => {
const flights = [];
const camera = {
positionWC: fromDegrees(0, 0, 250_000),
positionCartographic: { height: 250_000 },
heading: 0.2,
pitch: -1.2,
roll: 0.1,
flyTo: (value) => flights.push(value),
};
const viewer = {
camera,
scene: {
canvas: { getBoundingClientRect: () => rect(0, 0, 1200, 900) },
},
};
bindWildlifeViewer(viewer, {
query: { pickEllipsoid: (x, y) => fromDegrees(x / 100, y / 100) },
});
for (const reduced of [false, true]) {
assert.equal(
panWildlifeSighting(viewer, { x: 10, y: 10 }, { x: 30, y: 50 }, reduced),
true,
);
const flight = flights.at(-1);
assert.ok(Math.abs(toLonLatH(flight.destination).height - 250_000) < 0.001);
assert.deepEqual(flight.orientation, {
heading: 0.2,
pitch: -1.2,
roll: 0.1,
});
assert.equal(flight.duration, reduced ? 0 : 0.22);
}
});
test('the browser click that follows a globe selection does not close the card it opened', async (context) => {
const f = fixture(context);
await f.click();
assert.ok(f.cardElement(), 'the globe click opened the card');
assert.equal(
document.activeElement,
f.cardElement(),
'focus lands on the card, not as a ring on its close button',
);
// Cesium selects on pointer-up; the DOM click event lands on the canvas
// afterwards and must not count as an outside click.
f.canvas.dispatchEvent(new MouseEvent('click', { bubbles: true }));
await settle();
assert.ok(f.cardElement(), 'the card stays open');
assert.equal(f.clears(), 0);
document.body.click();
await settle();
assert.equal(f.cardElement(), null, 'a real outside click still closes it');
});
test('one card at a time, Escape, outside clicks and close all clear the selection', async (context) => {
const f = fixture(context);
await f.click();
const second = {
...row,
stableId: 'inat:789',
commonName: 'Another synthetic bird',
};
f.state.rowById.set(second.stableId, second);
await f.click('dot', second);
assert.equal(
document.querySelectorAll('[data-wildlife-sighting-card]').length,
1,
);
assert.equal(
f.cardElement().querySelector('h2').textContent,
second.commonName,
);
for (const close of ['Escape', 'outside', 'button']) {
if (close === 'Escape')
document.dispatchEvent(
new KeyboardEvent('keydown', {
key: 'Escape',
bubbles: true,
cancelable: true,
}),
);
if (close === 'outside') document.body.click();
if (close === 'button') f.cardElement().querySelector('button').click();
await settle();
assert.equal(f.cardElement(), null);
assert.equal(f.state.selectedId, null);
assert.deepEqual(f.overlays.get('wildlife-sightings-selected'), []);
assert.equal(document.activeElement, f.opener);
await f.click();
}
assert.equal(f.clears(), 3);
});
test('camera movement repositions the same card and removes frame work at rest', async (context) => {
const f = fixture(context);
await f.click();
const card = f.cardElement();
const before = f.host().style.left;
f.moveStart.emit();
assert.equal(f.preRender.size(), 1);
f.setPoint({ x: 800, y: 450 });
f.preRender.emit();
assert.equal(f.cardElement(), card);
assert.notEqual(f.host().style.left, before);
f.moveEnd.emit();
assert.equal(f.preRender.size(), 0);
await f.publish({ ...row, commonName: 'Updated synthetic bird' });
assert.equal(f.cardElement(), card);
assert.equal(card.querySelector('h2').textContent, 'Updated synthetic bird');
f.state.rowById.delete(row.stableId);
await f.publish(null);
assert.equal(
f.cardElement(),
card,
'a refreshed sample cannot close the selected card',
);
f.layer.clearSightingSelection();
await settle();
assert.equal(f.cardElement(), null);
});
test('replacement photo loads cannot expose the previous image and failures retain the text card', async (context) => {
const f = fixture(context);
await f.click();
const previous = f.cardElement().querySelector('img');
let decoded;
previous.decode = () =>
new Promise((resolve) => {
decoded = resolve;
});
previous.dispatchEvent(new Event('load'));
await f.publish({
...row,
photo: { ...row.photo, square: square.replace('/456/', '/789/') },
});
const current = f.cardElement().querySelector('img');
decoded();
await settle();
assert.equal(current.classList.contains('loaded'), false);
current.dispatchEvent(new Event('error'));
await settle();
assert.equal(
f.cardElement().querySelector('[role=status]').textContent,
'Photo unavailable',
);
assert.equal(current.style.display, 'none');
assert.equal(f.cardElement().querySelector('a').href, row.link);
});
test('teardown removes subscriptions, placement listeners and host, and ignores stale notifications', async (context) => {
const f = fixture(context);
await f.click();
f.moveStart.emit();
const stale = f.staleListener();
f.card.destroy();
assert.equal(f.cardElement(), null);
assert.equal(f.host(), null);
assert.equal(f.subscriptions.size, 0);
assert.equal(f.preRender.size(), 0);
stale(row);
await f.click();
assert.equal(f.cardElement(), null);
assert.equal(document.activeElement, f.opener);
});
test('locale changes translate the card without replacing the image or credit', async (context) => {
const before = getLocale();
context.after(() => setLocale(before));
const f = fixture(context);
await f.click();
const card = f.cardElement();
const image = card.querySelector('img');
for (const locale of LOCALES) {
setLocale(locale);
await settle();
assert.equal(f.cardElement(), card);
assert.equal(card.querySelector('img'), image);
assert.equal(
card.querySelector('button').getAttribute('aria-label'),
t('Close sighting'),
);
assert.ok(card.textContent.includes('© Synthetic Photographer · CC BY-SA'));
}
});
test('date-only and unsafe-link rows remain readable, and no sighting rail or lightbox is shipped', async (context) => {
const f = fixture(context, {
...row,
observedAt: null,
photo: null,
link: 'javascript:alert(1)',
});
await f.click();
assert.equal(f.cardElement().querySelector('a'), null);
assert.equal(
f.cardElement().querySelector('time').getAttribute('datetime'),
row.observedOn,
);
assert.equal(PANEL_RAIL_ITEMS['wildlife-sighting-panel'], undefined);
assert.equal(sheetForPanelId('wildlife-sighting-panel'), null);
const source = readFileSync(
new URL('./wildlifeSightingCard.js', import.meta.url),
'utf8',
);
assert.doesNotMatch(
source,
/Lightbox|showModal|requestAnimationFrame|setInterval/,
);
});
test('WHALES cards retain compact whale guidance outside the observation action', async (context) => {
const f = fixture(context);
f.layer.getParams = () => ({ taxa: 'whales' });
await f.click();
const guidance = f
.cardElement()
.querySelector('a[href="https://www.bewhalewise.org"]');
assert.equal(guidance.textContent, 'Be Whale Wise');
assert.equal(
guidance.parentElement.closest('a'),
null,
'the external guidance link never nests inside the observation action',
);
});
test('opening during camera motion tracks the card and closing stops frame work immediately', async (context) => {
const f = fixture(context);
f.moveStart.emit();
assert.equal(f.preRender.size(), 0);
await f.click();
assert.equal(f.preRender.size(), 1);
f.layer.clearSightingSelection();
await settle();
assert.equal(f.preRender.size(), 0);
});
test('newly mounted chrome repositions the open card without camera events or idle text work', async (context) => {
const observers = [];
class MutationObserver {
constructor(callback) {
this.callback = callback;
this.targets = [];
observers.push(this);
}
observe(target, options) {
this.targets.push({ target, options });
}
disconnect() {
this.targets = [];
}
}
const f = fixture(context, row, { x: 600, y: 450 }, { MutationObserver });
await f.click();
const structural = observers.find((observer) =>
observer.targets.some(
({ target, options }) =>
target === document.body && options.childList && options.subtree,
),
);
assert.ok(
structural,
'structural observation exists only while a card is open',
);
const original = f.cardElement();
const before = f.host().style.top;
const hudWrapper = document.body.appendChild(document.createElement('div'));
const hud = hudWrapper.appendChild(document.createElement('div'));
hud.className = 'hud-top-left';
hud.getBoundingClientRect = () => rect(500, 350, 200, 200);
structural.callback([{ addedNodes: [hudWrapper], removedNodes: [] }]);
await settle();
assert.equal(
f.pans.length,
1,
'chrome newly covering the dot triggers one minimal pan',
);
assert.equal(f.cardElement(), original);
assert.notEqual(f.host().style.top, before);
assert.equal(f.preRender.size(), 0);
const placed = rect(
Number.parseFloat(f.host().style.left),
Number.parseFloat(f.host().style.top),
258,
300,
);
assert.ok(
placed.right <= 494 ||
placed.left >= 706 ||
placed.bottom <= 344 ||
placed.top >= 556,
'the card clears the measured HUD rect',
);
const afterChrome = f.projections();
// The observer ignores text nodes, ordinary clock wrappers and the card's
// own image/caption patches even though body observation sees their records.
const clock = hud.appendChild(document.createElement('span'));
const text = clock.appendChild(document.createTextNode('13:00:01'));
structural.callback([
{
addedNodes: [clock, text, f.cardElement().querySelector('img')],
removedNodes: [],
},
]);
assert.equal(f.projections(), afterChrome);
f.layer.clearSightingSelection();
await settle();
assert.equal(
structural.targets.length,
0,
'closing disconnects structural observation',
);
});