mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
Create pick registries and selection dispatchers for each scene attachment, publish them through scene.services, and release their predicates and input subscriptions before parking the renderer. Resolve layer ownership with the attached engine so identical layer IDs in simultaneous scenes cannot overwrite or remove one another. Re-register retained ALPR and cyclone picks on attachment, and resolve voice pointer picks against the engine that supplied the pick. Preserve Cesium's selection, sibling ownership, inert trails, touch expansion, drag and long-press rules on both engines. Extract the unchanged gesture predicates so portable picking does not acquire a native input dependency. Exercise scene isolation, teardown and reattachment on fake and headless Cesium engines, retaining the existing layer assertions. No coupling count falls or grows. Cesium and Navara renderer lines remain 0 and 189; external Cesium imports 3; viewer lines 910; Navara kind checks 2; engine sniff calls 0; extension reads 3; ground passes 1; SDK loads 3; screen-handler files 4; engine-name lines 33.
889 lines
29 KiB
JavaScript
889 lines
29 KiB
JavaScript
import { msg } from '../../i18n/marker.js';
|
|
import { getWildlifeHeightBand, rowInWildlifeBoxes } from './model.js';
|
|
import {
|
|
combineWildlifeGridSnapshots,
|
|
preferredWildlifeFailure,
|
|
wildlifeFailureDelayMs,
|
|
wildlifeFailures,
|
|
wildlifeRetryAfterMs,
|
|
} from './source.js';
|
|
import { wildlifeMeasure } from './performance.js';
|
|
import { isRecentWildlifeSighting } from './records.js';
|
|
import {
|
|
wildlifeGridViewportBoxes,
|
|
chooseWildlifeGridZoom,
|
|
wildlifeGridTiles,
|
|
wildlifeGridCellId,
|
|
} from './gridViewport.js';
|
|
import { wildlifeViewportBoxes, snapWildlifeBox } from './viewport.js';
|
|
import {
|
|
WILDLIFE_DEBOUNCE_MS,
|
|
WILDLIFE_MAX_ROWS,
|
|
WILDLIFE_GRID_HEIGHT_METERS,
|
|
} from './policy.js';
|
|
|
|
/** Manager-owned acquisition with camera debounce and guarded transactions. */
|
|
export function createLifecycle({ state, services, parts }) {
|
|
let requestQueryKey = null;
|
|
let removeManagerListener = null;
|
|
let lifetimeEpoch = 0;
|
|
let initialCameraDeadline = 0;
|
|
let initialSettle = null;
|
|
// The manager invokes update immediately after enable. Settle startup camera
|
|
// events before dispatching anything, then acquire only the resulting view.
|
|
const INITIAL_CAMERA_SETTLE_MS = 300;
|
|
|
|
function settleInitialCamera(signal) {
|
|
if (!initialCameraDeadline || services.now() >= initialCameraDeadline) {
|
|
initialCameraDeadline = 0;
|
|
return Promise.resolve();
|
|
}
|
|
return new Promise((resolve) => {
|
|
const finish = () => {
|
|
services.clearTimer(state.cameraTimer);
|
|
state.cameraTimer = null;
|
|
initialSettle = null;
|
|
initialCameraDeadline = 0;
|
|
signal?.removeEventListener('abort', finish);
|
|
resolve();
|
|
};
|
|
initialSettle = {
|
|
schedule() {
|
|
services.clearTimer(state.cameraTimer);
|
|
state.cameraTimer = services.setTimer(
|
|
finish,
|
|
Math.max(0, initialCameraDeadline - services.now()),
|
|
);
|
|
},
|
|
finish,
|
|
};
|
|
signal?.addEventListener('abort', finish, { once: true });
|
|
initialSettle.schedule();
|
|
});
|
|
}
|
|
|
|
function renderBatch(fn) {
|
|
parts.rendering.beginBatch?.();
|
|
try {
|
|
return fn();
|
|
} finally {
|
|
parts.rendering.endBatch?.();
|
|
}
|
|
}
|
|
|
|
function clearPending() {
|
|
if (!state.pendingParams) return;
|
|
if (state.error) state.failedParams = state.pendingParams;
|
|
state.pendingParams = null;
|
|
parts.controls.notify();
|
|
}
|
|
|
|
function failParams(params) {
|
|
// An acquisition can fail during an ordinary refresh, when no option is
|
|
// pending. Keep the chosen taxa visible and retryable in that case too.
|
|
state.failedParams = {
|
|
...params,
|
|
keys: [
|
|
...new Set([
|
|
...(state.pendingParams?.keys || []),
|
|
'taxa',
|
|
...(params.confirmed ? ['confirmed'] : []),
|
|
]),
|
|
],
|
|
};
|
|
state.pendingParams = null;
|
|
}
|
|
|
|
function applyRetry(
|
|
errors,
|
|
retryAfterSec = null,
|
|
previousMs = state.failures || 0,
|
|
) {
|
|
// Only 429/5xx failures impose cooldown; client, network and schema
|
|
// errors retry on pan. Several requests can fail together: wait for the
|
|
// longest effective delay among them.
|
|
const delays = [
|
|
...wildlifeFailures(errors).map((error) =>
|
|
wildlifeFailureDelayMs(error, previousMs),
|
|
),
|
|
wildlifeRetryAfterMs(retryAfterSec),
|
|
].filter((delay) => delay !== null);
|
|
if (!delays.length) {
|
|
state.failures = 0;
|
|
state.retryAt = 0;
|
|
return;
|
|
}
|
|
const backoff = Math.max(...delays);
|
|
state.failures = backoff;
|
|
state.retryAt = services.now() + backoff;
|
|
}
|
|
|
|
function pageHidden() {
|
|
return (
|
|
services.eventTarget?.document?.hidden || globalThis.document?.hidden
|
|
);
|
|
}
|
|
|
|
function currentQuery() {
|
|
const engine = state.engine;
|
|
const height = engine?.camera.height();
|
|
state.band = getWildlifeHeightBand(height ?? Infinity, state.band);
|
|
const boxes =
|
|
state.band === 'global'
|
|
? null
|
|
: wildlifeViewportBoxes(engine)?.map((box) => snapWildlifeBox(box));
|
|
const visibleBoxes = wildlifeGridViewportBoxes(engine);
|
|
const scope =
|
|
state.band === 'global' ||
|
|
(!boxes && (height ?? Infinity) > WILDLIFE_GRID_HEIGHT_METERS)
|
|
? 'global'
|
|
: 'view';
|
|
if (scope === 'view' && (!boxes?.length || boxes.some((box) => !box)))
|
|
return null;
|
|
const baseKey = JSON.stringify([
|
|
scope,
|
|
scope === 'global' ? null : boxes,
|
|
state.confirmed,
|
|
state.taxa,
|
|
]);
|
|
const size = engine?.host.size();
|
|
const zoom = visibleBoxes?.length
|
|
? chooseWildlifeGridZoom({
|
|
boxes: visibleBoxes,
|
|
width: size?.width || 1400,
|
|
height: size?.height || 900,
|
|
})
|
|
: 0;
|
|
const tiles = visibleBoxes?.length
|
|
? wildlifeGridTiles({ boxes: visibleBoxes, z: zoom })
|
|
: [];
|
|
return {
|
|
scope,
|
|
boxes: scope === 'global' ? null : boxes,
|
|
visibleBoxes,
|
|
tiles,
|
|
key: JSON.stringify([baseKey, tiles]),
|
|
};
|
|
}
|
|
|
|
function refreshView() {
|
|
const query = currentQuery();
|
|
const superseded = state.query?.key !== query?.key;
|
|
state.query = query;
|
|
if (superseded) {
|
|
state.request?.abort();
|
|
state.background?.abort();
|
|
}
|
|
// Keep the previous validated display while changing filters. Its rows
|
|
// and parameter chips are replaced together when acquisition succeeds.
|
|
renderBatch(() => {
|
|
const pending =
|
|
!state.pendingClear && parts.rendering.rebuild() === 'pending';
|
|
parts.rendering.cull();
|
|
if (pending) return;
|
|
parts.selection.refreshAmbient();
|
|
parts.selection.refreshContexts();
|
|
parts.selection.syncCredits();
|
|
});
|
|
return query;
|
|
}
|
|
|
|
async function refresh() {
|
|
if (!state.enabled || pageHidden()) {
|
|
clearPending();
|
|
return;
|
|
}
|
|
const controller = new AbortController();
|
|
const pendingParams = state.pendingParams;
|
|
state.background?.abort();
|
|
state.background = controller;
|
|
try {
|
|
if (state.manager)
|
|
await state.manager.refreshLayer('wildlife-sightings', {
|
|
signal: controller.signal,
|
|
});
|
|
else await methods.update(undefined, { signal: controller.signal });
|
|
} catch {
|
|
// update exposes expected source errors through stats; manager failures
|
|
// already have their own normalized status path.
|
|
} finally {
|
|
if (state.background === controller) {
|
|
state.background = null;
|
|
// A manager may decline acquisition while it is enabling, or the view
|
|
// may disappear before update. Only queued/in-flight work is busy.
|
|
if (
|
|
state.pendingParams === pendingParams &&
|
|
!state.loading &&
|
|
state.cameraTimer == null
|
|
)
|
|
clearPending();
|
|
}
|
|
}
|
|
}
|
|
|
|
function scheduleRefresh() {
|
|
services.clearTimer(state.cameraTimer);
|
|
state.cameraTimer = null;
|
|
if (!state.enabled || pageHidden()) {
|
|
clearPending();
|
|
return;
|
|
}
|
|
if (initialSettle) {
|
|
initialSettle.schedule();
|
|
return;
|
|
}
|
|
const query = currentQuery();
|
|
if (!query || query.key === state.lastQueryKey) {
|
|
clearPending();
|
|
return;
|
|
}
|
|
if (
|
|
query.key === requestQueryKey &&
|
|
state.request &&
|
|
!state.request.signal.aborted
|
|
)
|
|
return;
|
|
state.cameraTimer = services.setTimer(
|
|
() => {
|
|
state.cameraTimer = null;
|
|
if (!state.enabled || pageHidden()) {
|
|
clearPending();
|
|
return;
|
|
}
|
|
const query = currentQuery();
|
|
if (!query || query.key === state.lastQueryKey) {
|
|
clearPending();
|
|
return;
|
|
}
|
|
if (
|
|
query.key === requestQueryKey &&
|
|
state.request &&
|
|
!state.request.signal.aborted
|
|
)
|
|
return;
|
|
if (services.now() < state.retryAt) {
|
|
scheduleRefresh();
|
|
return;
|
|
}
|
|
void refresh();
|
|
},
|
|
Math.max(WILDLIFE_DEBOUNCE_MS, state.retryAt - services.now()),
|
|
);
|
|
}
|
|
|
|
function applyAccepted({
|
|
snapshot,
|
|
grid,
|
|
gridError,
|
|
query,
|
|
params,
|
|
request,
|
|
signal,
|
|
epoch,
|
|
previousFailures,
|
|
replaceRows = true,
|
|
}) {
|
|
const current = currentQuery();
|
|
if (
|
|
!state.enabled ||
|
|
state.destroyed ||
|
|
epoch !== lifetimeEpoch ||
|
|
request.signal.aborted ||
|
|
signal?.aborted ||
|
|
params.taxa !== state.taxa ||
|
|
params.confirmed !== state.confirmed ||
|
|
current?.key !== query.key
|
|
)
|
|
return;
|
|
renderBatch(() => {
|
|
const sameParams =
|
|
params.taxa === state.drawnParams?.taxa &&
|
|
params.confirmed === state.drawnParams?.confirmed;
|
|
const gridParams = state.gridParams || state.drawnParams;
|
|
const sameGridParams =
|
|
params.taxa === gridParams?.taxa &&
|
|
params.confirmed === gridParams?.confirmed;
|
|
// Tiles may beat a slow observation page. Publish their density without
|
|
// replacing observations or claiming their filter transaction succeeded.
|
|
// A pending filter keeps its previous display until both paths agree.
|
|
if (!snapshot) {
|
|
if (state.drawnParams && !sameParams) return;
|
|
if (grid) {
|
|
state.gridCells = grid.cells || [];
|
|
state.gridParams = params;
|
|
state.gridAvailable = true;
|
|
state.gridTotal = grid.totalResults || 0;
|
|
if (state.lastUpdate == null)
|
|
state.lastUpdate = Number.isFinite(grid.fetchedAt)
|
|
? grid.fetchedAt
|
|
: services.now();
|
|
const pendingRender = parts.rendering.rebuild() === 'pending';
|
|
if (!pendingRender) {
|
|
parts.selection.refreshAmbient();
|
|
parts.selection.publishSelected();
|
|
parts.selection.refreshContexts();
|
|
parts.selection.syncCredits();
|
|
}
|
|
parts.controls.notify();
|
|
}
|
|
return;
|
|
}
|
|
if (replaceRows) {
|
|
if (state.selectedId && !state.selectedRow)
|
|
state.selectedRow =
|
|
state.rowById.get(state.selectedId) ||
|
|
state.rows.get(state.selectedId) ||
|
|
null;
|
|
const retainedRows = sameParams
|
|
? (parts.selection.retainedAmbientRows?.() || []).filter(
|
|
(row) =>
|
|
state.rows.has(row.stableId) &&
|
|
isRecentWildlifeSighting(row, services.now(), params.taxa),
|
|
)
|
|
: [];
|
|
const retainedIds = new Set(retainedRows.map((row) => row.stableId));
|
|
if (state.selectedRow) retainedIds.add(state.selectedRow.stableId);
|
|
if (state.pendingClear || state.loadedScope !== query.scope)
|
|
state.rows.clear();
|
|
state.loadedScope = query.scope;
|
|
state.pendingClear = false;
|
|
// A successful page replaces this queried area, including a healthy
|
|
// empty page. Keep only other visited areas in the bounded LRU. Areas
|
|
// whose iNaturalist request failed keep their last iNaturalist rows.
|
|
const inat = snapshot.sources?.inaturalist;
|
|
const failedInatBoxes =
|
|
inat?.ok === false ? inat.failedBoxes || query.boxes : null;
|
|
for (const [id, row] of state.rows) {
|
|
if (
|
|
failedInatBoxes &&
|
|
row.origin === 'inaturalist' &&
|
|
rowInWildlifeBoxes(row, failedInatBoxes, 0)
|
|
)
|
|
continue;
|
|
if (rowInWildlifeBoxes(row, query.boxes, 0)) state.rows.delete(id);
|
|
}
|
|
for (const row of snapshot.rows) {
|
|
state.rows.delete(row.stableId);
|
|
state.rows.set(row.stableId, row);
|
|
if (row.stableId === state.selectedId) state.selectedRow = row;
|
|
}
|
|
// Selection owns a real observation until explicit deselection. It is
|
|
// independent of sample/window/filter and ambient-card eligibility.
|
|
if (state.selectedRow && !state.rows.has(state.selectedId))
|
|
state.rows.set(state.selectedId, state.selectedRow);
|
|
// Random samples may omit a photograph already displayed. Its bounded
|
|
// incumbent row stays selectable until the card leaves the view/window.
|
|
for (const row of retainedRows) {
|
|
if (!state.rows.has(row.stableId)) state.rows.set(row.stableId, row);
|
|
}
|
|
if (state.rows.size > WILDLIFE_MAX_ROWS) {
|
|
for (const id of state.rows.keys()) {
|
|
if (!retainedIds.has(id)) state.rows.delete(id);
|
|
if (state.rows.size <= WILDLIFE_MAX_ROWS) break;
|
|
}
|
|
}
|
|
if (state.rows.size > WILDLIFE_MAX_ROWS) {
|
|
for (const id of state.rows.keys()) {
|
|
if (id !== state.selectedId) state.rows.delete(id);
|
|
if (state.rows.size <= WILDLIFE_MAX_ROWS) break;
|
|
}
|
|
}
|
|
}
|
|
const failedStale = [snapshot, grid].filter(
|
|
(value) =>
|
|
value?.stale === true &&
|
|
Number.isFinite(value.retryAfterSec) &&
|
|
(value.upstreamStatus === undefined ||
|
|
value.upstreamStatus === 429 ||
|
|
value.upstreamStatus >= 500),
|
|
);
|
|
// The filter above admits only 429/5xx or an unmarked stale answer.
|
|
const staleError = failedStale.length
|
|
? Object.assign(
|
|
new Error(msg('Wildlife sightings source unavailable')),
|
|
{
|
|
upstreamStatus: Math.max(
|
|
...failedStale.map((value) => value.upstreamStatus || 503),
|
|
),
|
|
retryAfterSec: Math.max(
|
|
...failedStale.map((value) => value.retryAfterSec),
|
|
),
|
|
},
|
|
)
|
|
: null;
|
|
const inat = snapshot.sources?.inaturalist;
|
|
const acartia = snapshot.sources?.acartia;
|
|
// Keep each failed request's status and Retry-After; the displayed
|
|
// error is the one whose effective delay sets the cooldown.
|
|
const sourceErrors = [
|
|
gridError,
|
|
staleError,
|
|
inat?.ok === false
|
|
? inat.error ||
|
|
new Error(msg('Wildlife sightings source unavailable'))
|
|
: null,
|
|
acartia?.ok === false
|
|
? Object.assign(new Error(msg('Acartia feed unavailable')), {
|
|
...(acartia.error?.status
|
|
? { status: acartia.error.status }
|
|
: {}),
|
|
...(acartia.error?.upstreamStatus
|
|
? { upstreamStatus: acartia.error.upstreamStatus }
|
|
: {}),
|
|
...(Number.isFinite(acartia.error?.retryAfterSec)
|
|
? { retryAfterSec: acartia.error.retryAfterSec }
|
|
: {}),
|
|
})
|
|
: null,
|
|
].filter(Boolean);
|
|
const sourceError = preferredWildlifeFailure(
|
|
sourceErrors,
|
|
previousFailures,
|
|
);
|
|
state.stale =
|
|
!sourceError && (snapshot.stale === true || grid?.stale === true);
|
|
const fetchedAt = [snapshot.fetchedAt, grid?.fetchedAt].filter(
|
|
Number.isFinite,
|
|
);
|
|
state.lastUpdate =
|
|
(snapshot.stale === true || grid?.stale === true) && fetchedAt.length
|
|
? Math.min(...fetchedAt)
|
|
: services.now();
|
|
state.error = sourceError?.message || null;
|
|
state.drawnParams = params;
|
|
const retryAfter = [snapshot, grid]
|
|
.filter(
|
|
(value) =>
|
|
value &&
|
|
(value.upstreamStatus === undefined ||
|
|
value.upstreamStatus === 429 ||
|
|
value.upstreamStatus >= 500),
|
|
)
|
|
.map((value) => value.retryAfterSec)
|
|
.filter(Number.isFinite);
|
|
if (sourceError) {
|
|
failParams(params);
|
|
applyRetry(
|
|
sourceErrors,
|
|
retryAfter.length ? Math.max(...retryAfter) : null,
|
|
previousFailures,
|
|
);
|
|
} else {
|
|
state.pendingParams = null;
|
|
state.failedParams = null;
|
|
state.retryAt = retryAfter.length
|
|
? services.now() + wildlifeRetryAfterMs(Math.max(...retryAfter))
|
|
: 0;
|
|
state.failures = 0;
|
|
}
|
|
state.query = currentQuery();
|
|
if (grid !== undefined || !sameGridParams) {
|
|
state.gridCells = grid?.cells || [];
|
|
state.gridParams = grid ? params : null;
|
|
state.gridAvailable = !!grid;
|
|
state.gridTotal = grid?.totalResults || 0;
|
|
}
|
|
const pendingRender = parts.rendering.rebuild() === 'pending';
|
|
if (pendingRender) {
|
|
state.lastQueryKey = sourceError ? null : state.query?.key || query.key;
|
|
parts.controls.notify();
|
|
return;
|
|
}
|
|
parts.selection.refreshAmbient();
|
|
parts.selection.publishSelected();
|
|
parts.selection.notify();
|
|
parts.selection.refreshContexts();
|
|
parts.selection.syncCredits();
|
|
state.lastQueryKey = sourceError ? null : state.query?.key || query.key;
|
|
parts.controls.notify();
|
|
});
|
|
}
|
|
|
|
function onMoveEnd() {
|
|
if (!state.enabled) return;
|
|
wildlifeMeasure('moveEnd', () => {
|
|
if (initialCameraDeadline && services.now() < initialCameraDeadline) {
|
|
initialCameraDeadline = services.now() + INITIAL_CAMERA_SETTLE_MS;
|
|
refreshView();
|
|
initialSettle?.schedule();
|
|
} else {
|
|
refreshView();
|
|
scheduleRefresh();
|
|
}
|
|
parts.controls.notify();
|
|
});
|
|
}
|
|
|
|
// Draw the retained observations on the attached engine and listen to it.
|
|
function attachScene() {
|
|
parts.rendering.activate?.();
|
|
refreshView();
|
|
for (const id of parts.selection.sourceIds)
|
|
services.overlayHost?.setVisible?.(id, true);
|
|
parts.selection.install();
|
|
services.picking?.registerPickOwner?.(
|
|
'wildlife-sightings',
|
|
(id) =>
|
|
typeof id === 'string' &&
|
|
id.startsWith('wildlife:') &&
|
|
state.rowById.has(id.slice(9)),
|
|
state.engine,
|
|
);
|
|
state.removeCamera =
|
|
state.engine.camera.moveEnd.addEventListener(onMoveEnd);
|
|
}
|
|
|
|
function releaseScene() {
|
|
state.removeCamera?.();
|
|
state.removeCamera = null;
|
|
parts.rendering.deactivate?.();
|
|
parts.selection.uninstall?.();
|
|
services.picking?.unregisterPickOwner?.('wildlife-sightings', state.engine);
|
|
}
|
|
|
|
// Requests, timers and debounces in flight end with their scene or lifetime.
|
|
function stopAcquisition() {
|
|
lifetimeEpoch += 1;
|
|
initialSettle?.finish();
|
|
initialCameraDeadline = 0;
|
|
services.clearTimer(state.cameraTimer);
|
|
state.cameraTimer = null;
|
|
state.request?.abort();
|
|
state.request = null;
|
|
requestQueryKey = null;
|
|
state.background?.abort();
|
|
state.background = null;
|
|
state.loading = false;
|
|
clearPending();
|
|
}
|
|
|
|
function disable() {
|
|
stopAcquisition();
|
|
state.enabled = false;
|
|
clearPending();
|
|
releaseScene();
|
|
removeManagerListener?.();
|
|
removeManagerListener = null;
|
|
parts.selection.remove();
|
|
parts.rendering.clear();
|
|
parts.photos.clear();
|
|
parts.controls.notify();
|
|
parts.rendering.requestRender('disable');
|
|
return true;
|
|
}
|
|
|
|
const methods = {
|
|
/** Attach this layer to the scene's globe engine. */
|
|
init(_viewer, options = {}) {
|
|
if (state.engine)
|
|
throw new Error('Wildlife sightings layer is already initialized');
|
|
return methods.attachRenderer(_viewer, options);
|
|
},
|
|
/** Draw on `engine` (a scene switch brings another); observations,
|
|
* filters and selection carry over. */
|
|
attachRenderer(_viewer, { engine = null, signal = null } = {}) {
|
|
if (state.destroyed || signal?.aborted) return false;
|
|
if (state.engine)
|
|
throw new Error('Wildlife sightings display is already attached');
|
|
if (!engine)
|
|
throw new TypeError('Wildlife sightings need a globe engine');
|
|
state.engine = engine;
|
|
parts.rendering.init();
|
|
if (state.enabled) {
|
|
attachScene();
|
|
if (state.selectedId) {
|
|
parts.selection.publishSelected();
|
|
parts.selection.notify();
|
|
}
|
|
scheduleRefresh();
|
|
parts.controls.notify();
|
|
}
|
|
return true;
|
|
},
|
|
/** Release everything drawn on the engine; the data stays. */
|
|
detachRenderer() {
|
|
if (!state.engine) return;
|
|
stopAcquisition();
|
|
if (state.enabled) {
|
|
releaseScene();
|
|
parts.selection.detach();
|
|
}
|
|
parts.rendering.destroy();
|
|
state.engine = null;
|
|
parts.controls.notify();
|
|
},
|
|
/** Show retained observations and acquire the settled camera view. */
|
|
enable(_viewer, { signal } = {}) {
|
|
if (state.destroyed || signal?.aborted) return false;
|
|
if (!state.engine)
|
|
throw new Error('Wildlife sightings layer must be initialized');
|
|
if (state.enabled) return true;
|
|
state.enabled = true;
|
|
initialCameraDeadline = services.now() + INITIAL_CAMERA_SETTLE_MS;
|
|
attachScene();
|
|
// A debounce can expire while the manager is still enabling and cannot
|
|
// accept refreshLayer yet. Its settled visibility event is the one
|
|
// catch-up edge; completed initial queries are skipped by their key.
|
|
removeManagerListener =
|
|
state.manager?.subscribe?.((change) => {
|
|
if (
|
|
change.type === 'visibility' &&
|
|
change.layerId === 'wildlife-sightings' &&
|
|
change.enabled === true &&
|
|
state.enabled
|
|
)
|
|
scheduleRefresh();
|
|
}) || null;
|
|
return true;
|
|
},
|
|
/** Refresh observations and density independently for the current filters. */
|
|
async update(_viewer, { signal } = {}) {
|
|
if (
|
|
!state.enabled ||
|
|
!state.engine ||
|
|
state.destroyed ||
|
|
signal?.aborted
|
|
) {
|
|
if (!state.request) clearPending();
|
|
return false;
|
|
}
|
|
if (initialCameraDeadline && services.now() < initialCameraDeadline)
|
|
await settleInitialCamera(signal);
|
|
initialCameraDeadline = 0;
|
|
if (!state.enabled || state.destroyed || signal?.aborted) return false;
|
|
const query = currentQuery();
|
|
state.query = query;
|
|
if (!query || pageHidden()) {
|
|
clearPending();
|
|
return true;
|
|
}
|
|
if (services.now() < state.retryAt) {
|
|
if (state.pendingParams && state.cameraTimer == null) scheduleRefresh();
|
|
return true;
|
|
}
|
|
if (
|
|
requestQueryKey === query.key &&
|
|
state.request &&
|
|
!state.request.signal.aborted
|
|
)
|
|
return true;
|
|
state.request?.abort();
|
|
const request = new AbortController();
|
|
const requestLifetime = lifetimeEpoch;
|
|
// One acquisition publishes several times (tiles, rows, final grid).
|
|
// Each derives its default backoff from the backoff before it started.
|
|
const previousFailures = state.failures || 0;
|
|
const supersededResult = () =>
|
|
state.enabled &&
|
|
!state.destroyed &&
|
|
lifetimeEpoch === requestLifetime &&
|
|
!signal?.aborted;
|
|
state.request = request;
|
|
requestQueryKey = query.key;
|
|
const onAbort = () => request.abort(signal.reason);
|
|
signal?.addEventListener?.('abort', onAbort, { once: true });
|
|
const params = { confirmed: state.confirmed, taxa: state.taxa };
|
|
state.loading = true;
|
|
if (!state.pendingParams) {
|
|
const drawn = state.drawnParams || { confirmed: false, taxa: null };
|
|
const keys = ['confirmed', 'taxa'].filter(
|
|
(key) => params[key] !== drawn[key],
|
|
);
|
|
if (keys.length) state.pendingParams = { ...params, keys };
|
|
}
|
|
parts.controls.notify();
|
|
let received = false;
|
|
let gridPending = false;
|
|
let acceptedSnapshot = null;
|
|
let gridRequest = null;
|
|
let gridResult = null;
|
|
const tileSnapshots = new Map();
|
|
const gridParams = state.gridParams || state.drawnParams;
|
|
const retainedGrid =
|
|
params.taxa === gridParams?.taxa &&
|
|
params.confirmed === gridParams?.confirmed
|
|
? state.gridCells || []
|
|
: [];
|
|
function aggregateTiles(complete = false) {
|
|
if (!tileSnapshots.size) return undefined;
|
|
const grid = combineWildlifeGridSnapshots([...tileSnapshots.values()]);
|
|
if (!complete && retainedGrid.length) {
|
|
const zoom = query.tiles[0]?.z;
|
|
const covered = new Set(tileSnapshots.keys());
|
|
const retained = retainedGrid.filter(
|
|
(cell) =>
|
|
!covered.has(
|
|
wildlifeGridCellId(cell.lat, cell.lon, zoom)?.split(':')[1],
|
|
),
|
|
);
|
|
return combineWildlifeGridSnapshots([
|
|
{ ...grid, cells: [...retained, ...grid.cells] },
|
|
]);
|
|
}
|
|
return grid;
|
|
}
|
|
function completedGrid(value) {
|
|
if (!value) return value;
|
|
const aggregate = aggregateTiles(!value.error);
|
|
return aggregate
|
|
? combineWildlifeGridSnapshots([aggregate, value], value.error)
|
|
: value;
|
|
}
|
|
function publish(grid, gridError = null, replaceRows = false) {
|
|
applyAccepted({
|
|
snapshot: acceptedSnapshot,
|
|
grid,
|
|
gridError,
|
|
replaceRows,
|
|
query,
|
|
params,
|
|
request,
|
|
signal,
|
|
epoch: requestLifetime,
|
|
previousFailures,
|
|
});
|
|
}
|
|
function finishTiles() {
|
|
signal?.removeEventListener?.('abort', onAbort);
|
|
if (state.request === request) {
|
|
state.request = null;
|
|
requestQueryKey = null;
|
|
state.loading = false;
|
|
if (request.signal.aborted && state.cameraTimer == null)
|
|
clearPending();
|
|
parts.controls.notify();
|
|
}
|
|
}
|
|
function continueTiles() {
|
|
if (!gridRequest || gridResult) return;
|
|
gridPending = true;
|
|
void gridRequest
|
|
.then((result) => {
|
|
if (
|
|
acceptedSnapshot &&
|
|
!request.signal.aborted &&
|
|
state.request === request &&
|
|
state.enabled
|
|
)
|
|
publish(result?.value, result?.error || result?.value?.error);
|
|
})
|
|
.finally(finishTiles);
|
|
}
|
|
try {
|
|
const options = {
|
|
signal: request.signal,
|
|
boxes: query.boxes,
|
|
box: query.boxes?.[0] || null,
|
|
scope: query.scope,
|
|
...params,
|
|
};
|
|
// Observation requests enter the shared proxy queue first. A slow tile
|
|
// never holds the manager's initial enable or the first observations.
|
|
const observationRequest =
|
|
typeof services.source.getSnapshotDetail === 'function'
|
|
? services.source.getSnapshotDetail(options)
|
|
: Promise.resolve(services.source.getSnapshot(options)).then(
|
|
(rows) => ({ rows, stale: false, fetchedAt: services.now() }),
|
|
);
|
|
const hasGrid =
|
|
typeof services.source.getGridSnapshot === 'function' &&
|
|
query.tiles.length;
|
|
gridRequest = hasGrid
|
|
? services.source
|
|
.getGridSnapshot({
|
|
signal: request.signal,
|
|
tiles: query.tiles,
|
|
...params,
|
|
onTile(value, { tile }) {
|
|
if (request.signal.aborted || state.request !== request)
|
|
return;
|
|
tileSnapshots.set(`${tile.z}/${tile.x}/${tile.y}`, value);
|
|
publish(aggregateTiles());
|
|
},
|
|
})
|
|
.then(
|
|
(value) => {
|
|
gridResult = { value: completedGrid(value) };
|
|
if (!acceptedSnapshot)
|
|
publish(gridResult.value, value?.error);
|
|
return gridResult;
|
|
},
|
|
(error) => (gridResult = { error }),
|
|
)
|
|
: null;
|
|
const snapshot = await observationRequest;
|
|
if (
|
|
request.signal.aborted ||
|
|
state.request !== request ||
|
|
!state.enabled
|
|
)
|
|
return supersededResult();
|
|
if (!Array.isArray(snapshot?.rows))
|
|
throw new Error('Malformed iNaturalist response');
|
|
received = true;
|
|
acceptedSnapshot = snapshot;
|
|
publish(
|
|
gridResult?.value || aggregateTiles(),
|
|
gridResult?.error || gridResult?.value?.error,
|
|
true,
|
|
);
|
|
if (hasGrid && !gridResult) {
|
|
continueTiles();
|
|
} else if (gridResult && !gridResult.value && gridResult.error) {
|
|
// Observation rows remain visible when the first tile set fails.
|
|
publish(undefined, gridResult.error);
|
|
}
|
|
return true;
|
|
} catch (error) {
|
|
if (
|
|
request.signal.aborted ||
|
|
state.request !== request ||
|
|
!state.enabled
|
|
)
|
|
return supersededResult();
|
|
if (received) throw error;
|
|
// Observation failures must not cancel independent density tiles.
|
|
continueTiles();
|
|
state.stale = false;
|
|
state.error =
|
|
preferredWildlifeFailure(error, previousFailures)?.message ||
|
|
msg('Wildlife sightings source unavailable');
|
|
failParams(params);
|
|
state.lastQueryKey = null;
|
|
requestQueryKey = null;
|
|
applyRetry(error, null, previousFailures);
|
|
console.warn('[Data:WildlifeSightings] Update failed:', state.error);
|
|
return true;
|
|
} finally {
|
|
if (!gridPending) finishTiles();
|
|
}
|
|
},
|
|
/** Stop acquisition and release visible resources while retaining filters. */
|
|
disable,
|
|
/** Release requests, subscriptions, caches and scene resources. */
|
|
destroy() {
|
|
if (state.destroyed) return;
|
|
disable();
|
|
methods.detachRenderer();
|
|
state.destroyed = true;
|
|
parts.selection.destroy();
|
|
parts.photos.destroy();
|
|
parts.rendering.destroy();
|
|
state.rows.clear();
|
|
state.lastUpdate = null;
|
|
state.error = null;
|
|
state.stale = false;
|
|
state.drawnParams = null;
|
|
state.gridParams = null;
|
|
state.pendingParams = null;
|
|
state.failedParams = null;
|
|
state.controlsListener = null;
|
|
state.manager = null;
|
|
},
|
|
};
|
|
return {
|
|
methods,
|
|
scheduleRefresh,
|
|
};
|
|
}
|