mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 10:42:22 +00:00
# Conflicts: # scripts/engine-coupling-baseline.json # src/layers/wind/index.test.mjs
2295 lines
73 KiB
JavaScript
2295 lines
73 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as geo from '../../geo/index.js';
|
|
import { ENGINE_KINDS } from '../../globe/contract.js';
|
|
import { createFakeEngine } from '../../globe/testing/fakeEngine.js';
|
|
import { createWildlifeSightingsLayer } from './index.js';
|
|
import { WILDLIFE_BADGE_SET_ID } from './rendering.js';
|
|
import { WILDLIFE_DENSITY_SET_ID } from './density.js';
|
|
import { layerFeedState } from '../../data/feedState.js';
|
|
import { LayerLifecycle } from '../../data/lifecycle.js';
|
|
import { ICONIC_LEGEND_ORDER, WILDLIFE_MAX_ROWS } from './policy.js';
|
|
import { wildlifeGridCellId } from './gridViewport.js';
|
|
|
|
const NOW = Date.parse('2026-11-04T18:00:00Z');
|
|
const base = {
|
|
stableId: 'inat:1',
|
|
origin: 'inaturalist',
|
|
lat: 47.6,
|
|
lon: -122.4,
|
|
obscured: false,
|
|
cell: null,
|
|
observedAt: NOW - 3_600_000,
|
|
observedOn: '2026-11-04',
|
|
quality: 'research',
|
|
commonName: 'Synthetic bird',
|
|
scientificName: 'Avis synthetica',
|
|
iconic: 'Aves',
|
|
threatened: false,
|
|
provider: null,
|
|
link: 'https://www.inaturalist.org/observations/1',
|
|
photo: null,
|
|
};
|
|
const photographed = {
|
|
...base,
|
|
photo: {
|
|
square:
|
|
'https://inaturalist-open-data.s3.amazonaws.com/photos/1/square.jpg',
|
|
medium:
|
|
'https://inaturalist-open-data.s3.amazonaws.com/photos/1/medium.jpg',
|
|
attribution: '(c) Synthetic Photographer',
|
|
licence: 'cc-by',
|
|
},
|
|
};
|
|
|
|
const toRadians = geo.math.toRadians;
|
|
const toDegrees = geo.math.toDegrees;
|
|
const cartographicOf = (position) => geo.cartographic.fromCartesian(position);
|
|
const heightOf = (position) => cartographicOf(position).height;
|
|
const lonOf = (position) => toDegrees(cartographicOf(position).longitude);
|
|
const latOf = (position) => toDegrees(cartographicOf(position).latitude);
|
|
|
|
/**
|
|
* The layer on a fake globe engine above Seattle. `extra.project(_, position)`
|
|
* and `extra.occluderFactory()` script the engine's projection and horizon
|
|
* test; the rest goes to the layer.
|
|
*/
|
|
function harness(
|
|
source = { getSnapshot: async () => [base] },
|
|
extra = {},
|
|
{ autoEnable = true, width = 2000, height = 1200 } = {},
|
|
) {
|
|
const { project, occluderFactory, ...layerExtra } = extra;
|
|
let time = NOW;
|
|
let picked;
|
|
let cardHit = null;
|
|
let pointerFree = true;
|
|
let tilesLoaded = true;
|
|
let rectangle = { south: 47.4, west: -122.7, north: 47.9, east: -122.1 };
|
|
const events = new EventTarget();
|
|
// Camera heights are set exactly; the pose stays above Seattle.
|
|
const camera = { height: 30_000 };
|
|
const projectRow =
|
|
project ??
|
|
((_scene, position) => ({
|
|
x: 400 + (lonOf(position) - (rectangle.west + rectangle.east) / 2) * 1000,
|
|
y:
|
|
400 +
|
|
((rectangle.south + rectangle.north) / 2 - latOf(position)) * 1000,
|
|
}));
|
|
// Input registrations the layer holds, on every engine.
|
|
let inputs = 0;
|
|
/** A fake engine of `kind` that sees and projects the fixture view. */
|
|
function globe(kind) {
|
|
const engine = createFakeEngine({ kind, width, height });
|
|
engine.fake.setPose({
|
|
position: geo.cartesian3.fromDegrees(-122, 47, 30_000),
|
|
});
|
|
// Settle the camera so later frames raise no camera events.
|
|
engine.fake.frames(2);
|
|
engine.camera.height = () => camera.height;
|
|
engine.fake.script('viewRectangle', () =>
|
|
Object.fromEntries(
|
|
Object.entries(rectangle).map(([key, value]) => [
|
|
key,
|
|
toRadians(value),
|
|
]),
|
|
),
|
|
);
|
|
engine.projector.horizonVisible = (position) =>
|
|
occluderFactory ? occluderFactory().isPointVisible(position) : true;
|
|
engine.fake.script('worldToWindow', (position) =>
|
|
projectRow(null, position),
|
|
);
|
|
engine.fake.script('pick', () => picked ?? undefined);
|
|
engine.fake.script('tilesLoaded', () => tilesLoaded);
|
|
const on = engine.input.on;
|
|
engine.input.on = (type, listener, options) => {
|
|
const off = on(type, listener, options);
|
|
inputs++;
|
|
let removed = false;
|
|
return () => {
|
|
if (!removed) inputs--;
|
|
removed = true;
|
|
off();
|
|
};
|
|
};
|
|
return engine;
|
|
}
|
|
const engine = globe();
|
|
const owners = new Map();
|
|
const overlay = {
|
|
entries: new Map(),
|
|
visible: new Map(),
|
|
options: new Map(),
|
|
};
|
|
const renders = [];
|
|
const focus = [];
|
|
const links = [];
|
|
const store = { entities: new Map(), selectedEntityId: null };
|
|
const timers = new Map();
|
|
const idleTasks = new Map();
|
|
let nextTimer = 0;
|
|
let nextIdle = 0;
|
|
const images = [];
|
|
const ground = { sample: () => 123, resolves: 0 };
|
|
const layer = createWildlifeSightingsLayer({
|
|
source,
|
|
groundFloor: {
|
|
cachedGroundFloor: (lat, lon) => ground.sample(lat, lon),
|
|
resolveGroundFloorCellsBounded: async () => {
|
|
ground.resolves++;
|
|
},
|
|
},
|
|
now: () => time,
|
|
setTimer(fn, delay) {
|
|
const id = ++nextTimer;
|
|
timers.set(id, { fn, delay });
|
|
return id;
|
|
},
|
|
clearTimer: (id) => timers.delete(id),
|
|
requestIdleCallback(fn) {
|
|
const id = ++nextIdle;
|
|
idleTasks.set(id, fn);
|
|
return id;
|
|
},
|
|
cancelIdleCallback: (id) => idleTasks.delete(id),
|
|
imageFactory: () => {
|
|
const image = {};
|
|
images.push(image);
|
|
return image;
|
|
},
|
|
eventTarget: events,
|
|
overlayHost: {
|
|
setEntries: (id, entries, options) => {
|
|
assert.equal(options.moving, false);
|
|
overlay.entries.set(id, entries);
|
|
overlay.options.set(id, options);
|
|
},
|
|
setVisible: (id, value) => overlay.visible.set(id, value),
|
|
clearSource: (id) => overlay.entries.delete(id),
|
|
hitTest: (_x, _y, { sourceId }) =>
|
|
cardHit?.sourceId === sourceId ? cardHit : null,
|
|
},
|
|
pointer: { isPointerFree: () => pointerFree },
|
|
picking: {
|
|
registerPickOwner: (id, fn) => owners.set(id, fn),
|
|
unregisterPickOwner: (id) => owners.delete(id),
|
|
resolvePickId: (pick) => pick?.id ?? null,
|
|
isOwnedByOtherLayer: (_layerId, id) => id?.startsWith('other:'),
|
|
},
|
|
render: { governorRequestRender: (reason) => renders.push(reason) },
|
|
focus: { requestWorldFocus: (request) => focus.push(request) },
|
|
openExternal: (url) => links.push(url),
|
|
context: {
|
|
getContextStore: () => store,
|
|
registerEntityContext(entity, metadata) {
|
|
entity.__gevContextId = metadata.id;
|
|
store.entities.set(metadata.id, { ...metadata, entity });
|
|
},
|
|
selectEntityContext(entity) {
|
|
store.selectedEntityId = entity.__gevContextId;
|
|
const selected = new Event('gev:entity-selected');
|
|
selected.detail = store.entities.get(entity.__gevContextId);
|
|
events.dispatchEvent(selected);
|
|
},
|
|
clearSelectedEntityContextForLayer: () => {
|
|
store.selectedEntityId = null;
|
|
},
|
|
removeEntityContextsForLayer: () => store.entities.clear(),
|
|
},
|
|
...layerExtra,
|
|
});
|
|
const init = () => layer.init(null, { engine });
|
|
if (autoEnable) {
|
|
init();
|
|
layer.enable();
|
|
}
|
|
function flushIdle() {
|
|
for (let steps = 0; idleTasks.size; steps++) {
|
|
assert.ok(steps < 1000, 'idle work finishes without a frame loop');
|
|
const [id, fn] = idleTasks.entries().next().value;
|
|
idleTasks.delete(id);
|
|
fn({ timeRemaining: () => 10 });
|
|
}
|
|
}
|
|
const badgeSet = (target = engine) =>
|
|
target.fake.moverSet(WILDLIFE_BADGE_SET_ID);
|
|
// One badge as the engine draws it, read live from the mover store.
|
|
const badge = (id, target) => {
|
|
const index = () => {
|
|
const set = badgeSet(target);
|
|
if (!set) return -1;
|
|
for (let at = 0; at < set.store.count; at++)
|
|
if (set.store.pickIds[at] === id) return at;
|
|
return -1;
|
|
};
|
|
const read = (fn) => {
|
|
const at = index();
|
|
return at < 0 ? undefined : fn(badgeSet(target).store, at);
|
|
};
|
|
return {
|
|
id,
|
|
get position() {
|
|
return read((store, at) =>
|
|
geo.cartesian3.create(
|
|
store.positions[at * 3],
|
|
store.positions[at * 3 + 1],
|
|
store.positions[at * 3 + 2],
|
|
),
|
|
);
|
|
},
|
|
get show() {
|
|
return read((store, at) => store.shows[at] === 1);
|
|
},
|
|
get scale() {
|
|
return read((store, at) => store.scales[at]);
|
|
},
|
|
get color() {
|
|
return read((store, at) => [
|
|
...store.colors.subarray(at * 4, at * 4 + 4),
|
|
]);
|
|
},
|
|
get cell() {
|
|
return read((store, at) => store.cellKeys[store.cells[at]]);
|
|
},
|
|
};
|
|
};
|
|
return {
|
|
engine,
|
|
ground,
|
|
layer,
|
|
init,
|
|
async update(...args) {
|
|
// Explicit refreshes stand for successive poll batches, not push bursts.
|
|
time += 500;
|
|
const result = await layer.update(...args);
|
|
flushIdle();
|
|
return result;
|
|
},
|
|
flushIdle,
|
|
overlay,
|
|
owners,
|
|
renders,
|
|
focus,
|
|
links,
|
|
images,
|
|
events,
|
|
store,
|
|
timers,
|
|
/** The badges an engine draws, in instance order. */
|
|
badges(target = engine) {
|
|
const set = badgeSet(target);
|
|
return set
|
|
? Array.from({ length: set.store.count }, (_, at) =>
|
|
badge(set.store.pickIds[at], target),
|
|
)
|
|
: [];
|
|
},
|
|
globe,
|
|
badgeSet,
|
|
glow: () => engine.fake.moverSet(WILDLIFE_DENSITY_SET_ID),
|
|
moveEnd: {
|
|
emit: () => engine.fake.emit('camera.moveEnd'),
|
|
count: () => engine.camera.moveEnd.numberOfListeners,
|
|
},
|
|
/** Listeners that run on every drawn frame. */
|
|
frameWork: () => engine.frames.preRender.numberOfListeners,
|
|
/** The surface-loading watch (one per enabled scene). */
|
|
surfaceWatch: () => engine.frames.preRender.numberOfListeners,
|
|
/** Surface loading as the engine reports it, then one frame. */
|
|
tiles(loaded) {
|
|
tilesLoaded = loaded;
|
|
engine.fake.frame();
|
|
},
|
|
credits: () => engine.fake.credits.length,
|
|
inputs: () => inputs,
|
|
click(event) {
|
|
engine.fake.input('click', event);
|
|
},
|
|
height: (value) => {
|
|
camera.height = value;
|
|
},
|
|
pick: (value) => {
|
|
picked = value;
|
|
},
|
|
hit: (value) => {
|
|
cardHit = value;
|
|
},
|
|
free: (value) => {
|
|
pointerFree = value;
|
|
},
|
|
rectangle: (value) => {
|
|
rectangle = value;
|
|
},
|
|
time: (value) => {
|
|
time = value;
|
|
},
|
|
contextSelect(id) {
|
|
const selected = new Event('gev:entity-selected');
|
|
selected.detail = store.entities.get(id);
|
|
events.dispatchEvent(selected);
|
|
},
|
|
};
|
|
}
|
|
|
|
test('construction validates source and does not acquire; double init throws', () => {
|
|
assert.throws(() => createWildlifeSightingsLayer(), TypeError);
|
|
const h = harness({ getSnapshot: () => assert.fail('enable fetched') });
|
|
assert.throws(() => h.init(), /already initialized/);
|
|
assert.equal(h.badgeSet(), undefined, 'no badge set before any badge');
|
|
assert.deepEqual(h.engine.movers.list(), []);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('terrain warming resamples unchanged point, card and context anchors without a frame loop', async () => {
|
|
const h = harness(
|
|
{
|
|
getSnapshot: async () => [
|
|
photographed,
|
|
{ ...base, stableId: 'acartia:sea', origin: 'acartia', lon: -122.3 },
|
|
],
|
|
},
|
|
{},
|
|
{ autoEnable: false },
|
|
);
|
|
let height = 0;
|
|
let samples = 0;
|
|
h.ground.sample = () => {
|
|
samples++;
|
|
return height;
|
|
};
|
|
h.init();
|
|
h.layer.enable();
|
|
await h.update();
|
|
h.layer.selectSighting('inat:1');
|
|
const [point, sea] = h.badges();
|
|
const before = samples;
|
|
height = 600;
|
|
await h.update();
|
|
h.moveEnd.emit();
|
|
assert.equal(
|
|
samples,
|
|
before + 1,
|
|
'camera rest resamples the land anchor once',
|
|
);
|
|
h.tiles(false);
|
|
assert.equal(samples, before + 1, 'wait for terrain loading to settle');
|
|
h.tiles(true);
|
|
assert.ok(Math.abs(cartographicOf(point.position).height - 600) < 0.01);
|
|
assert.equal(
|
|
samples,
|
|
before + 2,
|
|
'Acartia sea anchors are never terrain-sampled',
|
|
);
|
|
assert.ok(Math.abs(cartographicOf(sea.position).height) < 0.01);
|
|
assert.equal(
|
|
h.badges()[0].id,
|
|
point.id,
|
|
'resampling preserves the badge instance',
|
|
);
|
|
assert.equal(h.badges().length, 2);
|
|
assert.deepEqual(
|
|
h.overlay.entries.get('wildlife-sightings')[0].position,
|
|
point.position,
|
|
);
|
|
assert.ok(
|
|
h.overlay.entries
|
|
.get('wildlife-sightings-selected')
|
|
.every((entry) => geo.cartesian3.equals(entry.position, point.position)),
|
|
);
|
|
assert.deepEqual(
|
|
h.store.entities.get('inat:1').entity.__localBaseCartesian,
|
|
point.position,
|
|
);
|
|
assert.ok(h.renders.includes('wildlife-sightings-terrain'));
|
|
assert.equal(h.frameWork(), 1);
|
|
h.layer.disable();
|
|
assert.equal(h.surfaceWatch(), 0);
|
|
const disabledSamples = samples;
|
|
h.tiles(false);
|
|
h.tiles(true);
|
|
assert.equal(samples, disabledSamples);
|
|
height = 900;
|
|
h.layer.enable();
|
|
assert.ok(
|
|
Math.abs(cartographicOf(h.badges()[0].position).height - 900) < 0.01,
|
|
);
|
|
assert.equal(h.surfaceWatch(), 1);
|
|
h.layer.destroy();
|
|
assert.equal(h.surfaceWatch(), 0);
|
|
});
|
|
|
|
test('surface loading and map-source changes refresh anchors and release listeners', async () => {
|
|
const h = harness(undefined, {}, { autoEnable: false });
|
|
let height = 20;
|
|
h.ground.sample = () => height;
|
|
h.init();
|
|
h.layer.enable();
|
|
await h.update();
|
|
const point = h.badges()[0];
|
|
const assertHeight = (expected) =>
|
|
assert.ok(Math.abs(heightOf(point.position) - expected) < 0.01);
|
|
height = 200;
|
|
h.tiles(false);
|
|
assertHeight(20);
|
|
h.tiles(true);
|
|
assertHeight(200);
|
|
height = 400;
|
|
h.tiles(true);
|
|
assertHeight(200);
|
|
h.tiles(false);
|
|
h.tiles(true);
|
|
assertHeight(400);
|
|
height = 800;
|
|
h.events.dispatchEvent(new Event('gev:map-stack-changed'));
|
|
assertHeight(800);
|
|
h.layer.disable();
|
|
assert.equal(h.surfaceWatch(), 0);
|
|
height = 1000;
|
|
h.events.dispatchEvent(new Event('gev:map-stack-changed'));
|
|
assert.equal(h.badges().length, 0);
|
|
h.layer.destroy();
|
|
assert.equal(h.frameWork(), 0);
|
|
});
|
|
|
|
test('camera rebuilds expire unselected sightings while a selected observation stays pinned', async () => {
|
|
for (const [taxa, windowHours] of [
|
|
['all', 48],
|
|
['whales', 7 * 24],
|
|
]) {
|
|
let requests = 0;
|
|
const h = harness({
|
|
getSnapshot: async () =>
|
|
++requests === 1
|
|
? [photographed]
|
|
: [{ ...base, stableId: 'inat:other-area', lat: 49.1, lon: -124.2 }],
|
|
});
|
|
h.layer.setParams({ taxa });
|
|
await h.update();
|
|
h.rectangle({ south: 48.8, west: -124.5, north: 49.4, east: -124 });
|
|
h.moveEnd.emit();
|
|
await h.update();
|
|
h.rectangle({ south: 47.4, west: -122.7, north: 47.9, east: -122.1 });
|
|
h.moveEnd.emit();
|
|
assert.equal(
|
|
h.badges()[0].id,
|
|
'wildlife:inat:1',
|
|
'the prior area is retained in the LRU',
|
|
);
|
|
assert.equal(h.layer.selectSighting('inat:1'), true);
|
|
assert.ok(h.overlay.entries.get('wildlife-sightings-selected').length > 0);
|
|
h.time(NOW + windowHours * 3_600_000);
|
|
h.moveEnd.emit();
|
|
assert.equal(
|
|
h.badges().length,
|
|
1,
|
|
`${taxa} keeps the explicitly selected observation beyond its window`,
|
|
);
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings').length, 0);
|
|
assert.equal(
|
|
h.overlay.entries.get('wildlife-sightings-selected').length,
|
|
1,
|
|
);
|
|
h.layer.clearSightingSelection();
|
|
h.moveEnd.emit();
|
|
assert.equal(h.badges().length, 0, 'expired rows retire on deselection');
|
|
assert.equal(requests, 2, 'expiry needs no new source success');
|
|
h.layer.destroy();
|
|
}
|
|
});
|
|
|
|
test('pending filter changes retain the accepted recency window until their result validates', async () => {
|
|
const h = harness({
|
|
getSnapshot: async () => [
|
|
{ ...photographed, observedAt: NOW - 3 * 86_400_000 },
|
|
],
|
|
});
|
|
h.layer.setParams({ taxa: 'whales' });
|
|
await h.update();
|
|
h.layer.setParams({ taxa: 'all' });
|
|
assert.equal(h.layer.selectSighting('inat:1'), true);
|
|
assert.equal(
|
|
h.badges().length,
|
|
1,
|
|
'three-day whale remains while ALL is pending',
|
|
);
|
|
assert.ok(h.overlay.entries.get('wildlife-sightings-selected').length > 0);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('sampled ground and sea heights keep badges on top and update them in place', async () => {
|
|
let rows = [
|
|
base,
|
|
{
|
|
...base,
|
|
stableId: 'acartia:2',
|
|
origin: 'acartia',
|
|
lon: -122.5,
|
|
iconic: 'Mammalia',
|
|
},
|
|
];
|
|
const h = harness({ getSnapshot: async () => rows });
|
|
await h.update();
|
|
const first = h.badges()[0];
|
|
assert.equal(h.badgeSet().options.depthTest, 'always');
|
|
assert.ok(Math.abs(cartographicOf(first.position).height - 123) < 0.01);
|
|
assert.ok(Math.abs(cartographicOf(h.badges()[1].position).height) < 0.01);
|
|
await h.update();
|
|
assert.equal(h.badges()[0].id, first.id);
|
|
for (const change of [
|
|
{ lon: -122.3 },
|
|
{ iconic: 'Fungi' },
|
|
{ quality: 'needs_id' },
|
|
]) {
|
|
const before = h.badgeSet().store.count;
|
|
rows = [{ ...rows[0], ...change }];
|
|
await h.update();
|
|
assert.equal(
|
|
h.badges()[0].id,
|
|
first.id,
|
|
'changed contacts update in place',
|
|
);
|
|
assert.ok(h.badgeSet().store.count <= before);
|
|
}
|
|
assert.ok(h.renders.length > 0);
|
|
h.layer.destroy();
|
|
const unsupported = harness(undefined);
|
|
unsupported.ground.sample = () => null;
|
|
await unsupported.update();
|
|
assert.ok(
|
|
Math.abs(cartographicOf(unsupported.badges()[0].position).height) < 0.01,
|
|
);
|
|
unsupported.layer.destroy();
|
|
});
|
|
|
|
test('a painted card hides its anchored badge across rebuilds while retaining its context and selection', async (t) => {
|
|
const h = harness({ getSnapshot: async () => [photographed] });
|
|
t.after(() => h.layer.destroy());
|
|
await h.update();
|
|
const point = h.badges()[0];
|
|
assert.equal(point.show, true);
|
|
const visibility =
|
|
h.overlay.options.get('wildlife-sightings').onVisibilityChange;
|
|
visibility(new Set(['sighting:inat:1']));
|
|
assert.equal(point.show, false);
|
|
h.moveEnd.emit();
|
|
assert.equal(
|
|
point.show,
|
|
false,
|
|
'a camera rebuild must not resurrect the represented badge',
|
|
);
|
|
assert.equal(
|
|
h.store.entities.get('inat:1').entity.show,
|
|
true,
|
|
'visual badge suppression must not hide the sighting context',
|
|
);
|
|
assert.equal(h.layer.selectSighting('inat:1'), true);
|
|
assert.equal(
|
|
point.show,
|
|
false,
|
|
'selection must not resurrect the represented badge',
|
|
);
|
|
visibility(new Set());
|
|
assert.equal(point.show, true);
|
|
});
|
|
|
|
test('a painted thumbnail hides the repeat name label, ambient and selected, until it leaves', async (t) => {
|
|
const h = harness({ getSnapshot: async () => [photographed] });
|
|
t.after(() => h.layer.destroy());
|
|
await h.update();
|
|
const labelIds = () =>
|
|
[
|
|
...(h.overlay.entries.get('wildlife-sightings-labels') || []),
|
|
...(h.overlay.entries.get('wildlife-sightings-selected') || []),
|
|
]
|
|
.filter((entry) => entry.variant === 'label')
|
|
.map((entry) => entry.id);
|
|
const visibility =
|
|
h.overlay.options.get('wildlife-sightings').onVisibilityChange;
|
|
assert.ok(h.layer.selectSighting('inat:1'));
|
|
assert.deepEqual(labelIds(), ['wildlife-sightings-label:inat:1']);
|
|
visibility(new Set(['sighting:inat:1']));
|
|
assert.deepEqual(labelIds(), [], 'the thumbnail already names it');
|
|
h.moveEnd.emit();
|
|
assert.deepEqual(labelIds(), [], 'a rebuild keeps the label hidden');
|
|
h.layer.clearSelection?.();
|
|
assert.deepEqual(labelIds(), [], 'ambient labels also yield to the card');
|
|
visibility(new Set());
|
|
assert.ok(labelIds().length <= 1);
|
|
});
|
|
|
|
test('dot, ambient card and context clicks focus the true sighting; cards win over scene picks', async () => {
|
|
const h = harness({ getSnapshot: async () => [photographed] });
|
|
const selections = [];
|
|
h.layer.subscribeSelection((row, metadata) =>
|
|
selections.push({ row, metadata }),
|
|
);
|
|
await h.update();
|
|
h.pick({ id: 'wildlife:inat:1' });
|
|
h.click({ position: { x: 20, y: 30 } });
|
|
assert.equal(h.focus.length, 1);
|
|
assert.equal(h.badges()[0].scale, 1);
|
|
assert.equal(h.store.selectedEntityId, 'inat:1');
|
|
assert.deepEqual(selections.at(-1), {
|
|
row: photographed,
|
|
metadata: { explicitSelection: true },
|
|
});
|
|
const ambient = h.overlay.entries.get('wildlife-sightings')[0];
|
|
assert.equal(ambient.interactive, true);
|
|
// The anchored photo card owns the single iNaturalist link; canvas cards
|
|
// only select and focus.
|
|
assert.match(ambient.accessibilityLabel, /Show Synthetic bird sighting/);
|
|
assert.equal(ambient.activate(), true);
|
|
assert.equal(h.focus.length, 2);
|
|
assert.deepEqual(h.links, []);
|
|
assert.deepEqual(selections.at(-1).metadata, { explicitSelection: true });
|
|
const selected = h.overlay.entries.get('wildlife-sightings-selected');
|
|
assert.equal(selected.length, 1);
|
|
assert.equal(selected[0].variant, 'label');
|
|
assert.equal(selected[0].title, base.commonName.toUpperCase());
|
|
assert.equal(selected[0].placement, 'above');
|
|
assert.equal(selected[0].interactive, false);
|
|
assert.equal(selected[0].selected, true);
|
|
assert.equal(selected[0].image, undefined);
|
|
assert.equal(selected[0].details, undefined);
|
|
assert.equal(selected[0].pinned, undefined);
|
|
assert.ok(
|
|
h.images.every((image) => /square.jpg$/.test(image.src)),
|
|
'selection never starts an overlay medium image',
|
|
);
|
|
h.hit({ sourceId: 'wildlife-sightings', entry: ambient });
|
|
h.pick({ id: 'other:aircraft' });
|
|
h.click({ position: {} });
|
|
assert.deepEqual(h.links, [], 'canvas cards select; they never open links');
|
|
assert.equal(h.focus.length, 3);
|
|
assert.equal(
|
|
h.store.selectedEntityId,
|
|
'inat:1',
|
|
'ambient cards win over scene picks',
|
|
);
|
|
h.hit(null);
|
|
h.click({ position: {} });
|
|
assert.equal(h.store.selectedEntityId, 'inat:1', 'sibling picks yield');
|
|
h.free(false);
|
|
h.pick(null);
|
|
h.click({ position: {} });
|
|
assert.equal(h.store.selectedEntityId, 'inat:1');
|
|
h.contextSelect('inat:1');
|
|
assert.equal(
|
|
h.focus.length,
|
|
4,
|
|
'context selection focuses the same true observation position',
|
|
);
|
|
assert.deepEqual(selections.at(-1).metadata, { explicitSelection: true });
|
|
h.free(true);
|
|
h.click({ position: {} });
|
|
assert.equal(h.store.selectedEntityId, null);
|
|
h.layer.disable();
|
|
assert.equal(ambient.activate(), false);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('selection subscriptions publish current rows, accepted refreshes, reselection and real deselection', async () => {
|
|
let rows = [photographed];
|
|
const h = harness({ getSnapshot: async () => rows });
|
|
const seen = [];
|
|
const metadata = [];
|
|
const unsubscribe = h.layer.subscribeSelection((selected, details) => {
|
|
seen.push(selected);
|
|
metadata.push(details);
|
|
});
|
|
assert.deepEqual(
|
|
seen,
|
|
[null],
|
|
'subscription immediately publishes its empty state',
|
|
);
|
|
assert.deepEqual(metadata.at(-1), { explicitSelection: false });
|
|
await h.update();
|
|
assert.deepEqual(metadata.at(-1), { explicitSelection: false });
|
|
assert.equal(h.layer.selectSighting('inat:1'), true);
|
|
assert.equal(seen.at(-1), photographed);
|
|
assert.deepEqual(metadata.at(-1), { explicitSelection: true });
|
|
const immediately = [];
|
|
const removeImmediate = h.layer.subscribeSelection((selected, details) =>
|
|
immediately.push({ selected, details }),
|
|
);
|
|
assert.deepEqual(
|
|
immediately,
|
|
[{ selected: photographed, details: { explicitSelection: false } }],
|
|
'late subscribers immediately receive the selected row without an explicit reselection',
|
|
);
|
|
removeImmediate();
|
|
rows = [{ ...photographed, commonName: 'Updated synthetic bird' }];
|
|
await h.update();
|
|
assert.equal(seen.at(-1), rows[0]);
|
|
assert.deepEqual(
|
|
metadata.at(-1),
|
|
{ explicitSelection: false },
|
|
'an accepted snapshot preserves disclosure',
|
|
);
|
|
assert.equal(
|
|
h.overlay.entries.get('wildlife-sightings-selected')[0].title,
|
|
rows[0].commonName.toUpperCase(),
|
|
);
|
|
const beforeReselect = seen.length;
|
|
h.layer.selectSighting('inat:1');
|
|
assert.equal(
|
|
seen.length,
|
|
beforeReselect + 1,
|
|
'reselection notifies the dialog',
|
|
);
|
|
assert.deepEqual(
|
|
metadata.at(-1),
|
|
{ explicitSelection: true },
|
|
'explicitly reselecting the same row can reopen it',
|
|
);
|
|
assert.equal(h.layer.clearSightingSelection(), true);
|
|
assert.equal(seen.at(-1), null);
|
|
assert.deepEqual(metadata.at(-1), { explicitSelection: false });
|
|
assert.equal(h.store.selectedEntityId, null);
|
|
assert.equal(h.badges()[0].scale, 1);
|
|
assert.deepEqual(h.badges()[0].color, [1, 1, 1, 1]);
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-selected'), []);
|
|
assert.equal(h.layer.clearSightingSelection(), false);
|
|
h.layer.selectSighting('inat:1');
|
|
const beforeUnsubscribe = seen.length;
|
|
unsubscribe();
|
|
await h.update();
|
|
h.layer.clearSightingSelection();
|
|
assert.equal(seen.length, beforeUnsubscribe);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('selection subscriptions retain omitted rows and clear on disable and destroy, without an overlay host', async () => {
|
|
let rows = [base];
|
|
const eventListeners = new Map();
|
|
const eventTarget = {
|
|
addEventListener(type, listener) {
|
|
if (!eventListeners.has(type)) eventListeners.set(type, new Set());
|
|
eventListeners.get(type).add(listener);
|
|
},
|
|
removeEventListener(type, listener) {
|
|
eventListeners.get(type)?.delete(listener);
|
|
},
|
|
};
|
|
const h = harness(
|
|
{ getSnapshot: async () => rows },
|
|
{ overlayHost: null, eventTarget },
|
|
);
|
|
assert.equal(eventListeners.get('gev:entity-selected').size, 1);
|
|
const seen = [];
|
|
const unsubscribe = h.layer.subscribeSelection((selected) =>
|
|
seen.push(selected),
|
|
);
|
|
h.layer.subscribeSelection(() => {
|
|
throw new Error('Disconnected dialog');
|
|
});
|
|
await h.update();
|
|
h.layer.selectSighting('inat:1');
|
|
rows = [];
|
|
await h.update();
|
|
assert.equal(
|
|
seen.at(-1),
|
|
base,
|
|
'an accepted result omitting the selected row preserves the dialog',
|
|
);
|
|
rows = [base];
|
|
await h.update();
|
|
h.layer.selectSighting('inat:1');
|
|
h.layer.disable();
|
|
assert.equal(seen.at(-1), null);
|
|
assert.equal(eventListeners.get('gev:entity-selected').size, 0);
|
|
const disabledCount = seen.length;
|
|
h.layer.enable();
|
|
assert.equal(eventListeners.get('gev:entity-selected').size, 1);
|
|
await h.update();
|
|
h.layer.selectSighting('inat:1');
|
|
assert.equal(seen.at(-1), base);
|
|
assert.ok(
|
|
seen.length > disabledCount,
|
|
'disable retains subscriptions for re-enable',
|
|
);
|
|
h.layer.destroy();
|
|
assert.equal(seen.at(-1), null);
|
|
assert.equal(h.inputs(), 0, 'no click listener remains');
|
|
assert.equal(eventListeners.get('gev:entity-selected').size, 0);
|
|
const destroyedCount = seen.length;
|
|
h.layer.clearSightingSelection();
|
|
assert.equal(
|
|
seen.length,
|
|
destroyedCount,
|
|
'destroy removes existing subscribers',
|
|
);
|
|
const afterDestroy = [];
|
|
const removeDestroyed = h.layer.subscribeSelection((selected) =>
|
|
afterDestroy.push(selected),
|
|
);
|
|
assert.deepEqual(afterDestroy, [null]);
|
|
h.layer.clearSightingSelection();
|
|
assert.deepEqual(
|
|
afterDestroy,
|
|
[null],
|
|
'destroyed layers never retain new subscribers',
|
|
);
|
|
removeDestroyed();
|
|
unsubscribe();
|
|
});
|
|
|
|
function watchCells(engine) {
|
|
let current;
|
|
const createSet = engine.ground.createSet.bind(engine.ground);
|
|
engine.ground.createSet = (options) => {
|
|
const set = createSet(options);
|
|
const { replace } = set;
|
|
set.replace = (items) => {
|
|
replace(items);
|
|
current = { set, items };
|
|
};
|
|
return set;
|
|
};
|
|
return () => current;
|
|
}
|
|
|
|
test('privacy cells draw on ground, replace changed batches and release them', async () => {
|
|
let rows = [
|
|
{
|
|
...base,
|
|
obscured: true,
|
|
cell: { south: 47.6, west: -122.4, north: 47.8, east: -122.2 },
|
|
},
|
|
];
|
|
const h = harness({ getSnapshot: async () => rows });
|
|
const cells = watchCells(h.engine);
|
|
await h.update();
|
|
const first = cells();
|
|
assert.equal(h.engine.ground.list().length, 1);
|
|
assert.equal(h.frameWork(), 1, 'only the shared surface observer');
|
|
rows = [{ ...rows[0], iconic: 'Fungi' }];
|
|
await h.update();
|
|
const second = cells();
|
|
assert.equal(h.engine.ground.list().length, 1);
|
|
assert.notEqual(second.set, first.set, 'a new accent replaces the geometry');
|
|
assert.notDeepEqual(second.items[0].fill, first.items[0].fill);
|
|
assert.throws(() => first.set.commit(), /destroyed/);
|
|
h.layer.selectSighting(base.stableId);
|
|
assert.equal(h.focus.at(-1).kind, 'sighting-area');
|
|
const selectedRing = h.badges()[0];
|
|
assert.deepEqual(selectedRing.color, [1, 1, 1, 1]);
|
|
assert.equal(selectedRing.scale, 1);
|
|
assert.match(h.badgeSet().options.sprite.atlas.url, /^data:image\/svg/);
|
|
assert.equal(cells(), second, 'selection reuses unchanged privacy geometry');
|
|
h.layer.disable();
|
|
assert.deepEqual(h.engine.ground.list(), []);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('disable ignores late successes and failures, unregisters owners and hides both overlay sources and credits', async () => {
|
|
for (const reject of [false, true]) {
|
|
let settle;
|
|
let signal;
|
|
const h = harness({
|
|
getSnapshot: ({ signal: requestSignal }) => {
|
|
signal = requestSignal;
|
|
return new Promise((resolve, fail) => {
|
|
settle = reject ? fail : resolve;
|
|
});
|
|
},
|
|
});
|
|
const pending = h.update();
|
|
assert.equal(h.owners.size, 1);
|
|
h.layer.disable();
|
|
assert.equal(signal.aborted, true);
|
|
settle(reject ? Error('iNaturalist HTTP 502') : [photographed]);
|
|
assert.equal(await pending, false);
|
|
assert.equal(h.layer.getStats().error, null);
|
|
assert.equal(h.badges().length, 0);
|
|
assert.equal(h.owners.size, 0);
|
|
assert.equal(h.credits(), 0);
|
|
assert.deepEqual([...h.overlay.visible.values()], [false, false, false]);
|
|
assert.equal(h.overlay.entries.size, 0);
|
|
assert.equal(h.moveEnd.count(), 0);
|
|
h.layer.destroy();
|
|
assert.deepEqual(h.engine.movers.list(), []);
|
|
assert.equal(h.badgeSet(), undefined);
|
|
assert.equal(h.inputs(), 0);
|
|
}
|
|
});
|
|
|
|
test('first failure stays enabled; stale timestamps and subsequent failure preserve data with honest feed states', async () => {
|
|
let snapshot = null;
|
|
const h = harness({
|
|
getSnapshot: async () => [],
|
|
getSnapshotDetail: async () => {
|
|
if (!snapshot) throw new Error('iNaturalist HTTP 502');
|
|
return snapshot;
|
|
},
|
|
});
|
|
assert.equal(await h.update(), true);
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'unavailable');
|
|
assert.equal(h.owners.size, 1);
|
|
snapshot = { rows: [base], stale: true, fetchedAt: NOW - 300_000 };
|
|
h.time(NOW + 31_000);
|
|
await h.update();
|
|
assert.equal(h.layer.getStats().lastUpdate, snapshot.fetchedAt);
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'stale');
|
|
snapshot = null;
|
|
await h.update();
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
assert.equal(h.layer.getStats().stale, false);
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'degraded');
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('camera boxes supersede pending fetches through one manager debounce', async () => {
|
|
let signal;
|
|
let settle;
|
|
const h = harness({
|
|
getSnapshot: ({ signal: requestSignal }) => {
|
|
signal = requestSignal;
|
|
return new Promise((resolve) => {
|
|
settle = resolve;
|
|
});
|
|
},
|
|
});
|
|
let refreshes = 0;
|
|
h.layer.attachDataManager({
|
|
refreshLayer: async (id) => {
|
|
assert.equal(id, 'wildlife-sightings');
|
|
refreshes++;
|
|
return true;
|
|
},
|
|
});
|
|
const pending = h.update();
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
h.moveEnd.emit();
|
|
assert.equal(signal.aborted, true);
|
|
assert.equal(h.timers.size, 1);
|
|
const timer = [...h.timers.values()][0];
|
|
assert.equal(timer.delay, 600);
|
|
h.time(NOW + 2500);
|
|
timer.fn();
|
|
await Promise.resolve();
|
|
assert.equal(refreshes, 1);
|
|
settle([base]);
|
|
assert.equal(await pending, true);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('a deferred A to B to A pan starts a new A request after aborting the first', async () => {
|
|
const requests = [];
|
|
const h = harness({
|
|
getSnapshot: ({ signal, boxes }) =>
|
|
new Promise((resolve) => {
|
|
requests.push({ signal, boxes, resolve });
|
|
}),
|
|
});
|
|
const boxA = { south: 47.4, west: -122.7, north: 47.9, east: -122.1 };
|
|
const pending = h.update();
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
h.moveEnd.emit();
|
|
assert.equal(requests[0].signal.aborted, true);
|
|
h.rectangle(boxA);
|
|
h.moveEnd.emit();
|
|
assert.equal(
|
|
h.timers.size,
|
|
1,
|
|
'returning to aborted A schedules its replacement',
|
|
);
|
|
requests[0].resolve([base]);
|
|
assert.equal(await pending, true);
|
|
assert.equal(h.layer.getStats().count, 0);
|
|
const [timerId, timer] = [...h.timers][0];
|
|
h.timers.delete(timerId);
|
|
h.time(NOW + timer.delay);
|
|
timer.fn();
|
|
assert.equal(requests.length, 2);
|
|
assert.deepEqual(requests[1].boxes, requests[0].boxes);
|
|
assert.equal(requests[1].signal.aborted, false);
|
|
requests[1].resolve([base]);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
assert.equal(h.layer.getStats().error, null);
|
|
assert.equal(h.timers.size, 0);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('a completed A stays reusable when only the B debounce was pending', async () => {
|
|
let calls = 0;
|
|
const h = harness({
|
|
getSnapshot: async () => {
|
|
calls++;
|
|
return [base];
|
|
},
|
|
});
|
|
await h.update();
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
h.moveEnd.emit();
|
|
assert.equal(h.timers.size, 1);
|
|
h.rectangle({ south: 47.4, west: -122.7, north: 47.9, east: -122.1 });
|
|
h.moveEnd.emit();
|
|
assert.equal(h.timers.size, 0);
|
|
assert.equal(calls, 1);
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('an externally aborted attempt does not suppress a camera retry in the same box', async () => {
|
|
const requests = [];
|
|
const h = harness({
|
|
getSnapshot: ({ signal }) =>
|
|
new Promise((resolve) => {
|
|
requests.push({ signal, resolve });
|
|
}),
|
|
});
|
|
const controller = new AbortController();
|
|
const pending = h.update(undefined, { signal: controller.signal });
|
|
controller.abort();
|
|
h.moveEnd.emit();
|
|
assert.equal(requests[0].signal.aborted, true);
|
|
assert.equal(h.timers.size, 1);
|
|
requests[0].resolve([base]);
|
|
assert.equal(await pending, false);
|
|
const [timerId, timer] = [...h.timers][0];
|
|
h.timers.delete(timerId);
|
|
h.time(NOW + timer.delay);
|
|
timer.fn();
|
|
assert.equal(requests.length, 2);
|
|
requests[1].resolve([base]);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('the real manager keeps first enable on after a pan supersedes either a success or a failure', async () => {
|
|
for (const reject of [false, true]) {
|
|
for (const debounceBeforeSettlement of [false, true]) {
|
|
const requests = [];
|
|
const h = harness(
|
|
{
|
|
getSnapshot: ({ signal, boxes }) =>
|
|
new Promise((resolve, fail) => {
|
|
requests.push({ signal, boxes, resolve, fail });
|
|
}),
|
|
},
|
|
{},
|
|
{ autoEnable: false },
|
|
);
|
|
const manager = new LayerLifecycle(null, { engine: h.engine });
|
|
manager.register(h.layer);
|
|
h.layer.attachDataManager(manager);
|
|
const fireCameraTimer = () => {
|
|
assert.equal(h.timers.size, 1);
|
|
const [timerId, timer] = [...h.timers][0];
|
|
h.timers.delete(timerId);
|
|
h.time(NOW + 2500);
|
|
timer.fn();
|
|
};
|
|
try {
|
|
const enabling = manager.setEnabled(h.layer.id, true);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(requests.length, 0, 'startup settles before dispatch');
|
|
fireCameraTimer();
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(requests.length, 1);
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
h.moveEnd.emit();
|
|
assert.equal(requests[0].signal.aborted, true);
|
|
if (debounceBeforeSettlement) {
|
|
fireCameraTimer();
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(
|
|
requests.length,
|
|
1,
|
|
'manager cannot refresh during initial enable',
|
|
);
|
|
assert.equal(h.timers.size, 0);
|
|
}
|
|
if (reject) requests[0].fail(Error('iNaturalist HTTP 502'));
|
|
else requests[0].resolve([base]);
|
|
assert.equal(await enabling, true);
|
|
assert.equal(manager.isEnabled(h.layer.id), true);
|
|
assert.equal(h.owners.size, 1);
|
|
assert.equal(
|
|
h.layer.getStats().count,
|
|
0,
|
|
'superseded rows never publish',
|
|
);
|
|
assert.equal(
|
|
h.layer.getStats().error,
|
|
null,
|
|
'superseded errors never publish',
|
|
);
|
|
assert.equal(h.layer.getStats().lastUpdate, null);
|
|
fireCameraTimer();
|
|
assert.equal(
|
|
requests.length,
|
|
2,
|
|
'settled enable recovers the latest query',
|
|
);
|
|
assert.equal(requests[1].boxes[0].south, 48);
|
|
requests[1].resolve([
|
|
{ ...base, stableId: 'inat:2', lat: 48.2, lon: -122.8 },
|
|
]);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(manager.isEnabled(h.layer.id), true);
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
assert.equal(manager.layers.get(h.layer.id).managerRefreshError, null);
|
|
assert.equal(h.owners.get(h.layer.id)('wildlife:inat:2'), true);
|
|
} finally {
|
|
await manager.destroyLayer(h.layer.id);
|
|
}
|
|
assert.equal(h.owners.size, 0);
|
|
assert.equal(h.moveEnd.count(), 0);
|
|
assert.equal(manager._listeners.size, 0);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('first enable settles once and publishes badges within two seconds without restarting its fetch set', async (t) => {
|
|
let finishObservations;
|
|
const requests = [];
|
|
let gridSets = 0;
|
|
const row = { ...base, lat: 48.2, lon: -122.8 };
|
|
const h = harness(
|
|
{
|
|
getSnapshot({ signal, boxes }) {
|
|
requests.push({ signal, boxes });
|
|
return new Promise((resolve) => {
|
|
finishObservations = resolve;
|
|
});
|
|
},
|
|
async getGridSnapshot({ tiles, signal }) {
|
|
gridSets++;
|
|
assert.ok(tiles.length <= 6);
|
|
assert.equal(signal.aborted, false);
|
|
return {
|
|
cells: [
|
|
gridCell(tiles[0].z, {
|
|
id: wildlifeGridCellId(row.lat, row.lon, tiles[0].z),
|
|
lat: row.lat,
|
|
lon: row.lon,
|
|
}),
|
|
],
|
|
totalResults: 12,
|
|
fetchedAt: NOW,
|
|
};
|
|
},
|
|
},
|
|
{},
|
|
{ autoEnable: false },
|
|
);
|
|
const manager = new LayerLifecycle(null, { engine: h.engine });
|
|
manager.register(h.layer);
|
|
h.layer.attachDataManager(manager);
|
|
try {
|
|
const enabling = manager.setEnabled(h.layer.id, true);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(requests.length, 0);
|
|
h.time(NOW + 100);
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
h.moveEnd.emit();
|
|
assert.equal(h.timers.size, 1, 'one camera settle timer');
|
|
const [id, timer] = [...h.timers][0];
|
|
h.timers.delete(id);
|
|
h.time(NOW + 400);
|
|
timer.fn();
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(requests.length, 1);
|
|
assert.equal(requests[0].boxes[0].south, 48);
|
|
h.moveEnd.emit();
|
|
assert.equal(requests[0].signal.aborted, false);
|
|
h.time(NOW + 550); // Ordinary upstream response after 150 ms.
|
|
finishObservations([row]);
|
|
assert.equal(await enabling, true);
|
|
assert.equal(h.badges()[0]?.id, 'wildlife:inat:1');
|
|
assert.equal(requests.length, 1);
|
|
assert.equal(gridSets, 1);
|
|
assert.equal(
|
|
h.timers.size,
|
|
1,
|
|
'only the bounded density fade is scheduled',
|
|
);
|
|
t.diagnostic(
|
|
'Deterministic first badge: 550 ms (100 ms camera adjustment + 300 ms settle + 150 ms upstream); one observation set and one tile set, zero aborts.',
|
|
);
|
|
} finally {
|
|
finishObservations?.([row]);
|
|
await manager.destroyLayer(h.layer.id);
|
|
}
|
|
});
|
|
|
|
test('the real manager does not report a refresh error when a pan supersedes periodic acquisition', async () => {
|
|
let ready = true;
|
|
let settle;
|
|
const h = harness(
|
|
{
|
|
getSnapshot: async () => {
|
|
if (ready) return [base];
|
|
return new Promise((resolve) => {
|
|
settle = resolve;
|
|
});
|
|
},
|
|
},
|
|
{},
|
|
{ autoEnable: false },
|
|
);
|
|
const manager = new LayerLifecycle(null, { engine: h.engine });
|
|
manager.register(h.layer);
|
|
h.layer.attachDataManager(manager);
|
|
try {
|
|
const enabling = manager.setEnabled(h.layer.id, true);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const [id, timer] = [...h.timers][0];
|
|
h.timers.delete(id);
|
|
h.time(NOW + timer.delay);
|
|
timer.fn();
|
|
assert.equal(await enabling, true);
|
|
ready = false;
|
|
const refreshing = manager.refreshLayer(h.layer.id);
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
h.moveEnd.emit();
|
|
settle([base]);
|
|
assert.equal(await refreshing, true);
|
|
assert.equal(manager.isEnabled(h.layer.id), true);
|
|
assert.equal(manager.layers.get(h.layer.id).managerRefreshError, null);
|
|
assert.equal(h.layer.getStats().error, null);
|
|
} finally {
|
|
await manager.destroyLayer(h.layer.id);
|
|
}
|
|
});
|
|
|
|
test('legend keeps semantic order, omits zero groups and puts one blurb first; stats expose only contract fields', async () => {
|
|
const rows = [
|
|
base,
|
|
{ ...base, stableId: 'inat:2', iconic: 'Fungi', lon: -122.3 },
|
|
{ ...base, stableId: 'inat:3', iconic: 'Unknown', lon: -122.2 },
|
|
];
|
|
const h = harness({ getSnapshot: async () => rows });
|
|
await h.update();
|
|
const controls = h.layer.getRowControls();
|
|
assert.equal(controls.chips.length, 7);
|
|
assert.equal(controls.chips.filter((chip) => chip.label === 'ALL').length, 1);
|
|
assert.deepEqual(
|
|
controls.legend.map((entry) => entry.label),
|
|
['Birds', 'Fungi', 'Other or unknown'],
|
|
);
|
|
assert.deepEqual(
|
|
ICONIC_LEGEND_ORDER.filter((group) =>
|
|
['Aves', 'Fungi', 'Unknown'].includes(group),
|
|
),
|
|
['Aves', 'Fungi', 'Unknown'],
|
|
);
|
|
assert.equal(controls.legend.filter((entry) => entry.blurb).length, 1);
|
|
assert.match(controls.legend[0].blurb, /Not a census/);
|
|
const allowed = new Set([
|
|
'count',
|
|
'lastUpdate',
|
|
'error',
|
|
'stale',
|
|
'loading',
|
|
'refreshing',
|
|
'loadingLabel',
|
|
'partial',
|
|
'rawRowCount',
|
|
'countLabel',
|
|
'status',
|
|
'statusMessage',
|
|
'retryInSec',
|
|
]);
|
|
assert.ok(Object.keys(h.layer.getStats()).every((key) => allowed.has(key)));
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('filter chips keep failed desired params active, expose retry and activate normally after recovery', async () => {
|
|
let fail = false;
|
|
const h = harness({
|
|
getSnapshot: async () => {
|
|
if (fail) throw Error('iNaturalist HTTP 502');
|
|
return [base];
|
|
},
|
|
});
|
|
await h.update();
|
|
h.layer.setParams({ taxa: 'whales', confirmed: true, ignored: 'x' });
|
|
let chips = h.layer.getRowControls().chips;
|
|
const whale = () => chips.find((chip) => chip.id === 'taxa-whales');
|
|
assert.equal(whale().state, 'loading');
|
|
assert.equal(whale().active, false);
|
|
assert.equal(whale().disabled, true);
|
|
fail = true;
|
|
await h.update();
|
|
chips = h.layer.getRowControls().chips;
|
|
assert.equal(whale().state, 'error');
|
|
assert.equal(whale().disabled, false);
|
|
assert.deepEqual(h.layer.getParams(), { confirmed: true, taxa: 'whales' });
|
|
assert.deepEqual(chips[0].params, { confirmed: true });
|
|
fail = false;
|
|
assert.equal(whale().active, true);
|
|
h.layer.setParams(whale().params);
|
|
h.time(NOW + 31_000);
|
|
await h.update();
|
|
chips = h.layer.getRowControls().chips;
|
|
assert.equal(whale().state, 'active');
|
|
assert.equal(chips[0].active, true);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('disjoint option edits retain every unresolved chip through revert, failure, retry and success', async () => {
|
|
let fail = false;
|
|
const h = harness({
|
|
getSnapshot: async () => {
|
|
if (fail) throw Error('iNaturalist HTTP 502');
|
|
return [base];
|
|
},
|
|
});
|
|
await h.update();
|
|
const chip = (id) =>
|
|
h.layer.getRowControls().chips.find((item) => item.id === id);
|
|
h.layer.setParams({ confirmed: true });
|
|
h.layer.setParams({ taxa: 'Aves' });
|
|
for (const id of ['quality-confirmed', 'taxa-birds']) {
|
|
assert.equal(chip(id).state, 'loading');
|
|
assert.equal(chip(id).busy, true);
|
|
assert.equal(chip(id).disabled, true);
|
|
assert.equal(chip(id).active, false);
|
|
}
|
|
assert.equal(
|
|
chip('taxa-all').active,
|
|
true,
|
|
'the last accepted taxa remains active',
|
|
);
|
|
h.layer.setParams({ confirmed: false });
|
|
assert.equal(chip('quality-confirmed').state, 'idle');
|
|
assert.equal(chip('quality-confirmed').busy, false);
|
|
assert.equal(chip('taxa-birds').state, 'loading');
|
|
h.layer.setParams({ confirmed: true });
|
|
fail = true;
|
|
await h.update();
|
|
for (const id of ['quality-confirmed', 'taxa-birds']) {
|
|
assert.equal(chip(id).state, 'error');
|
|
assert.equal(chip(id).disabled, false);
|
|
assert.equal(chip(id).active, true);
|
|
assert.match(chip(id).title, /click to retry/);
|
|
}
|
|
assert.deepEqual(chip('quality-confirmed').params, { confirmed: true });
|
|
h.layer.setParams(chip('taxa-birds').params);
|
|
for (const id of ['quality-confirmed', 'taxa-birds'])
|
|
assert.equal(
|
|
chip(id).state,
|
|
'loading',
|
|
'unchanged desired params retry all unresolved options',
|
|
);
|
|
fail = false;
|
|
h.time(NOW + 31_000);
|
|
await h.update();
|
|
for (const id of ['quality-confirmed', 'taxa-birds']) {
|
|
assert.equal(chip(id).state, 'active');
|
|
assert.equal(chip(id).active, true);
|
|
assert.equal(chip(id).busy, false);
|
|
assert.equal(chip(id).disabled, false);
|
|
}
|
|
assert.equal(chip('taxa-all').active, false);
|
|
assert.deepEqual(h.layer.getParams(), { confirmed: true, taxa: 'Aves' });
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('the initial load keeps ALL pending and the default-off CONFIRMED chip idle', async () => {
|
|
let resolve;
|
|
const h = harness({
|
|
getSnapshot: () =>
|
|
new Promise((done) => {
|
|
resolve = done;
|
|
}),
|
|
});
|
|
const pending = h.update();
|
|
h.layer.setParams({ taxa: 'all', confirmed: false });
|
|
let chips = h.layer.getRowControls().chips;
|
|
assert.equal(chips.find((chip) => chip.id === 'taxa-all').state, 'loading');
|
|
assert.equal(
|
|
chips.find((chip) => chip.id === 'quality-confirmed').state,
|
|
'idle',
|
|
);
|
|
resolve([base]);
|
|
assert.equal(await pending, true);
|
|
chips = h.layer.getRowControls().chips;
|
|
assert.equal(chips.find((chip) => chip.id === 'taxa-all').state, 'active');
|
|
assert.equal(
|
|
chips.find((chip) => chip.id === 'quality-confirmed').state,
|
|
'idle',
|
|
);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('global fallback hides cards and upstream totals, and caps retained observations', async () => {
|
|
let options;
|
|
const h = harness({
|
|
getSnapshot: async (value) => {
|
|
options = value;
|
|
return Array.from({ length: WILDLIFE_MAX_ROWS + 2 }, (_, index) => ({
|
|
...photographed,
|
|
stableId: `inat:${index}`,
|
|
}));
|
|
},
|
|
});
|
|
h.height(5_000_000);
|
|
await h.update();
|
|
assert.equal(options.scope, 'global');
|
|
assert.equal(options.boxes, null);
|
|
assert.equal(h.layer.getStats().count, WILDLIFE_MAX_ROWS);
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'nominal');
|
|
assert.equal(h.layer.getStats().partial, undefined);
|
|
assert.match(h.layer.getStats().countLabel, /sightings in view/);
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings').length, 0);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('a missing regional query does not claim zoom guidance at a local camera height', async () => {
|
|
const h = harness({
|
|
getSnapshot: () => assert.fail('wide regional view fetched'),
|
|
});
|
|
h.rectangle({ south: 20, west: -150, north: 60, east: -90 });
|
|
assert.equal(await h.update(), true);
|
|
assert.equal(h.layer.getStats().status, undefined);
|
|
assert.equal(h.layer.getStats().statusMessage, undefined);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('a successful empty page keeps the selected observation until explicit deselection', async () => {
|
|
let rows = [base];
|
|
const h = harness({ getSnapshot: async () => rows });
|
|
await h.update();
|
|
h.layer.selectSighting(base.stableId);
|
|
rows = [];
|
|
await h.update();
|
|
assert.equal(h.badges().length, 1);
|
|
assert.equal(h.store.selectedEntityId, base.stableId);
|
|
h.layer.clearSightingSelection();
|
|
await h.update();
|
|
assert.equal(h.badges().length, 0);
|
|
assert.equal(h.store.selectedEntityId, null);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('provider credits sit in the layer row, never on the globe; Acartia failure still surfaces degradation', async () => {
|
|
let healthy = true;
|
|
const acartia = {
|
|
...base,
|
|
stableId: 'acartia:1',
|
|
origin: 'acartia',
|
|
iconic: 'Mammalia',
|
|
provider: { name: 'Synthetic Provider', entity: null },
|
|
};
|
|
const h = harness({
|
|
getSnapshot: async () => [],
|
|
getSnapshotDetail: async () => ({
|
|
rows: healthy ? [base, acartia] : [base],
|
|
sources: { acartia: { ok: healthy } },
|
|
}),
|
|
});
|
|
await h.update();
|
|
const onGlobe = () =>
|
|
h.engine.fake.credits.filter((credit) => credit.onScreen).length;
|
|
assert.equal(h.credits(), 1, 'the Acartia credit joins the attribution');
|
|
assert.equal(onGlobe(), 0, 'no credit on the globe credit line');
|
|
assert.equal(
|
|
h.layer.getRowControls().info,
|
|
'iNaturalist contributors · Acartia 1 (Salish Sea) · licences per record',
|
|
);
|
|
healthy = false;
|
|
await h.update();
|
|
assert.equal(h.layer.getStats().error, 'Acartia feed unavailable');
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'degraded');
|
|
assert.equal(
|
|
h.layer.getRowControls().info,
|
|
'iNaturalist contributors · licences per record',
|
|
);
|
|
assert.equal(onGlobe(), 0);
|
|
h.layer.disable();
|
|
assert.equal(onGlobe(), 0);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('an iNaturalist failure beside a good Acartia reply keeps both and reports degraded', async () => {
|
|
let inatHealthy = true;
|
|
const acartia = {
|
|
...base,
|
|
stableId: 'acartia:1',
|
|
origin: 'acartia',
|
|
iconic: 'Mammalia',
|
|
lon: -122.3,
|
|
provider: { name: 'Synthetic Provider', entity: null },
|
|
};
|
|
const failure = Object.assign(new Error('iNaturalist HTTP 502'), {
|
|
status: 502,
|
|
retryAfterSec: 30,
|
|
});
|
|
const h = harness({
|
|
getSnapshot: async () => [],
|
|
getSnapshotDetail: async ({ boxes }) => ({
|
|
rows: inatHealthy ? [base, acartia] : [acartia],
|
|
sources: {
|
|
inaturalist: inatHealthy
|
|
? { ok: true }
|
|
: { ok: false, error: failure, failedBoxes: boxes },
|
|
acartia: { ok: true },
|
|
},
|
|
}),
|
|
});
|
|
await h.update();
|
|
assert.equal(h.layer.getStats().count, 2);
|
|
inatHealthy = false;
|
|
await h.update();
|
|
// The failed iNaturalist area keeps its last rows; Acartia still refreshes.
|
|
assert.equal(h.layer.getStats().count, 2);
|
|
assert.equal(h.layer.getStats().error, 'iNaturalist HTTP 502');
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'degraded');
|
|
assert.equal(
|
|
h.layer.getRowControls().info,
|
|
'iNaturalist contributors · Acartia 1 (Salish Sea) · licences per record',
|
|
);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('ambient cards prefilter the horizon, spread over screen regions and retain visible slots', async () => {
|
|
const rows = Array.from({ length: 32 }, (_, i) => ({
|
|
...photographed,
|
|
stableId: `inat:${String(i + 1).padStart(2, '0')}`,
|
|
lon: -122.5 + i * 0.01,
|
|
favesCount: 1000 - i,
|
|
}));
|
|
const screens = new Map(
|
|
rows.map((row, i) => [
|
|
row.stableId,
|
|
{
|
|
x: 130 + (i % 8) * 150,
|
|
y: 130 + Math.floor(i / 8) * 150,
|
|
},
|
|
]),
|
|
);
|
|
rows.push(
|
|
{
|
|
...photographed,
|
|
stableId: 'inat:overlap',
|
|
lon: -122.17,
|
|
favesCount: 999.5,
|
|
},
|
|
{
|
|
...photographed,
|
|
stableId: 'inat:edge',
|
|
lon: -122.16,
|
|
favesCount: 999.25,
|
|
},
|
|
);
|
|
screens.set('inat:overlap', { x: 241, y: 130 }); // Same occupied region.
|
|
screens.set('inat:edge', { x: 130, y: 242 }); // Spacing alone cannot admit a second card in that region.
|
|
rows.unshift({
|
|
...photographed,
|
|
stableId: 'inat:far',
|
|
lon: -122.6,
|
|
favesCount: 100000,
|
|
});
|
|
const h = harness(
|
|
{ getSnapshot: async () => rows },
|
|
{
|
|
occluderFactory: () => ({
|
|
isPointVisible: (position) =>
|
|
toDegrees(cartographicOf(position).longitude) > -122.55,
|
|
}),
|
|
project: (_scene, position) =>
|
|
screens.get(
|
|
rows.find(
|
|
(row) =>
|
|
Math.abs(
|
|
row.lon - toDegrees(cartographicOf(position).longitude),
|
|
) < 1e-7,
|
|
)?.stableId,
|
|
),
|
|
},
|
|
);
|
|
await h.update();
|
|
const entries = h.overlay.entries.get('wildlife-sightings');
|
|
assert.equal(entries.length, 6);
|
|
const expected = [
|
|
'inat:01',
|
|
'inat:04',
|
|
'inat:07',
|
|
'inat:17',
|
|
'inat:20',
|
|
'inat:23',
|
|
];
|
|
const assertCohort = (cohort) => {
|
|
assert.deepEqual(
|
|
cohort.map((entry) => entry.id),
|
|
expected.map((id) => `sighting:${id}`),
|
|
);
|
|
for (let i = 0; i < cohort.length; i++) {
|
|
const a = screens.get(cohort[i].id.slice('sighting:'.length));
|
|
for (let j = i + 1; j < cohort.length; j++) {
|
|
const b = screens.get(cohort[j].id.slice('sighting:'.length));
|
|
assert.ok(
|
|
Math.hypot(a.x - b.x, a.y - b.y) >= 112,
|
|
`${cohort[i].id} overlaps ${cohort[j].id}`,
|
|
);
|
|
}
|
|
}
|
|
};
|
|
assertCohort(entries);
|
|
const farDot = h.badges().find((point) => point.id === 'wildlife:inat:far');
|
|
assert.ok(!farDot || farDot.show === false);
|
|
assert.equal(h.frameWork(), 1);
|
|
h.layer.selectSighting('inat:01');
|
|
const selected = h.overlay.entries.get('wildlife-sightings-selected');
|
|
h.moveEnd.emit();
|
|
assert.equal(
|
|
h.overlay.entries.get('wildlife-sightings-selected'),
|
|
selected,
|
|
'moveEnd never republishes selected cards',
|
|
);
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings').length, 6);
|
|
assertCohort(h.overlay.entries.get('wildlife-sightings'));
|
|
h.layer.destroy();
|
|
});
|
|
|
|
function gridCell(z, extra = {}) {
|
|
return {
|
|
id: wildlifeGridCellId(base.lat, base.lon, z),
|
|
lat: base.lat,
|
|
lon: base.lon,
|
|
cellCount: 12,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
// Keep request/selection fixtures compact enough for the six-tile budget.
|
|
function gridHarness(source, extra) {
|
|
return harness(source, extra, { width: 896, height: 896 });
|
|
}
|
|
|
|
test('observations publish real badges while grid acquisition is still pending', async () => {
|
|
let finishGrid;
|
|
const h = gridHarness({
|
|
getSnapshot: async () => [base],
|
|
getGridSnapshot: () =>
|
|
new Promise((resolve) => {
|
|
finishGrid = resolve;
|
|
}),
|
|
});
|
|
h.time(NOW + 500);
|
|
const updating = h.layer.update();
|
|
try {
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(h.badges()[0]?.id, 'wildlife:inat:1');
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
assert.equal(h.frameWork(), 1, 'only the shared surface observer');
|
|
} finally {
|
|
finishGrid({ cells: [], totalResults: 0, fetchedAt: NOW });
|
|
await updating;
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
h.layer.destroy();
|
|
}
|
|
});
|
|
|
|
test('each arriving tile extends the density glow before the remaining tiles finish', async () => {
|
|
let publishTile;
|
|
let finishGrid;
|
|
let cells;
|
|
let tiles;
|
|
const h = gridHarness({
|
|
getSnapshot: async () => [],
|
|
getGridSnapshot(options) {
|
|
publishTile = options.onTile;
|
|
tiles = options.tiles;
|
|
cells = [
|
|
gridCell(tiles[0].z),
|
|
gridCell(tiles[0].z, {
|
|
id: wildlifeGridCellId(base.lat, base.lon + 0.2, tiles[0].z),
|
|
lon: base.lon + 0.2,
|
|
cellCount: 9,
|
|
}),
|
|
];
|
|
return new Promise((resolve) => {
|
|
finishGrid = resolve;
|
|
});
|
|
},
|
|
});
|
|
h.time(NOW + 500);
|
|
const updating = h.layer.update();
|
|
try {
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
publishTile?.(
|
|
{ cells: [cells[0]], totalResults: 12, fetchedAt: NOW },
|
|
{ tile: tiles[0] },
|
|
);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(h.badges().length, 0);
|
|
assert.equal(h.glow().options.pickable, false);
|
|
assert.equal(h.glow().store.count, 1);
|
|
assert.equal(h.layer.getStats().countLabel, '12 sightings in view');
|
|
publishTile?.(
|
|
{ cells: [cells[1]], totalResults: 9, fetchedAt: NOW },
|
|
{ tile: tiles[1] || tiles[0] },
|
|
);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(h.badges().length, 0);
|
|
assert.equal(h.glow().store.count, 2);
|
|
assert.equal(h.layer.getStats().countLabel, '21 sightings in view');
|
|
assert.equal(h.frameWork(), 2, 'glow and the shared surface observer');
|
|
} finally {
|
|
finishGrid({ cells, totalResults: 21, fetchedAt: NOW });
|
|
await updating;
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
h.layer.destroy();
|
|
}
|
|
});
|
|
|
|
test('grid-only views draw nonpickable glow without observation badges, labels or cards', async () => {
|
|
const h = gridHarness({
|
|
getSnapshot: async () => [],
|
|
getGridSnapshot: async ({ tiles }) => ({
|
|
cells: [gridCell(tiles[0].z)],
|
|
totalResults: 12,
|
|
fetchedAt: NOW,
|
|
}),
|
|
});
|
|
h.height(1_500_000);
|
|
await h.update();
|
|
assert.equal(h.badges().length, 0);
|
|
const glow = h.glow();
|
|
assert.ok(glow);
|
|
assert.equal(glow.options.pickable, false);
|
|
assert.equal(glow.store.count, 1);
|
|
assert.equal(
|
|
glow.store.pickIds[0],
|
|
undefined,
|
|
'density has no pick identity',
|
|
);
|
|
assert.equal(h.layer.getStats().countLabel, '12 sightings in view');
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-labels'), []);
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-selected'), []);
|
|
assert.equal(h.focus.length, 0);
|
|
assert.equal(h.frameWork(), 2, 'glow and the shared surface observer');
|
|
h.layer.disable();
|
|
assert.equal(h.glow(), undefined);
|
|
assert.equal(h.frameWork(), 0);
|
|
assert.equal(h.timers.size, 0);
|
|
assert.deepEqual(h.engine.movers.list(), [], 'no glow remains');
|
|
h.layer.enable();
|
|
await h.update();
|
|
assert.ok(h.glow());
|
|
h.layer.destroy();
|
|
assert.equal(h.glow(), undefined);
|
|
assert.deepEqual(h.engine.movers.list(), []);
|
|
assert.equal(h.timers.size, 0);
|
|
});
|
|
|
|
test('height and upstream sample totals retain the same loaded sighting and grid count', async () => {
|
|
let partialSample = false;
|
|
let gridRequests = 0;
|
|
const h = gridHarness({
|
|
getSnapshot: async () => [base],
|
|
getSnapshotDetail: async () => ({
|
|
rows: [base],
|
|
totalResults: partialSample ? 100 : 1,
|
|
partial: partialSample,
|
|
}),
|
|
async getGridSnapshot({ tiles }) {
|
|
gridRequests++;
|
|
return {
|
|
cells: [gridCell(tiles[0].z)],
|
|
totalResults: 12,
|
|
fetchedAt: NOW,
|
|
};
|
|
},
|
|
});
|
|
await h.update();
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
h.height(450_000);
|
|
await h.update();
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
h.height(410_000);
|
|
h.moveEnd.emit();
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
h.height(350_000);
|
|
await h.update();
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
h.height(30_000);
|
|
partialSample = true;
|
|
await h.update();
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
assert.equal(gridRequests, 4);
|
|
assert.equal(h.layer.getStats().countLabel, '12 sightings in view');
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'nominal');
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('close and wide views wait for loaded common-name labels without unnamed label candidates or frame work', async (t) => {
|
|
for (const heightM of [30_000, 7_000_000]) {
|
|
let rows = [{ ...base, commonName: null }];
|
|
let projections = 0;
|
|
const h = gridHarness(
|
|
{
|
|
getSnapshot: async () => rows,
|
|
getGridSnapshot: async ({ tiles }) => ({
|
|
cells: [gridCell(tiles[0].z)],
|
|
fetchedAt: NOW,
|
|
}),
|
|
},
|
|
{
|
|
project() {
|
|
projections++;
|
|
return { x: 400, y: 400 };
|
|
},
|
|
},
|
|
);
|
|
t.after(() => h.layer.destroy());
|
|
h.height(heightM);
|
|
await h.update();
|
|
const point = h.badges()[0];
|
|
assert.ok(point, `${heightM}m: unnamed contacts still have icons`);
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-labels'), []);
|
|
// Only observation icons require screen projections; unnamed contacts
|
|
// never add the separate label candidate pass.
|
|
assert.equal(
|
|
projections,
|
|
1,
|
|
'only the real observation is projected; unnamed rows add no label pass',
|
|
);
|
|
|
|
rows = [{ ...base, commonName: 'Red-tailed Hawk' }];
|
|
await h.update();
|
|
assert.equal(
|
|
h.badges()[0].id,
|
|
point.id,
|
|
`${heightM}m: a newly known name reuses the icon`,
|
|
);
|
|
const labels = h.overlay.entries.get('wildlife-sightings-labels');
|
|
assert.equal(labels.length, 1);
|
|
assert.equal(labels[0].title, 'RED-TAILED HAWK');
|
|
assert.equal(labels[0].collisionGroup, 'ambient-label');
|
|
assert.equal(labels[0].protected, undefined);
|
|
assert.equal(labels[0].selected, undefined);
|
|
const settled = projections;
|
|
h.engine.fake.frames(10);
|
|
assert.equal(
|
|
projections,
|
|
settled,
|
|
`${heightM}m: parked frames never rebuild label candidates`,
|
|
);
|
|
|
|
rows = [{ ...base, commonName: ' ' }];
|
|
await h.update();
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-labels'), []);
|
|
h.layer.destroy();
|
|
}
|
|
});
|
|
|
|
test('selecting an unnamed observation preserves the selection without inventing a category label', async (t) => {
|
|
const h = harness({
|
|
getSnapshot: async () => [{ ...base, commonName: null }],
|
|
});
|
|
t.after(() => h.layer.destroy());
|
|
const selections = [];
|
|
h.layer.subscribeSelection((row) => selections.push(row));
|
|
await h.update();
|
|
h.pick({ id: h.badges()[0].id });
|
|
h.click({ position: { x: 400, y: 400 } });
|
|
assert.equal(selections.at(-1).stableId, base.stableId);
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-selected'), []);
|
|
assert.deepEqual(h.overlay.entries.get('wildlife-sightings-labels'), []);
|
|
});
|
|
|
|
test('unavailable grids fail closed to visible sampled sprites without a global newest-total claim', async () => {
|
|
const h = gridHarness({
|
|
getSnapshot: async () => [base],
|
|
getSnapshotDetail: async () => ({
|
|
rows: [base],
|
|
totalResults: 160645,
|
|
partial: true,
|
|
}),
|
|
getGridSnapshot: async () => {
|
|
throw Error('Malformed iNaturalist grid response');
|
|
},
|
|
});
|
|
h.height(5_000_000);
|
|
await h.update();
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
assert.ok(h.badgeSet().options.sprite.sizePx * 0.5 >= 8);
|
|
assert.equal(h.layer.getStats().count, 1);
|
|
assert.match(h.layer.getStats().countLabel, /sightings in view/);
|
|
assert.equal(h.layer.getStats().partial, undefined);
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'degraded');
|
|
assert.match(h.layer.getStats().error, /Malformed iNaturalist grid response/);
|
|
assert.equal(
|
|
h.layer.getStats().retryInSec,
|
|
undefined,
|
|
'schema errors do not start upstream cooldown',
|
|
);
|
|
assert.equal(
|
|
h.overlay.entries.get('wildlife-sightings-labels')[0].title,
|
|
'SYNTHETIC BIRD',
|
|
);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('an oversized view coarsens to a complete grid within the six-tile cap', async () => {
|
|
const h = harness(
|
|
{
|
|
getSnapshot: async () => [base],
|
|
getGridSnapshot: async ({ tiles }) => {
|
|
assert.ok(tiles.length > 0 && tiles.length <= 6);
|
|
return {
|
|
cells: [gridCell(tiles[0].z)],
|
|
totalResults: 12,
|
|
fetchedAt: NOW,
|
|
};
|
|
},
|
|
},
|
|
{ project: () => ({ x: 400, y: 400 }) },
|
|
{ width: 4000, height: 4000 },
|
|
);
|
|
h.rectangle({ south: -85, west: -180, north: 85, east: 180 });
|
|
h.height(7_000_000);
|
|
await h.update();
|
|
assert.equal(h.badges().length, 1);
|
|
assert.equal(h.badges()[0].id, 'wildlife:inat:1');
|
|
assert.match(h.layer.getStats().countLabel, /sightings in view/);
|
|
assert.equal(layerFeedState(h.layer.getStats()), 'nominal');
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('label candidates are bounded after on-screen and horizon filtering, with names only', async () => {
|
|
const rows = Array.from({ length: 220 }, (_, index) => ({
|
|
...base,
|
|
stableId: `inat:${index}`,
|
|
commonName: `Synthetic bird ${index}`,
|
|
lat: 47.5 + index / 2000,
|
|
lon: -122.5 + index / 2000,
|
|
}));
|
|
const h = harness(
|
|
{ getSnapshot: async () => rows },
|
|
{
|
|
project: (_scene, position) => ({
|
|
x:
|
|
cartographicOf(position).latitude > toRadians(47.6)
|
|
? 3000
|
|
: 30 +
|
|
(Math.round(
|
|
(toDegrees(cartographicOf(position).latitude) - 47.5) * 2000,
|
|
) %
|
|
50) *
|
|
28,
|
|
y:
|
|
30 +
|
|
Math.floor(
|
|
Math.round(
|
|
(toDegrees(cartographicOf(position).latitude) - 47.5) * 2000,
|
|
) / 50,
|
|
) *
|
|
28,
|
|
}),
|
|
occluderFactory: () => ({
|
|
isPointVisible: (position) =>
|
|
cartographicOf(position).latitude < toRadians(47.59),
|
|
}),
|
|
},
|
|
);
|
|
await h.update();
|
|
const labels = h.overlay.entries.get('wildlife-sightings-labels');
|
|
assert.equal(labels.length, 150);
|
|
assert.ok(
|
|
labels.every(
|
|
(entry) =>
|
|
entry.title.startsWith('SYNTHETIC BIRD ') &&
|
|
entry.details === undefined,
|
|
),
|
|
);
|
|
assert.ok(
|
|
labels.every(
|
|
(entry) => cartographicOf(entry.position).latitude < toRadians(47.59),
|
|
),
|
|
);
|
|
assert.equal(h.frameWork(), 1);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('accepted observation refreshes publish immediately and disable clears their badges', async () => {
|
|
let rows = [base];
|
|
const h = harness({ getSnapshot: async () => rows });
|
|
await h.update();
|
|
const point = h.badges()[0];
|
|
for (const lon of [-122.35, -122.3, -122.25]) {
|
|
rows = [{ ...base, lon }];
|
|
await h.layer.update();
|
|
assert.equal(h.badges()[0].id, point.id);
|
|
assert.ok(
|
|
Math.abs(cartographicOf(point.position).longitude - toRadians(lon)) <
|
|
1e-12,
|
|
);
|
|
assert.equal(h.timers.size, 0, 'observation rendering adds no batch delay');
|
|
}
|
|
h.layer.disable();
|
|
assert.equal(h.timers.size, 0);
|
|
assert.equal(h.badges().length, 0);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('a grid result for the previous global view cannot mark new camera tiles loaded', async () => {
|
|
let settle;
|
|
let requests = 0;
|
|
const h = gridHarness({
|
|
getSnapshot: async () => [base],
|
|
getGridSnapshot: ({ tiles }) => {
|
|
requests++;
|
|
return new Promise((resolve) => {
|
|
settle = () =>
|
|
resolve({
|
|
cells: [gridCell(tiles[0].z)],
|
|
totalResults: 12,
|
|
fetchedAt: NOW,
|
|
});
|
|
});
|
|
},
|
|
});
|
|
h.height(5_000_000);
|
|
h.time(NOW + 500);
|
|
const updating = h.layer.update();
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
h.rectangle({ south: -30, west: 60, north: 20, east: 120 });
|
|
settle();
|
|
await updating;
|
|
assert.equal(
|
|
h.badges().filter((point) => point.id.startsWith('wildlife:grid:')).length,
|
|
0,
|
|
'old tile result is rejected before moveEnd',
|
|
);
|
|
h.moveEnd.emit();
|
|
assert.equal(h.timers.size, 1, 'new camera view remains due for acquisition');
|
|
assert.equal(requests, 1);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('clearing a selected contact restores its cached ambient label without projecting candidates again', async () => {
|
|
let projects = 0;
|
|
const h = harness(undefined, {
|
|
project: () => {
|
|
projects++;
|
|
return { x: 400, y: 400 };
|
|
},
|
|
});
|
|
await h.update();
|
|
const baseline = projects;
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings-labels').length, 1);
|
|
h.pick({ id: 'wildlife:inat:1' });
|
|
const renders = h.renders.length;
|
|
h.click({ position: { x: 1, y: 1 } });
|
|
assert.equal(h.renders.length - renders, 1);
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings-labels').length, 0);
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings-selected').length, 1);
|
|
h.layer.clearSightingSelection();
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings-labels').length, 1);
|
|
assert.equal(h.overlay.entries.get('wildlife-sightings-selected').length, 0);
|
|
assert.equal(projects, baseline);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('visible photo cards survive a pan into the same icon bucket and a different random sample', async () => {
|
|
let rows = [
|
|
photographed,
|
|
{ ...photographed, stableId: 'inat:2', lon: -122.2 },
|
|
];
|
|
let collapsed = false;
|
|
const h = harness(
|
|
{ getSnapshot: async () => rows },
|
|
{
|
|
project: (_scene, position) => ({
|
|
x:
|
|
collapsed || toDegrees(cartographicOf(position).longitude) < -122.3
|
|
? 400
|
|
: 700,
|
|
y: 400,
|
|
}),
|
|
},
|
|
);
|
|
await h.update();
|
|
for (const image of h.images) image.onload?.();
|
|
const ids = () =>
|
|
h.overlay.entries
|
|
.get('wildlife-sightings')
|
|
.map((entry) => entry.id)
|
|
.sort();
|
|
const initial = ids();
|
|
assert.equal(initial.length, 2);
|
|
collapsed = true;
|
|
h.moveEnd.emit();
|
|
assert.equal(h.badges().length, 1, 'one icon in the shared bucket');
|
|
assert.deepEqual(
|
|
ids(),
|
|
initial,
|
|
'both visible incumbent photo cards keep their anchors',
|
|
);
|
|
rows = [];
|
|
await h.update();
|
|
assert.deepEqual(
|
|
ids(),
|
|
initial,
|
|
'a fresh random sample cannot evict visible cards',
|
|
);
|
|
assert.equal(
|
|
h.layer.selectSighting('inat:2'),
|
|
true,
|
|
'retained card remains selectable',
|
|
);
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('cold ground cells start on the ellipsoid and one bounded resolve per batch lifts them, without scene sampling', async () => {
|
|
const h = harness(undefined, {}, { autoEnable: false });
|
|
let warm = false;
|
|
let reads = 0;
|
|
h.ground.sample = () => {
|
|
reads++;
|
|
return warm ? 250 : null;
|
|
};
|
|
h.init();
|
|
h.layer.enable();
|
|
await h.update();
|
|
const point = h.badges()[0];
|
|
const pointHeight = () => heightOf(point.position);
|
|
assert.ok(
|
|
Math.abs(pointHeight()) < 0.01,
|
|
'cold cell anchors on the ellipsoid',
|
|
);
|
|
assert.equal(h.ground.resolves, 1, 'one bounded resolve for the batch');
|
|
warm = true;
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.ok(
|
|
Math.abs(pointHeight() - 250) < 0.01,
|
|
'resolved cell lifts in place',
|
|
);
|
|
assert.equal(h.badges()[0].id, point.id);
|
|
const before = reads;
|
|
h.moveEnd.emit();
|
|
assert.ok(reads - before <= h.badges().length);
|
|
assert.equal(h.ground.resolves, 1, 'warm cells do not resolve again');
|
|
h.layer.destroy();
|
|
});
|
|
|
|
test('an engine switch keeps the data and selection and redraws the same badges and glow on the next engine', async () => {
|
|
let requests = 0;
|
|
const rows = [
|
|
photographed,
|
|
{ ...base, stableId: 'inat:2', lon: -122.3, iconic: 'Mammalia' },
|
|
{
|
|
...base,
|
|
stableId: 'inat:3',
|
|
lon: -122.2,
|
|
obscured: true,
|
|
cell: { south: 47.5, west: -122.3, north: 47.7, east: -122.1 },
|
|
},
|
|
];
|
|
const h = harness({
|
|
getSnapshot: async () => {
|
|
requests++;
|
|
return rows;
|
|
},
|
|
getGridSnapshot: async ({ tiles }) => ({
|
|
cells: [gridCell(tiles[0].z)],
|
|
totalResults: 12,
|
|
fetchedAt: NOW,
|
|
}),
|
|
});
|
|
const firstCells = watchCells(h.engine);
|
|
await h.update();
|
|
assert.equal(h.layer.selectSighting('inat:1'), true);
|
|
const drawn = (engine) =>
|
|
h.badges(engine).map((badge) => ({
|
|
id: badge.id,
|
|
position: badge.position,
|
|
cell: badge.cell,
|
|
show: badge.show,
|
|
scale: badge.scale,
|
|
color: badge.color,
|
|
}));
|
|
const style = (engine) => {
|
|
const { options } = h.badgeSet(engine);
|
|
return {
|
|
order: options.order,
|
|
depthTest: options.depthTest,
|
|
pickable: options.pickable,
|
|
sizePx: options.sprite.sizePx,
|
|
scaleByDistance: [...options.sprite.scaleByDistance],
|
|
cells: options.sprite.atlas.cells,
|
|
};
|
|
};
|
|
const glow = (engine) => {
|
|
const set = engine.fake.moverSet(WILDLIFE_DENSITY_SET_ID);
|
|
return {
|
|
count: set.store.count,
|
|
pickable: set.options.pickable,
|
|
positions: [...set.store.positions.subarray(0, set.store.count * 3)],
|
|
};
|
|
};
|
|
const first = h.engine;
|
|
const before = drawn(first);
|
|
assert.equal(before.length, 3);
|
|
const beforeStyle = style(first);
|
|
const beforeGlow = glow(first);
|
|
assert.equal(beforeGlow.count, 1);
|
|
const cell = firstCells();
|
|
const stats = h.layer.getStats();
|
|
|
|
h.layer.detachRenderer();
|
|
assert.deepEqual(first.movers.list(), [], 'nothing stays drawn');
|
|
assert.deepEqual(first.lines.list(), []);
|
|
assert.deepEqual(first.ground.list(), []);
|
|
assert.equal(first.camera.moveEnd.numberOfListeners, 0);
|
|
assert.equal(first.frames.preRender.numberOfListeners, 0);
|
|
assert.equal(first.frames.postRender.numberOfListeners, 0);
|
|
assert.equal(h.inputs(), 0, 'no click listener on the old engine');
|
|
assert.equal(h.owners.size, 0);
|
|
assert.equal(h.overlay.visible.get('wildlife-sightings-selected'), false);
|
|
|
|
const other = ENGINE_KINDS.find((kind) => kind !== h.engine.kind);
|
|
const next = h.globe(other);
|
|
const nextCells = watchCells(next);
|
|
assert.equal(h.layer.attachRenderer({ engine: next }), true);
|
|
h.flushIdle();
|
|
assert.deepEqual(drawn(next), before, 'the same badges, drawn the same');
|
|
assert.deepEqual(style(next), beforeStyle);
|
|
assert.deepEqual(glow(next), beforeGlow);
|
|
assert.deepEqual(
|
|
nextCells().items,
|
|
cell.items,
|
|
'same draped cell colours and bounds',
|
|
);
|
|
assert.equal(requests, 1, 'the retained view needs no new request');
|
|
assert.equal(h.layer.getStats().count, stats.count);
|
|
assert.equal(
|
|
h.overlay.entries.get('wildlife-sightings-selected')[0].id,
|
|
'wildlife-sightings-label:inat:1',
|
|
'the selection carries over',
|
|
);
|
|
assert.equal(h.overlay.visible.get('wildlife-sightings-selected'), true);
|
|
assert.equal(h.owners.size, 1);
|
|
assert.equal(h.inputs(), 1);
|
|
|
|
h.pick({ id: 'wildlife:inat:2' });
|
|
next.fake.input('click', { position: { x: 1, y: 1 } });
|
|
assert.equal(
|
|
h.store.selectedEntityId,
|
|
'inat:2',
|
|
'clicks reach the new engine',
|
|
);
|
|
// The camera debounce is the one timer of 600 ms or more.
|
|
const debounces = () =>
|
|
[...h.timers.values()].filter(({ delay }) => delay >= 600).length;
|
|
h.rectangle({ south: 48, west: -123, north: 48.4, east: -122.6 });
|
|
first.fake.emit('camera.moveEnd');
|
|
assert.equal(debounces(), 0, 'the old camera is no longer followed');
|
|
next.fake.emit('camera.moveEnd');
|
|
assert.equal(debounces(), 1, 'the new camera schedules acquisition');
|
|
h.layer.destroy();
|
|
assert.deepEqual(next.movers.list(), []);
|
|
assert.deepEqual(next.lines.list(), []);
|
|
});
|