Files
gods-eye-view/src/ui/wildlifeSightingCard.test.mjs
T
German Khokhlov 35e70ec280 Draw the aircraft family, Wildlife Sightings and the Cockpit through the contract
The layers that still had one Cesium and one Navara implementation, or
drew on Cesium only, now draw through engine.movers, engine.lines and
engine.camera on both engines, and application code holds the engine
instead of guessing it from a viewer.

- Aircraft family: flights, military and local ADS-B share one display
  (src/layers/aircraft/render/display.js). The Cesium and Navara
  renderers are gone. Where they differed, the display follows Cesium:
  - attach and visibility tracking, live disableDepthTestDistance
    changes, the tracked glyph's distance scale, model ids that change,
    local ADS-B markers hidden until shown and its UAT ring as a point;
  - the trail head's hidden alpha is 0.45, the contract's
    depthFailAlpha scaled by the head's 0.9.
  The tracked glyph stays over the fleet, as on Navara. The movers
  contract reports readiness per model and reads model axes as the
  glTF's own on every engine. Cesium's follow takes any native target
  through a proxy entity in the ENU frame and mirrors its readout fields.
- Wildlife Sightings draws badges and the density glow as sprite sets
  and its privacy cells as line outlines (no fill yet). It takes clicks
  from engine.input and its card anchors to the engine's canvas and
  camera, so the layer is in both engines' catalogs again and a switch
  keeps the session's layer set.
- Cockpit: cockpitHost takes the engine only. The ridden aircraft is the
  engine follow's target, hidden through its sprite; only the Cesium
  Viewer's stock double-click is still routed around.
- About forty camera, navigation, share-link, HUD, voice, detection and
  layer-lifecycle callers take the engine. isGlobeEngine and
  engineFromViewer calls outside src/globe fall from 51 to 14.

The coupling baseline drops accordingly: layer renderer lines from
5239/12331 to 4546/11106 (Cesium/Navara), `viewer` lines from 2424 to
2209, Cesium-importing files from 69 to 66.
2026-11-07 02:34:34 +04:00

811 lines
25 KiB
JavaScript

import '../testSupport/registerDom.mjs';
import assert from 'node:assert/strict';
import test from 'node:test';
import { nextTick } from 'vue';
import * as geo from '../geo/index.js';
import { createFakeEngine } from '../globe/testing/fakeEngine.js';
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,
projectWildlifeSighting,
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 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 engine = createFakeEngine({ width: 1200, height: 900, canvas });
engine.fake.script('pick', () => picked ?? undefined);
const raise = (name) => ({ emit: () => engine.fake.emit(name) });
const moveStart = raise('camera.moveStart');
const moveEnd = raise('camera.moveEnd');
const preRender = {
...raise('frames.preRender'),
size: () => engine.frames.preRender.numberOfListeners,
};
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(),
engine,
};
let picked = null;
let hit = null;
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,
},
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,
engine,
documentRef: document,
windowRef,
now: () => NOW,
project: () => {
projections++;
return currentPoint;
},
pan: (_engine, 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,
engine,
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) {
// An icon pick names the badge's mover set and instance as well.
picked =
kind === 'icon'
? {
id: `wildlife:${target.stableId}`,
owner: 'wildlife-sightings',
instance: 0,
}
: { id: `wildlife:${target.stableId}` };
hit =
kind === 'ambient photo card'
? {
sourceId: 'wildlife-sightings',
entry: buildWildlifeThumbnailEntry(target, NOW, {
select: selection.selectAndFocus,
}),
}
: null;
engine.fake.input('click', { position: { x: 50, y: 50 } });
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,
engine: f.engine,
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 engine = createFakeEngine({
canvas: { getBoundingClientRect: () => rect(0, 0, 1200, 900) },
});
engine.fake.setPose({
position: geo.cartesian3.fromDegrees(0, 0, 250_000),
heading: 0.2,
pitch: -1.2,
roll: 0.1,
});
const pose = engine.camera.pose();
engine.fake.script('pickEllipsoid', (p) =>
geo.cartesian3.fromDegrees(p.x / 100, p.y / 100),
);
engine.camera.flyTo = (value) => flights.push(value);
for (const reduced of [false, true]) {
assert.equal(
panWildlifeSighting(engine, { x: 10, y: 10 }, { x: 30, y: 50 }, reduced),
true,
);
const flight = flights.at(-1);
assert.ok(
Math.abs(
geo.cartographic.fromCartesian(flight.destination).height - 250_000,
) < 0.001,
);
assert.deepEqual(flight.orientation, {
heading: pose.heading,
pitch: pose.pitch,
roll: pose.roll,
});
for (const [angle, value] of Object.entries({
heading: 0.2,
pitch: -1.2,
roll: 0.1,
}))
assert.ok(Math.abs(flight.orientation[angle] - value) < 1e-9, angle);
assert.equal(flight.duration, reduced ? 0 : 0.22);
}
});
test('a sighting projects through the engine onto the page, and not from behind the globe', () => {
const engine = createFakeEngine({
canvas: { getBoundingClientRect: () => rect(30, 40, 1024, 768) },
});
engine.fake.setPose({ position: geo.cartesian3.fromDegrees(0, 0, 250_000) });
const centre = projectWildlifeSighting(engine, row, null);
assert.ok(Math.abs(centre.x - (30 + 512)) < 1e-6);
assert.ok(Math.abs(centre.y - (40 + 384)) < 1e-6);
const anchored = { x: 1, y: 2, z: 3 };
engine.fake.script('worldToWindow', () => ({ x: 10, y: 20 }));
engine.projector.horizonVisible = (position) => position === anchored;
assert.deepEqual(
projectWildlifeSighting(engine, row, {
getSightingPosition: () => anchored,
}),
{ x: 40, y: 60 },
'the layer anchor wins over the row coordinates',
);
assert.equal(projectWildlifeSighting(engine, row, null), null);
assert.equal(projectWildlifeSighting(null, row, null), null);
});
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',
);
// The engine reports the globe click 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',
);
});