import * as Cesium from 'cesium'; import { createState } from './state.js'; import { createMarker } from './marker.js'; import { createCameraFraming } from './cameraFraming.js'; import { createCredits } from './credits.js'; import { createPickRouter } from './pickRouter.js'; import { createSelection } from './selection.js'; import { createViewerHost } from './viewerHost.js'; import { filtersOf, requiresKeyIdFor, validateProviders } from './registry.js'; import { normalizeFilter, resolveFilter, sameFilter } from './filter.js'; import { worldTimeFor } from '../../time/worldClock.js'; import { decodeParams, encodeParams } from './params.js'; import { composeUIState, keyAlternatives, summarizeCoverage, } from './uiState.js'; import { groundUnderCamera, metresBetween, viewCentre } from './view.js'; import { createGroundClick, groundClickHeightOk } from './groundClick.js'; import { msg, t, translateKnown } from '../../i18n/index.js'; import { AIM_AT_GROUND_MESSAGE, keyStatusLabel, NEAREST_RADIUS_M, NEAREST_RADIUS_MAX_M, POSITION_PICK_ID, STREET_LEVEL_LAYER_ID, } from './policy.js'; export { STREET_LEVEL_LAYER_ID } from './policy.js'; /** Longest wait for a provider's key status; past it, the provider decides. */ const KEY_STATUS_TIMEOUT_MS = 10_000; /** Re-measures of a ground not loaded yet (Google 3D), a second apart. */ const GROUND_RETRY_LIMIT = 5; const GROUND_RETRY_MS = 1000; /** * An armed point stays the OPEN button's target while the view centre is * this close to it (m); a user who moved on opens what the view shows now. */ const ARMED_REACH_M = 1000; /** * The Street Level layer over imagery providers (contract in registry.js). * The core owns what they share: the filter and switches, the photo viewer * host, the position marker, the click handler and nearest-image lookups. * Providers own coverage, sequences and their viewer. One source is lit at * a time. * @param {{providers: Array, services?: object}} options */ // "Since N days" counts back from the world time. const streetLevelTime = worldTimeFor(STREET_LEVEL_LAYER_ID); export function createStreetLevelLayer({ providers: definitions, services = {}, }) { const defs = validateProviders(definitions); const state = createState({ services }); const parts = {}; const context = { state, parts }; parts.credits = createCredits(); parts.marker = createMarker(context); parts.framing = createCameraFraming(context); parts.router = createPickRouter(() => state.providers.values(), { positionId: POSITION_PICK_ID, }); parts.viewerHost = createViewerHost(context); parts.hasSelectedSequence = () => [...state.providers.values()].some( (entry) => entry.instance.sequenceStats?.()?.selectedId, ); parts.clearSequences = () => { for (const entry of state.providers.values()) entry.instance.clearSequence?.(); }; parts.selection = createSelection(context); parts.openAtGround = createGroundClick({ state, openNearest: (point, options) => layer.openNearest(point, options), isAvailable: (entry) => providerAvailable(entry), }); let notifyQueued = false; function notify() { if (notifyQueued) return; notifyQueued = true; queueMicrotask(() => { notifyQueued = false; const snapshot = getUIState(); for (const listener of [...state.listeners]) { try { listener(snapshot); } catch (error) { console.warn('[Data:StreetLevel] listener error:', error); } } }); } state.notify = notify; function providerContext(entry) { return Object.freeze({ services: state.services, /** Resolved against now, so "since N days" keeps up with the clock. */ getFilter: () => resolveFilter(state.filter, streetLevelTime()), /** The layer and this provider's switch are both on. */ isActive: () => state.enabled && entry.on, notify, actions: { /** `{frame: false}` opens it without moving the camera. */ openImage: (imageId, options) => openImage(entry.def.id, imageId, options), /** This provider's image nearest a point the user picked on the map. */ openNearest: (point) => layer.openNearest(point, { providerIds: [entry.def.id], frame: false, }), /** * Show a provider error, or withdraw it (null). A withdrawal clears * only this provider's own error, never a newer one from elsewhere. */ reportError: (message) => { if (message) { state.street.error = entry.reportedError = message; } else { if (!entry.reportedError) return; if (state.street.error === entry.reportedError) state.street.error = null; entry.reportedError = null; } notify(); }, }, }); } /** `def` if its key is ready, else the first keyless provider not refused. */ function keylessInstead(def, refused = () => false) { if (def.keyReady?.() !== false) return def; return defs.find((d) => !d.requiresKeyId && !refused(d.id)) || def; } // One source at a time: the first provider that defaults on. Without its // key, the first keyless source instead, so a fresh keyless install opens // on coverage rather than KEY REQUIRED. const preferred = defs.find((def) => def.defaultOn !== false); const startsOn = preferred && keylessInstead(preferred); for (const def of defs) { const entry = { def, instance: null, on: def === startsOn, status: null, /** The status request in flight; overlapping checks share it. */ statusCheck: null, /** The error this provider last reported, until it withdraws it. */ reportedError: null, }; entry.instance = def.create(providerContext(entry)); state.providers.set(def.id, entry); } let mapStack = null; let unsubscribeMapStack = null; /** Usable only on its map stack (Google's terms: Street View on Google 3D only). */ function providerAvailable(entry) { const required = entry.def.requiresMapStack; return !required || mapStack?.getActiveId?.() === required; } /** Leaving a provider's map stack closes its image, viewer and credit. */ function syncProviderAvailability() { const owner = state.providers.get(state.street.providerId); if (state.street.open && owner && !providerAvailable(owner)) layer.closeViewer(); // An armed lookup for a source whose map left dies too. const armedFor = state.street.armed?.providerIds?.map((id) => state.providers.get(id), ); if (armedFor?.some((entry) => entry && !providerAvailable(entry))) state.street.armed = null; for (const entry of state.providers.values()) { if (!entry.def.requiresMapStack) continue; if (state.enabled && entry.on && providerAvailable(entry)) parts.credits.show(state.viewer, entry.def); else { parts.credits.hide(state.viewer, entry.def); parts.viewerHost.unmount(entry.def.id); } } remeasureGround(); notify(); } let groundRetry = null; let groundRetries = 0; function cancelGroundRetry() { clearTimeout(groundRetry); groundRetry = null; } /** * Whether a ground click can open an image: the camera is at street zoom. * Under Google 3D the ground is unknown until its tiles load, so an unknown * ground is measured again a few times instead of waiting for the next move. */ function syncGroundClickReady() { cancelGroundRetry(); const ready = state.enabled && groundClickHeightOk(state.viewer); if ( state.enabled && !ready && groundRetries < GROUND_RETRY_LIMIT && groundUnderCamera(state.viewer) === null ) { groundRetries++; groundRetry = setTimeout(syncGroundClickReady, GROUND_RETRY_MS); } if (ready === state.groundClickReady) return; state.groundClickReady = ready; notify(); } /** A camera move or a map change measures afresh. */ function remeasureGround() { groundRetries = 0; syncGroundClickReady(); } let removeCameraListener = null; function watchCamera(viewer) { removeCameraListener?.(); removeCameraListener = viewer?.camera?.moveEnd?.addEventListener(remeasureGround) || null; } const activeEntries = () => [...state.providers.values()].filter((entry) => entry.on); /** A provider's key status. A hung server must not hold LOADING, or the next check, forever. */ function checkStatus(entry) { entry.statusCheck ||= (async () => { try { entry.status = await entry.instance.status({ signal: AbortSignal.timeout(KEY_STATUS_TIMEOUT_MS), }); } catch { entry.status = null; } notify(); })().finally(() => { entry.statusCheck = null; }); return entry.statusCheck; } function activate(entry) { if (!state.viewer) return; entry.instance.activate(state.viewer); // Without a known key, a switch-on asks again: the server may be back, // or have a key now. if (entry.status?.configured !== true) checkStatus(entry); if (providerAvailable(entry)) parts.credits.show(state.viewer, entry.def); } /** Requests replacing the open photo that switch its source keep it up. */ let viewerHolds = 0; function deactivate(entry) { if (!viewerHolds) parts.viewerHost.unmount(entry.def.id); entry.instance.deactivate(); parts.credits.hide(state.viewer, entry.def); } /** The nearest-image lookup in flight; any newer user action aborts it. */ let nearestLookup = null; function abortNearest() { nearestLookup?.abort(); nearestLookup = null; } /** Close the image and deselect its sequence on the map. */ function closeViewer() { abortNearest(); parts.viewerHost.close(); parts.clearSequences(); } /** Ground under the screen centre; null for sky, undefined when it cannot aim. */ function screenCentreGround() { const canvas = state.viewer?.scene?.canvas; const pick = state.services.scenePick?.pickGroundPosition; if (!pick || !canvas?.clientWidth || !canvas?.clientHeight) return undefined; const position = pick(state.viewer, { x: canvas.clientWidth / 2, y: canvas.clientHeight / 2, }); const carto = position && Cesium.Cartographic.fromCartesian(position); return carto ? { lon: Cesium.Math.toDegrees(carto.longitude), lat: Cesium.Math.toDegrees(carto.latitude), } : null; } /** `frame: false` keeps the camera where it is (the user picked the spot). */ function openImage( providerId, imageId, { frame = true, signal = null } = {}, ) { if (signal?.aborted) return Promise.resolve(false); abortNearest(); state.street.armed = null; const entry = state.providers.get(providerId); if (entry && !providerAvailable(entry)) { state.street.loading = false; state.street.error = unavailableReason(entry); notify(); return Promise.resolve(false); } return parts.viewerHost.open(providerId, imageId, { frame, signal }); } function unavailableReason(entry) { return t('{name} needs the Google 3D map: choose it under MAP SOURCE', { name: translateKnown(entry.def.name), }); } /** One imagery source at a time: lighting a provider darkens the others. */ function setProviderEnabled(providerId, on) { const entry = state.providers.get(providerId); if (!entry) return false; const before = litIds(); const next = on !== false; if (next) for (const other of state.providers.values()) if (other !== entry && other.on) switchProvider(other, false); switchProvider(entry, next); sourceChanged(before); notify(); return true; } const litIds = () => [...state.providers] .filter(([, entry]) => entry.on) .map(([id]) => id) .join(); /** * After a chip, voice or a link changed the lit source: a lookup still * running and its spinner or error were about the source switched away * (an open photo keeps its own state). */ function sourceChanged(before) { if (litIds() === before) return; abortNearest(); if (state.street.open) return; state.street.error = null; state.street.loading = false; } function switchProvider(entry, on) { if (entry.on === on) return; entry.on = on; // A lookup armed for this source dies with it. if (!on && state.street.armed?.providerIds?.includes(entry.def.id)) state.street.armed = null; if (!state.enabled) return; if (on) activate(entry); else deactivate(entry); } /** * The one provider params leave lit: of those they switch on, the one * already on (reapplying never flips), else the first; with none, the lit * one unless they switch it off. */ function litByParams(switches) { const asked = [...state.providers.keys()].filter( (id) => switches.get(id) === true, ); const current = [...state.providers] .filter(([, entry]) => entry.on) .map(([id]) => id); if (asked.length) return asked.find((id) => current.includes(id)) ?? asked[0]; return current.find((id) => switches.get(id) !== false) ?? null; } function setCoverageFilter(next) { const filter = normalizeFilter(next, state.filter); if (sameFilter(filter, state.filter)) return; state.filter = filter; const resolved = resolveFilter(filter, streetLevelTime()); for (const entry of state.providers.values()) entry.instance.setFilter(resolved); notify(); } /** The hint a ground-click provider shows, or the provider's own. */ function hintFor(entry, stats) { if (entry.def.groundClick && stats.hint && !state.groundClickReady) // No-break spaces keep a provider name (Google Street View) on one line. return t('zoom in to a street to open {name}', { name: translateKnown(entry.def.name).replace(/ /g, '\u00a0'), }); return stats.hint || ''; } /** Providers usable on this map stack; the others are not shown at all. */ const listedEntries = () => [...state.providers.values()].filter((entry) => providerAvailable(entry)); function providerSnapshots() { return listedEntries().map((entry) => { const stats = entry.instance.coverageStats(); return { id: entry.def.id, name: entry.def.name, label: entry.def.label, on: entry.on, configured: entry.status ? entry.status.configured === true : null, // A rejected key gates the provider exactly like a missing one. keyRequired: stats.keyRequired === true || stats.keyRejected === true, keyRejected: stats.keyRejected === true, requiresKeyId: entry.def.requiresKeyId || null, loading: stats.loading === true, count: stats.count || 0, hint: hintFor(entry, stats), error: stats.error || null, color: entry.def.colors.coverage, coverageLabel: entry.def.coverageLabel || null, sinceBasis: entry.def.sinceBasis === 'upload' ? 'upload' : 'capture', groundClick: entry.def.groundClick === true, filters: [...filtersOf(entry.def)], }; }); } /** The selected sequence; the provider showing the open image answers first. */ function sequenceSnapshot() { const owner = state.providers.get(state.street.providerId); const candidates = owner ? [owner, ...[...state.providers.values()].filter((e) => e !== owner)] : [...state.providers.values()]; for (const entry of candidates) { const stats = entry.instance.sequenceStats?.(); if (stats?.selectedId || stats?.loading || stats?.error) return { providerId: entry.def.id, selectedId: stats.selectedId || null, images: stats.images || 0, loading: stats.loading === true, error: stats.error || null, }; } return { providerId: null, selectedId: null, images: 0, loading: false, error: null, }; } function getUIState() { const { host, ...street } = state.street; const ui = composeUIState({ enabled: state.enabled, groundClickReady: state.groundClickReady, filter: state.filter, providers: providerSnapshots(), street, sequence: sequenceSnapshot(), }); // The lit source cannot run on this map: say so, not a blank panel. const stranded = [...state.providers.values()].find( (entry) => entry.on && !providerAvailable(entry), ); if (stranded && !ui.providers.some((p) => p.on)) ui.coverage.hint = unavailableReason(stranded); return ui; } const layer = { id: STREET_LEVEL_LAYER_ID, name: 'Street Level', icon: '๐Ÿ“ท', /** The sources usable on this map (Street View only on Google 3D). */ get source() { return listedEntries() .map((entry) => entry.def.name) .join(' ยท '); }, updateInterval: 0, statsRefreshInterval: 1000, /** The key the switched-on providers share (or null), for the layer row. */ get requiresKeyId() { const on = activeEntries(); return requiresKeyIdFor(on.length ? on.map((entry) => entry.def) : defs); }, /** Registered providers, in chip order. */ providerIds: defs.map((def) => def.id), /** The map stack a provider needs (`requiresMapStack`), or null for any. */ requiredMapStack(providerId) { const def = defs.find((entry) => entry.id === providerId); return def?.requiresMapStack || null; }, /** * A provider's name and key state on any map (the panel lists a provider * only on the map it needs). `configured` is null until its status call * answers; `keyRequired` covers a missing or refused key. */ providerStatus(providerId) { const entry = state.providers.get(providerId); if (!entry) return null; const stats = entry.instance.coverageStats(); return { id: entry.def.id, name: entry.def.name, on: entry.on, configured: entry.status ? entry.status.configured === true : null, keyRequired: stats.keyRequired === true || stats.keyRejected === true, keyRejected: stats.keyRejected === true, groundClick: entry.def.groundClick === true, billed: entry.def.billedPerImage === true, available: providerAvailable(entry), error: stats.error || null, }; }, getSourceAvailability() { const available = defs.length > 0; return { available, source: STREET_LEVEL_LAYER_ID, reason: available ? null : 'No street-level imagery providers configured', }; }, init(viewer) { state.viewer = viewer; parts.marker.ensure(viewer); parts.marker.setVisible(false); for (const entry of state.providers.values()) { entry.instance.init(viewer); checkStatus(entry); } console.log('[Data:StreetLevel] Initialized'); }, enable(viewer) { state.enabled = true; state.viewer = viewer; parts.marker.setVisible(true); parts.selection.install(viewer); for (const entry of activeEntries()) activate(entry); watchCamera(viewer); remeasureGround(); notify(); }, disable() { state.enabled = false; abortNearest(); removeCameraListener?.(); removeCameraListener = null; cancelGroundRetry(); parts.viewerHost.unmount(); for (const entry of state.providers.values()) entry.instance.deactivate(); syncGroundClickReady(); parts.credits.hideAll(state.viewer); parts.selection.uninstall(); parts.marker.setVisible(false); notify(); }, async update() { return state.enabled; }, destroy(viewer = state.viewer) { layer.disable(); for (const entry of state.providers.values()) entry.instance.destroy(viewer); parts.marker.destroy(viewer); parts.framing.attachNavigation(null); unsubscribeMapStack?.(); unsubscribeMapStack = null; mapStack = null; state.listeners.clear(); state.viewer = null; }, getStats() { // The lifecycle polls this every second: summarise, don't snapshot. // English data: the layer panel translates these through translateKnown. const snapshots = providerSnapshots(); const coverage = summarizeCoverage(snapshots); const keyLabel = keyStatusLabel(coverage); let loadingLabel = ''; if (keyLabel) loadingLabel = keyLabel; else if (coverage.loading) loadingLabel = msg('loading coverage...'); else if (coverage.hint && state.enabled) loadingLabel = coverage.hint; return { source: layer.source, count: coverage.count, loading: coverage.loading, keyRequired: coverage.keyRequired, keyAlternatives: keyAlternatives(snapshots), // A rejected key's message names the fix; a missing one says so. error: keyLabel ? coverage.keyRejected ? coverage.error || keyLabel : keyLabel : coverage.error, loadingLabel, }; }, /** A photo frames itself only if it still owns the camera once loaded. */ attachNavigation(navigation) { parts.framing.attachNavigation(navigation); }, /** The application map stack; Street View is usable only on Google 3D. */ attachMapStackController(controller) { unsubscribeMapStack?.(); mapStack = controller || null; unsubscribeMapStack = mapStack?.subscribe?.(syncProviderAvailability) || null; syncProviderAvailability(); }, /** Share-link and stored state: provider switches plus the filter. */ getParams() { return encodeParams({ providers: [...state.providers].map(([id, entry]) => [id, entry.on]), filter: state.filter, }); }, /** Unknown providers and malformed values are ignored, so any link applies. */ setParams(params = {}) { const decoded = decodeParams(params, { providerIds: state.providers.keys(), filter: state.filter, }); // A restored "Mapillary on" (the codec default) would light a source a // keyless install cannot draw. Only redirect a provider the params switch // on: a filter-only update keeps whatever the user chose. const asked = litByParams(decoded.providers); const lit = asked && decoded.providers.get(asked) === true ? keylessInstead( state.providers.get(asked).def, (id) => decoded.providers.get(id) === false, ).id : asked; const before = litIds(); for (const [id, entry] of state.providers) if (id !== lit) switchProvider(entry, false); if (lit) switchProvider(state.providers.get(lit), true); sourceChanged(before); notify(); setCoverageFilter(decoded.filter); return true; }, // โ”€โ”€ Public surface used by the panel โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ subscribe(listener) { if (typeof listener !== 'function') return () => {}; state.listeners.add(listener); return () => state.listeners.delete(listener); }, getUIState, /** The DOM element provider viewers render into. */ attachViewerHost(element) { parts.viewerHost.attach(element); }, setProviderEnabled, openImage, /** * Open the nearest image of the active providers (or `providerIds`) near * a point, else the view centre, or with `aim: 'screen-centre'` the ground * under the screen centre (sky: nothing). Providers without * `nearestImage` are skipped. Options: * - `radiusM` widens the search where a provider can (a geocoded landmark * is rarely within 50 m of a street); * - `signal` retires the lookup: nothing opens after it fires; * - `armed: false` (the assistant's own request) ignores a link's armed * point and keeps it until a photo opens; * - `replace: true` keeps an open photo (and EXPAND) up while it looks and * closes it if nothing opens; * - `proceed()` is asked before a found photo loads or an empty lookup * reports; false retires the request and leaves the panel as it was. * Why nothing opened is in `street.nearestOutcome`: 'empty', 'sky' or * null (an error). */ async openNearest( point, { providerIds = null, frame = true, aim = 'view', radiusM = null, signal: callerSignal = null, armed: useArmed = true, replace = false, proceed = null, } = {}, ) { if (callerSignal?.aborted) return false; state.street.nearestOutcome = null; // An OPEN press after a link armed a lookup opens what the link asked; // any other lookup is a new request and drops the armed one. const armed = useArmed ? state.street.armed : null; if (useArmed) state.street.armed = null; const closeReplaced = () => { if (replace && state.street.open) closeViewer(); }; if (!point && aim === 'screen-centre' && armed) { // OPEN promises the view centre: the link's spot only while the view // still shows it, or when the view cannot be picked. const centre = armed.point ? screenCentreGround() : null; if (!armed.point) radiusM ??= armed.radiusM; else if ( centre === undefined || (centre && metresBetween(centre, armed.point) <= ARMED_REACH_M) ) { point = armed.point; radiusM ??= armed.radiusM; } } const radius = Number.isFinite(radiusM) ? Math.min(NEAREST_RADIUS_MAX_M, Math.max(1, radiusM)) : NEAREST_RADIUS_M; let view = point; if (!view && aim === 'screen-centre') { view = screenCentreGround(); if (view === null) { abortNearest(); closeReplaced(); state.street.loading = false; state.street.error = AIM_AT_GROUND_MESSAGE; state.street.nearestOutcome = 'sky'; notify(); return false; } } view ||= viewCentre(state.viewer); if (!Number.isFinite(view?.lat) || !Number.isFinite(view?.lon)) return false; abortNearest(); const lookup = new AbortController(); nearestLookup = lookup; const { signal } = lookup; const onCallerAbort = () => lookup.abort(); callerSignal?.addEventListener('abort', onCallerAbort, { once: true }); const retired = () => { callerSignal?.removeEventListener('abort', onCallerAbort); // A newer lookup owns the panel, its spinner and its error. if (nearestLookup !== lookup) return false; nearestLookup = null; if (state.street.loading) { state.street.loading = false; notify(); } return false; }; state.street.loading = true; state.street.error = null; notify(); let lastError = null; const asked = (entry) => (!providerIds || providerIds.includes(entry.def.id)) && typeof entry.instance.nearestImage === 'function' && providerAvailable(entry); const entries = activeEntries().filter(asked); for (const entry of entries) { let imageId = null; try { imageId = await entry.instance.nearestImage( { lat: view.lat, lon: view.lon }, radius === NEAREST_RADIUS_M ? { signal } : { signal, radiusM: radius }, ); } catch (error) { if (callerSignal?.aborted) return retired(); // Overtaken: whatever replaced it owns the panel, errors included. if (signal.aborted) return retired(); // One provider failing (no key, offline) must not hide the others. lastError = error; continue; } if (callerSignal?.aborted) return retired(); if (signal.aborted) return retired(); if (!state.enabled) break; // Switched off, or its map left, while it looked: try the next. if (!imageId || !entry.on || !providerAvailable(entry)) continue; if (proceed && proceed() !== true) return retired(); nearestLookup = null; callerSignal?.removeEventListener('abort', onCallerAbort); // A sequence playing in the replaced photo would step past this one. if (replace && state.street.open) parts.viewerHost.stopPlayback(); // The caller's signal still counts while the viewer mounts and loads. return openImage(entry.def.id, imageId, { frame, signal: callerSignal, }); } callerSignal?.removeEventListener('abort', onCallerAbort); // Replaced while it looked: the panel is the newer lookup's. if (nearestLookup !== lookup) return false; // Given up by its caller: the panel stays as it was. if (proceed && proceed() !== true) return retired(); nearestLookup = null; closeReplaced(); // Switched off while it looked: nothing to open, nothing to report. const stillOn = entries.some( (entry) => entry.on && providerAvailable(entry), ); // A provider's own refusal is English data that the panel translates; // the core's refusal is built here, for the panel only, in the language. if (state.enabled && stillOn && !lastError) state.street.nearestOutcome = 'empty'; if (state.enabled && stillOn) state.street.error = lastError?.message || (point ? t('No street-level imagery within {radius} m of that point', { radius, }) : t( 'No street-level imagery within {radius} m of the view centre', { radius, }, )); state.street.loading = false; notify(); return false; }, closeViewer, /** * Keep the open photo up while a request that replaces it switches the * source, so EXPAND stays. Release closes it if its source is still off. */ holdViewer() { viewerHolds += 1; let held = true; return () => { if (!held) return; held = false; viewerHolds -= 1; if (viewerHolds) return; for (const entry of state.providers.values()) if (!entry.on) parts.viewerHost.unmount(entry.def.id); }; }, /** * Arm a nearest lookup for the next OPEN press without running it (a link * to a source that bills every load). Any other lookup, open or close, the * source switched off or its map leaving clears it. */ armNearest(point, { providerIds = null, radiusM = null } = {}) { state.street.armed = { point: Number.isFinite(point?.lat) && Number.isFinite(point?.lon) ? { lat: point.lat, lon: point.lon } : null, providerIds: Array.isArray(providerIds) ? [...providerIds] : null, radiusM: Number.isFinite(radiusM) ? radiusM : null, }; notify(); }, setViewerRenderMode: (mode) => parts.viewerHost.setRenderMode(mode), resizeViewer: () => parts.viewerHost.resize(), }; return layer; }