mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
A superseded open wait cleared the shared cancelShown slot that belonged to the newer wait, leaving its auth listener and timer alive after close; open() now settles the previous wait first. A lookup whose viewer unmounted while the Street View service loaded still sent a billed getPanorama; describe() now rechecks the lookup after acquisition.
291 lines
8.6 KiB
JavaScript
291 lines
8.6 KiB
JavaScript
import {
|
||
DETAILS_RETRY_COOLDOWN_MS,
|
||
DETAILS_TIMEOUT_MS,
|
||
GOOGLE_PROVIDER_ID,
|
||
KEY_REJECTED_MESSAGE,
|
||
NO_ANSWER_MESSAGE,
|
||
OPEN_TIMEOUT_MS,
|
||
creatorFrom,
|
||
imageDateMs,
|
||
streetViewUrl,
|
||
} from './policy.js';
|
||
import { msg } from '../../../../i18n/index.js';
|
||
|
||
const PANORAMA_OPTIONS = Object.freeze({
|
||
visible: false,
|
||
// The caption has the address; Google's card covers a docked panorama.
|
||
addressControl: false,
|
||
linksControl: true,
|
||
panControl: true,
|
||
zoomControl: true,
|
||
clickToGo: true,
|
||
showRoadLabels: true,
|
||
// The panel has EXPAND and ×.
|
||
fullscreenControl: false,
|
||
enableCloseButton: false,
|
||
motionTracking: false,
|
||
motionTrackingControl: false,
|
||
});
|
||
|
||
/**
|
||
* Viewer adapter over Google's StreetViewPanorama: emits a pose for every
|
||
* panorama and view change, including steps along Google's arrows.
|
||
* @param {{loader: ReturnType<import('./mapsLoader.js').createMapsLoader>, getService?: () => Promise<object>, render?: object}} options
|
||
* @returns {import('../../registry.js').ViewerAdapter & {remember: Function}}
|
||
*/
|
||
export function createGoogleViewer({ loader, getService, render } = {}) {
|
||
let library = null;
|
||
let panorama = null;
|
||
let element = null;
|
||
let host = null;
|
||
let service = null;
|
||
let pendingOpen = null;
|
||
let cancelShown = null;
|
||
/** Bumped by `unmount`: a construction it overtook builds nothing. */
|
||
let generation = 0;
|
||
let subscriptions = [];
|
||
const described = new Map();
|
||
/** Panorama id → its lookup in flight; a late answer to a dropped one is ignored. */
|
||
const lookingUp = new Map();
|
||
const retryAfter = new Map();
|
||
const listeners = new Set();
|
||
|
||
function requestRender() {
|
||
render?.governorRequestRender?.('google-street-view');
|
||
}
|
||
|
||
async function ensureLibrary() {
|
||
library ||= await loader.importLibrary('streetView');
|
||
return library;
|
||
}
|
||
|
||
function emit(pose) {
|
||
for (const listener of [...listeners]) {
|
||
try {
|
||
listener(pose);
|
||
} catch {
|
||
/* listener errors are the core's to log */
|
||
}
|
||
}
|
||
}
|
||
|
||
function metaFrom(data) {
|
||
return {
|
||
capturedAt: imageDateMs(data?.imageDate),
|
||
creator: creatorFrom(data?.copyright),
|
||
title: data?.location?.description || null,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Look up a panorama's date, photographer and address once, then re-emit
|
||
* the pose. A failed or timed-out lookup can retry after the cooldown.
|
||
*/
|
||
async function describe(panoId) {
|
||
if (described.has(panoId) || lookingUp.has(panoId)) return;
|
||
if (Date.now() < (retryAfter.get(panoId) ?? 0)) return;
|
||
const lookup = { timer: null };
|
||
lookingUp.set(panoId, lookup);
|
||
const current = () => lookingUp.get(panoId) === lookup;
|
||
try {
|
||
const { data } = await new Promise((resolve, reject) => {
|
||
lookup.timer = setTimeout(
|
||
() => reject(new Error(NO_ANSWER_MESSAGE)),
|
||
DETAILS_TIMEOUT_MS,
|
||
);
|
||
(async () => {
|
||
service ||= getService
|
||
? await getService()
|
||
: new (await ensureLibrary()).StreetViewService();
|
||
if (!current())
|
||
throw new Error('Street View details lookup was released');
|
||
return service.getPanorama({ pano: panoId });
|
||
})().then(resolve, reject);
|
||
});
|
||
if (!current()) return;
|
||
described.set(panoId, metaFrom(data));
|
||
retryAfter.delete(panoId);
|
||
} catch {
|
||
if (current())
|
||
retryAfter.set(panoId, Date.now() + DETAILS_RETRY_COOLDOWN_MS);
|
||
return;
|
||
} finally {
|
||
clearTimeout(lookup.timer);
|
||
if (current()) lookingUp.delete(panoId);
|
||
}
|
||
publishPose();
|
||
}
|
||
|
||
function releaseLookups() {
|
||
for (const lookup of lookingUp.values()) clearTimeout(lookup.timer);
|
||
lookingUp.clear();
|
||
}
|
||
|
||
function publishPose() {
|
||
const panoId = panorama?.getPano?.();
|
||
const latLng = panorama?.getPosition?.();
|
||
if (!panoId || !latLng || pendingOpen === null) return;
|
||
const meta = described.get(panoId);
|
||
if (!meta) describe(panoId);
|
||
const pov = panorama.getPov() || {};
|
||
emit({
|
||
providerId: GOOGLE_PROVIDER_ID,
|
||
imageId: panoId,
|
||
position: { lon: latLng.lng(), lat: latLng.lat() },
|
||
bearing: Number.isFinite(pov.heading) ? pov.heading : null,
|
||
tilt: Number.isFinite(pov.pitch) ? pov.pitch : 0,
|
||
altitude: null,
|
||
isPano: true,
|
||
capturedAt: meta?.capturedAt ?? null,
|
||
capturedAtPrecision: 'month',
|
||
creator: meta?.creator ?? null,
|
||
title: meta?.title ?? null,
|
||
sequenceId: null,
|
||
externalUrl: streetViewUrl(panoId, {
|
||
heading: pov.heading || 0,
|
||
pitch: pov.pitch || 0,
|
||
}),
|
||
});
|
||
requestRender();
|
||
}
|
||
|
||
async function ensurePanorama(target) {
|
||
if (panorama && host === target) return panorama;
|
||
const built = generation;
|
||
const { StreetViewPanorama } = await ensureLibrary();
|
||
if (built !== generation) throw new Error('Street View was unmounted');
|
||
if (panorama && host === target) return panorama;
|
||
destroyPanorama();
|
||
element = target.ownerDocument.createElement('div');
|
||
element.className = 'sl-google-panorama';
|
||
element.style.cssText = 'position:absolute;inset:0;';
|
||
target.append(element);
|
||
host = target;
|
||
panorama = new StreetViewPanorama(element, PANORAMA_OPTIONS);
|
||
// Not pano_changed: it can fire with the old panorama's position.
|
||
subscriptions = ['position_changed', 'pov_changed'].map((name) =>
|
||
panorama.addListener(name, () => publishPose()),
|
||
);
|
||
return panorama;
|
||
}
|
||
|
||
function destroyPanorama() {
|
||
for (const subscription of subscriptions) subscription.remove();
|
||
subscriptions = [];
|
||
try {
|
||
panorama?.setVisible(false);
|
||
} catch {
|
||
/* already gone */
|
||
}
|
||
element?.remove();
|
||
panorama = null;
|
||
element = null;
|
||
host = null;
|
||
}
|
||
|
||
/**
|
||
* Resolves once `panoId` shows (OK status, or a new position when the
|
||
* status stays OK); rejects on no imagery, a refused key or no answer.
|
||
*/
|
||
function shown(instance, panoId) {
|
||
if (instance.getPano() === panoId && instance.getStatus() === 'OK')
|
||
return Promise.resolve();
|
||
return new Promise((resolve, reject) => {
|
||
const timer = setTimeout(
|
||
() => finish(reject, new Error(NO_ANSWER_MESSAGE)),
|
||
OPEN_TIMEOUT_MS,
|
||
);
|
||
const stopAuthWatch = loader.onAuthFailure(() =>
|
||
finish(reject, new Error(KEY_REJECTED_MESSAGE)),
|
||
);
|
||
cancelShown = () => finish(resolve);
|
||
// At a position event the status may still be the last panorama's failure.
|
||
const onStatus = () => {
|
||
if (pendingOpen !== panoId) return finish(resolve);
|
||
const status = instance.getStatus();
|
||
if (status === 'OK') finish(resolve);
|
||
else if (status)
|
||
finish(
|
||
reject,
|
||
new Error(msg('Street View has no imagery for this place')),
|
||
);
|
||
};
|
||
const onPosition = () => {
|
||
if (pendingOpen !== panoId || instance.getStatus() === 'OK')
|
||
finish(resolve);
|
||
};
|
||
const subscriptions = [
|
||
instance.addListener('status_changed', onStatus),
|
||
instance.addListener('position_changed', onPosition),
|
||
];
|
||
function finish(settle, value) {
|
||
cancelShown = null;
|
||
clearTimeout(timer);
|
||
for (const subscription of subscriptions) subscription.remove();
|
||
stopAuthWatch();
|
||
settle(value);
|
||
}
|
||
});
|
||
}
|
||
|
||
return {
|
||
async mount(target) {
|
||
if (!target) throw new Error('Street Level viewer has no host element');
|
||
await ensurePanorama(target);
|
||
},
|
||
|
||
async open(imageId) {
|
||
const panoId = String(imageId);
|
||
if (!host) throw new Error('Street View is not mounted');
|
||
if (loader.authFailed()) throw new Error(KEY_REJECTED_MESSAGE);
|
||
cancelShown?.();
|
||
pendingOpen = panoId;
|
||
const instance = await ensurePanorama(host);
|
||
if (pendingOpen !== panoId) return;
|
||
const ready = shown(instance, panoId);
|
||
instance.setPano(panoId);
|
||
instance.setVisible(true);
|
||
await ready;
|
||
if (pendingOpen !== panoId) return;
|
||
publishPose();
|
||
},
|
||
|
||
close() {
|
||
pendingOpen = null;
|
||
cancelShown?.();
|
||
try {
|
||
panorama?.setVisible(false);
|
||
} catch {
|
||
/* torn down */
|
||
}
|
||
},
|
||
|
||
unmount() {
|
||
pendingOpen = null;
|
||
cancelShown?.();
|
||
releaseLookups();
|
||
generation++;
|
||
destroyPanorama();
|
||
},
|
||
|
||
resize() {
|
||
if (!panorama) return;
|
||
try {
|
||
globalThis.google?.maps?.event?.trigger(panorama, 'resize');
|
||
} catch {
|
||
/* no-op */
|
||
}
|
||
},
|
||
|
||
onPose(listener) {
|
||
listeners.add(listener);
|
||
return () => listeners.delete(listener);
|
||
},
|
||
|
||
/** Seed the details cache from a nearest lookup's answer. */
|
||
remember(panoId, data) {
|
||
if (panoId && data) described.set(String(panoId), metaFrom(data));
|
||
},
|
||
};
|
||
}
|