mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
feat(street-level): "show me X on Street View" action, street_level view field and sl= links
show_street_level (voice and typed) flies to a place and opens its nearest street-level photo from Google Street View, Mapillary, KartaView or Panoramax; Street View switches to Google 3D first. The view model gains a street_level field, share links carry sl=<source>,<lat>,<lon>, and show_in_gods_eye_view can open a photo. A plain sl=google link only arms the point and waits for OPEN, so it never bills a key without a click. Embed pages show an open photo in an overlay that Esc closes. On-screen strings are translated into es, ru, zh-CN and zh-Hant. Covered by unit tests and three new steps in the Street Level browser suite.
This commit is contained in:
1 parent
f3adccd01a
commit
98de41c94a
64 files changed
+4147
-66
No files matched your search
@@ -21,6 +21,7 @@ import {
|
||||
AIM_AT_GROUND_MESSAGE,
|
||||
keyStatusLabel,
|
||||
NEAREST_RADIUS_M,
|
||||
NEAREST_RADIUS_MAX_M,
|
||||
POSITION_PICK_ID,
|
||||
STREET_LEVEL_LAYER_ID,
|
||||
} from './policy.js';
|
||||
@@ -157,6 +158,12 @@ export function createStreetLevelLayer({
|
||||
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))
|
||||
@@ -275,8 +282,14 @@ export function createStreetLevelLayer({
|
||||
}
|
||||
|
||||
/** `frame: false` keeps the camera where it is (the user picked the spot). */
|
||||
function openImage(providerId, imageId, { frame = true } = {}) {
|
||||
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;
|
||||
@@ -284,7 +297,7 @@ export function createStreetLevelLayer({
|
||||
notify();
|
||||
return Promise.resolve(false);
|
||||
}
|
||||
return parts.viewerHost.open(providerId, imageId, { frame });
|
||||
return parts.viewerHost.open(providerId, imageId, { frame, signal });
|
||||
}
|
||||
|
||||
function unavailableReason(entry) {
|
||||
@@ -330,6 +343,9 @@ export function createStreetLevelLayer({
|
||||
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);
|
||||
@@ -466,6 +482,37 @@ export function createStreetLevelLayer({
|
||||
},
|
||||
/** 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;
|
||||
},
|
||||
/** The coverage lines a provider draws now (see `coverageLines`). */
|
||||
coverageLines(providerId) {
|
||||
return state.providers.get(providerId)?.instance.coverageLines?.() ?? [];
|
||||
},
|
||||
/**
|
||||
* 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 {
|
||||
@@ -612,13 +659,34 @@ export function createStreetLevelLayer({
|
||||
/**
|
||||
* 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
|
||||
* under the screen centre (sky: nothing). `radiusM` widens the search for
|
||||
* providers that can (a geocoded landmark is rarely within 50 m of a
|
||||
* street); clicks keep the default. A caller's `signal` retires the
|
||||
* lookup: nothing opens after it fires. Providers without
|
||||
* `nearestImage` are skipped.
|
||||
*/
|
||||
async openNearest(
|
||||
point,
|
||||
{ providerIds = null, frame = true, aim = 'view' } = {},
|
||||
{
|
||||
providerIds = null,
|
||||
frame = true,
|
||||
aim = 'view',
|
||||
radiusM = null,
|
||||
signal: callerSignal = null,
|
||||
} = {},
|
||||
) {
|
||||
if (callerSignal?.aborted) return false;
|
||||
// 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 = state.street.armed;
|
||||
state.street.armed = null;
|
||||
if (!point && aim === 'screen-centre' && armed) {
|
||||
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();
|
||||
@@ -637,6 +705,21 @@ export function createStreetLevelLayer({
|
||||
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);
|
||||
// Only the lookup that still owns the panel may touch it: a newer one
|
||||
// has its own spinner and error.
|
||||
if (nearestLookup !== lookup) return false;
|
||||
nearestLookup = null;
|
||||
// The caller moved on: the panel shows nothing of this lookup.
|
||||
if (state.street.loading && !state.street.open) {
|
||||
state.street.loading = false;
|
||||
notify();
|
||||
}
|
||||
return false;
|
||||
};
|
||||
state.street.loading = true;
|
||||
state.street.error = null;
|
||||
notify();
|
||||
@@ -651,23 +734,35 @@ export function createStreetLevelLayer({
|
||||
try {
|
||||
imageId = await entry.instance.nearestImage(
|
||||
{ lat: view.lat, lon: view.lon },
|
||||
{ signal },
|
||||
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 false;
|
||||
// One provider failing (no key, offline) must not hide the others.
|
||||
lastError = error;
|
||||
continue;
|
||||
}
|
||||
if (callerSignal?.aborted) return retired();
|
||||
if (signal.aborted) return false;
|
||||
if (!state.enabled) break;
|
||||
// Switched off, or its map left, while it looked: try the next.
|
||||
if (!imageId || !entry.on || !providerAvailable(entry)) continue;
|
||||
nearestLookup = null;
|
||||
return openImage(entry.def.id, imageId, { frame });
|
||||
callerSignal?.removeEventListener('abort', onCallerAbort);
|
||||
// The caller's signal still counts while the viewer mounts and loads.
|
||||
return openImage(entry.def.id, imageId, {
|
||||
frame,
|
||||
signal: callerSignal,
|
||||
});
|
||||
}
|
||||
if (nearestLookup === lookup) nearestLookup = null;
|
||||
callerSignal?.removeEventListener('abort', onCallerAbort);
|
||||
// Replaced while it looked: the panel is the newer lookup's.
|
||||
if (nearestLookup !== lookup) return false;
|
||||
nearestLookup = null;
|
||||
// Switched off while it looked: nothing to open, nothing to report.
|
||||
const stillOn = entries.some(
|
||||
(entry) => entry.on && providerAvailable(entry),
|
||||
@@ -679,11 +774,13 @@ export function createStreetLevelLayer({
|
||||
lastError?.message ||
|
||||
(point
|
||||
? t('No street-level imagery within {radius} m of that point', {
|
||||
radius: NEAREST_RADIUS_M,
|
||||
radius,
|
||||
})
|
||||
: t(
|
||||
'No street-level imagery within {radius} m of the view centre',
|
||||
{ radius: NEAREST_RADIUS_M },
|
||||
{
|
||||
radius,
|
||||
},
|
||||
));
|
||||
state.street.loading = false;
|
||||
notify();
|
||||
@@ -695,6 +792,23 @@ export function createStreetLevelLayer({
|
||||
parts.viewerHost.close();
|
||||
parts.clearSequences();
|
||||
},
|
||||
/**
|
||||
* Prepare a nearest lookup for the next OPEN press without running it: a
|
||||
* link to a source that bills every load stops here. The press opens at
|
||||
* this point with this radius; 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(),
|
||||
};
|
||||
|
||||
@@ -12,6 +12,9 @@ import {
|
||||
fakeStreetLevelProvider as fakeProvider,
|
||||
} from '../../testSupport/streetLevelFakes.mjs';
|
||||
import { setLocale } from '../../i18n/index.js';
|
||||
// Loaded up front: it brings Vue, which reads `document` once when it loads,
|
||||
// and several tests here stand a bare fake document in for the page.
|
||||
import { createGevActionRunner } from '../../voice/gevActions.js';
|
||||
|
||||
/**
|
||||
* A layer over `source` and `photoViewer`, initialised on a stand-in viewer
|
||||
@@ -1118,6 +1121,674 @@ test('switching source by params clears a failed lookup’s error; reapplying th
|
||||
assert.equal(second.getUIState().street.error, kept);
|
||||
});
|
||||
|
||||
test('openNearest searches wider on request, never past the cap, and says how far it looked', async (t) => {
|
||||
const { layer, fake } = await withStreetView(t, { nearest: () => null });
|
||||
layer.setProviderEnabled('google', true);
|
||||
await settle();
|
||||
await layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false, radiusM: 250 },
|
||||
);
|
||||
assert.equal(fake.lookups.at(-1).radius, 250);
|
||||
assert.equal(
|
||||
layer.getUIState().street.error,
|
||||
'No street-level imagery within 250 m of that point',
|
||||
);
|
||||
await layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false, radiusM: 5000 },
|
||||
);
|
||||
assert.equal(fake.lookups.at(-1).radius, 250, 'capped');
|
||||
await layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false },
|
||||
);
|
||||
assert.equal(fake.lookups.at(-1).radius, 50, 'a click keeps the default');
|
||||
});
|
||||
|
||||
test('a caller’s signal retires a nearest lookup: nothing opens after it fires', async (t) => {
|
||||
let answer = null;
|
||||
const { layer, fake } = await withStreetView(t, {
|
||||
nearest: () => 'pano-a',
|
||||
});
|
||||
const lib = fake.library;
|
||||
const service = lib.StreetViewService.prototype.getPanorama;
|
||||
lib.StreetViewService.prototype.getPanorama = function (request) {
|
||||
return new Promise((resolve, reject) => {
|
||||
answer = () => service.call(this, request).then(resolve, reject);
|
||||
});
|
||||
};
|
||||
layer.setProviderEnabled('google', true);
|
||||
await settle();
|
||||
const controller = new AbortController();
|
||||
const pending = layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false, signal: controller.signal },
|
||||
);
|
||||
await settle();
|
||||
controller.abort();
|
||||
answer?.();
|
||||
assert.equal(await pending, false);
|
||||
const street = layer.getUIState().street;
|
||||
assert.equal(street.open, false, 'the retired lookup opened nothing');
|
||||
assert.equal(street.loading, false, 'no stuck spinner');
|
||||
assert.equal(street.error, null, 'and reports no missing imagery');
|
||||
const refused = await layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false, signal: controller.signal },
|
||||
);
|
||||
assert.equal(refused, false, 'an already-aborted signal asks nothing');
|
||||
});
|
||||
|
||||
test('providerStatus reports name, key state and billing on any map', async (t) => {
|
||||
const { layer } = await withStreetView(t, { mapStack: 'osm' });
|
||||
const google = layer.providerStatus('google');
|
||||
assert.equal(google.name, 'Google Street View');
|
||||
assert.equal(google.billed, true, 'every Street View load is billed');
|
||||
assert.equal(google.available, false, 'not on this map');
|
||||
assert.equal(google.keyRequired, false);
|
||||
assert.equal(layer.providerStatus('mapillary').billed, false);
|
||||
assert.equal(layer.providerStatus('nope'), null);
|
||||
assert.equal(layer.requiredMapStack('google'), 'photoreal');
|
||||
assert.equal(layer.requiredMapStack('mapillary'), null);
|
||||
});
|
||||
|
||||
test('an armed lookup asks nothing until the OPEN press, then opens at its point and radius once', async (t) => {
|
||||
const { layer, fake, mapillaryLookups } = await withStreetView(t);
|
||||
layer.setProviderEnabled('google', true);
|
||||
await settle();
|
||||
const before = fake.lookups.length;
|
||||
layer.armNearest(
|
||||
{ lat: 38.57986, lon: -121.49372 },
|
||||
{ providerIds: ['google'], radiusM: 250 },
|
||||
);
|
||||
await settle();
|
||||
await new Promise((resolve) => setTimeout(resolve, 20));
|
||||
// The click gate: arming is free. No provider was asked, nothing opened.
|
||||
assert.equal(
|
||||
fake.lookups.length,
|
||||
before,
|
||||
'no Google lookup before the press',
|
||||
);
|
||||
assert.deepEqual(mapillaryLookups, [], 'no Mapillary lookup either');
|
||||
assert.equal(layer.getUIState().street.open, false);
|
||||
assert.equal(layer.getUIState().street.loading, false);
|
||||
assert.deepEqual(layer.getUIState().street.armed, {
|
||||
point: { lat: 38.57986, lon: -121.49372 },
|
||||
providerIds: ['google'],
|
||||
radiusM: 250,
|
||||
});
|
||||
// The OPEN button: no point, aimed at the screen centre.
|
||||
const opened = await layer.openNearest(undefined, {
|
||||
providerIds: ['google'],
|
||||
frame: false,
|
||||
aim: 'screen-centre',
|
||||
});
|
||||
assert.equal(opened, true);
|
||||
assert.equal(
|
||||
fake.lookups.length,
|
||||
before + 1,
|
||||
'exactly one lookup for the press',
|
||||
);
|
||||
const request = fake.lookups.at(-1);
|
||||
assert.deepEqual(
|
||||
request.location,
|
||||
{ lat: 38.57986, lng: -121.49372 },
|
||||
'the armed point, not the screen centre',
|
||||
);
|
||||
assert.equal(request.radius, 250);
|
||||
assert.equal(layer.getUIState().street.armed, null, 'used once');
|
||||
layer.armNearest({ lat: 1, lon: 2 }, { providerIds: ['google'] });
|
||||
layer.closeViewer();
|
||||
assert.equal(layer.getUIState().street.armed, null, 'closing clears it');
|
||||
layer.armNearest({ lat: 1, lon: 2 }, { providerIds: ['google'] });
|
||||
await layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false },
|
||||
);
|
||||
assert.deepEqual(
|
||||
fake.lookups.at(-1).location,
|
||||
{ lat: 38.58, lng: -121.49 },
|
||||
'an explicit point wins',
|
||||
);
|
||||
assert.equal(layer.getUIState().street.armed, null);
|
||||
// Only the OPEN press consumes the armed point: "street view here" after a
|
||||
// pan is a new request at the view centre, and it drops the armed one.
|
||||
layer.closeViewer();
|
||||
layer.armNearest(
|
||||
{ lat: 10, lon: 20 },
|
||||
{ providerIds: ['google'], radiusM: 250 },
|
||||
);
|
||||
await layer.openNearest(null, { providerIds: ['google'], frame: false });
|
||||
const centre = fake.lookups.at(-1);
|
||||
assert.notDeepEqual(
|
||||
centre.location,
|
||||
{ lat: 10, lng: 20 },
|
||||
'the view centre, not the armed point',
|
||||
);
|
||||
assert.equal(centre.radius, 50, 'and the default radius');
|
||||
assert.equal(layer.getUIState().street.armed, null, 'dropped');
|
||||
// Opening any image, or switching the layer off, clears it too.
|
||||
layer.armNearest({ lat: 10, lon: 20 }, { providerIds: ['google'] });
|
||||
await layer.openImage('google', 'pano-a');
|
||||
assert.equal(layer.getUIState().street.armed, null, 'cleared by an open');
|
||||
layer.armNearest({ lat: 10, lon: 20 }, { providerIds: ['google'] });
|
||||
layer.disable();
|
||||
assert.equal(layer.getUIState().street.armed, null, 'cleared by disable');
|
||||
});
|
||||
|
||||
test('a caller’s signal: an aborted one asks nothing, and a provider that ignores the abort still opens nothing', async (t) => {
|
||||
const { layer, fake } = await withStreetView(t);
|
||||
layer.setProviderEnabled('google', true);
|
||||
await settle();
|
||||
const before = fake.lookups.length;
|
||||
const done = new AbortController();
|
||||
done.abort();
|
||||
assert.equal(
|
||||
await layer.openNearest(
|
||||
{ lat: 38.58, lon: -121.49 },
|
||||
{ providerIds: ['google'], frame: false, signal: done.signal },
|
||||
),
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
fake.lookups.length,
|
||||
before,
|
||||
'an already-aborted signal asks nothing',
|
||||
);
|
||||
});
|
||||
|
||||
test('a provider that ignores the abort and answers late still opens nothing', async (t) => {
|
||||
let seen = null;
|
||||
let release = null;
|
||||
const slow = fakeProvider({
|
||||
nearestImage: async (_point, { signal } = {}) => {
|
||||
seen = signal;
|
||||
await new Promise((resolve) => {
|
||||
release = resolve;
|
||||
});
|
||||
return 'late-image';
|
||||
},
|
||||
});
|
||||
const { layer: ignoring } = await enabledLayer(t, [slow]);
|
||||
const { fakeHost } =
|
||||
await import('../../testSupport/googleStreetViewFakes.mjs');
|
||||
ignoring.attachViewerHost(fakeHost());
|
||||
const controller = new AbortController();
|
||||
const pending = ignoring.openNearest(
|
||||
{ lat: 1, lon: 2 },
|
||||
{ frame: false, signal: controller.signal },
|
||||
);
|
||||
await settle();
|
||||
controller.abort();
|
||||
assert.equal(seen?.aborted, true, 'the provider sees the abort');
|
||||
release();
|
||||
assert.equal(await pending, false);
|
||||
const street = ignoring.getUIState().street;
|
||||
assert.equal(street.open, false, 'the late answer opened nothing');
|
||||
assert.equal(street.loading, false, 'no stuck spinner');
|
||||
assert.equal(street.error, null);
|
||||
});
|
||||
|
||||
test('providerStatus reports a keyless source on any map', async (t) => {
|
||||
const keyless = await withStreetView(t, {
|
||||
mapStack: 'osm',
|
||||
mapillaryKeyless: true,
|
||||
});
|
||||
await settle();
|
||||
const mapillary = keyless.layer.providerStatus('mapillary');
|
||||
assert.equal(mapillary.configured, false);
|
||||
assert.equal(mapillary.keyRequired, true);
|
||||
assert.equal(mapillary.keyRejected, false);
|
||||
});
|
||||
|
||||
test('providerStatus reports a refused key on any map', async (t) => {
|
||||
const refused = await withStreetView(t, { mapStack: 'osm' });
|
||||
refused.loader.refuseKey();
|
||||
await settle();
|
||||
const google = refused.layer.providerStatus('google');
|
||||
assert.equal(
|
||||
google.keyRequired,
|
||||
true,
|
||||
'a refused key gates like a missing one',
|
||||
);
|
||||
assert.equal(google.keyRejected, true);
|
||||
assert.equal(google.available, false, 'still not on this map');
|
||||
});
|
||||
|
||||
test('an armed lookup dies with its source: switched off, or its map gone', async (t) => {
|
||||
const { layer, stack } = await withStreetView(t);
|
||||
layer.setProviderEnabled('google', true);
|
||||
await settle();
|
||||
layer.armNearest(
|
||||
{ lat: 1, lon: 2 },
|
||||
{ providerIds: ['google'], radiusM: 250 },
|
||||
);
|
||||
layer.setProviderEnabled('google', false);
|
||||
assert.equal(
|
||||
layer.getUIState().street.armed,
|
||||
null,
|
||||
'switching the source off clears it',
|
||||
);
|
||||
layer.setProviderEnabled('google', true);
|
||||
layer.armNearest(
|
||||
{ lat: 1, lon: 2 },
|
||||
{ providerIds: ['google'], radiusM: 250 },
|
||||
);
|
||||
// Lighting Mapillary instead (one source at a time) turns Google off too.
|
||||
layer.setProviderEnabled('mapillary', true);
|
||||
assert.equal(
|
||||
layer.getUIState().street.armed,
|
||||
null,
|
||||
'another source lit clears it',
|
||||
);
|
||||
layer.setProviderEnabled('google', true);
|
||||
layer.armNearest(
|
||||
{ lat: 1, lon: 2 },
|
||||
{ providerIds: ['google'], radiusM: 250 },
|
||||
);
|
||||
// A map-stack notify that keeps Google 3D (a silent re-settle) keeps it.
|
||||
stack.switchTo('photoreal');
|
||||
assert.notEqual(
|
||||
layer.getUIState().street.armed,
|
||||
null,
|
||||
'a notify on the same map keeps it',
|
||||
);
|
||||
stack.switchTo('osm');
|
||||
assert.equal(
|
||||
layer.getUIState().street.armed,
|
||||
null,
|
||||
'leaving Google 3D clears it',
|
||||
);
|
||||
// Arming notifies, so a panel can show the state.
|
||||
let notified = 0;
|
||||
const unsubscribe = layer.subscribe(() => notified++);
|
||||
stack.switchTo('photoreal');
|
||||
await settle();
|
||||
const before = notified;
|
||||
layer.armNearest({ lat: 1, lon: 2 }, { providerIds: ['google'] });
|
||||
await settle();
|
||||
assert.ok(notified > before, 'subscribers hear about the armed lookup');
|
||||
unsubscribe();
|
||||
});
|
||||
|
||||
test('a lookup armed with no point opens under the middle of the screen on the press', async (t) => {
|
||||
const { createStreetLevelLayer: create } = await import('./index.js');
|
||||
const scenePick = await import('../../data/scenePick.js');
|
||||
const lookups = [];
|
||||
const provider = fakeProvider({
|
||||
nearestImage: async (point, options) => {
|
||||
lookups.push({ ...point, radiusM: options?.radiusM ?? null });
|
||||
return null;
|
||||
},
|
||||
});
|
||||
const saved = globalThis.document;
|
||||
const drawing = new Proxy({}, { get: () => () => ({ addColorStop() {} }) });
|
||||
globalThis.document = Object.assign(new EventTarget(), {
|
||||
createElement: () => ({ getContext: () => drawing }),
|
||||
});
|
||||
const viewer = fakeViewer();
|
||||
const centre = Cesium.Cartesian3.fromDegrees(-121.4937, 38.5799, 0);
|
||||
Object.assign(viewer.scene, {
|
||||
pickPositionSupported: true,
|
||||
pickPosition: (at) => (at.x === 500 && at.y === 300 ? centre : undefined),
|
||||
});
|
||||
viewer.scene.canvas.clientWidth = 1000;
|
||||
viewer.scene.canvas.clientHeight = 600;
|
||||
// Registered before the layer exists, so a throwing create() still
|
||||
// restores the document; destroy() runs first, while the stub is in place.
|
||||
let layer = null;
|
||||
t.after(() => {
|
||||
layer?.destroy();
|
||||
globalThis.document = saved;
|
||||
});
|
||||
layer = create({ providers: [provider], services: { scenePick } });
|
||||
layer.init(viewer);
|
||||
layer.enable(viewer);
|
||||
layer.armNearest(null, { providerIds: [provider.id], radiusM: 250 });
|
||||
assert.equal(
|
||||
layer.getUIState().street.armed.point,
|
||||
null,
|
||||
'no point stored, not 0,0',
|
||||
);
|
||||
await layer.openNearest(undefined, { aim: 'screen-centre' });
|
||||
assert.equal(lookups.length, 1);
|
||||
assert.ok(
|
||||
Math.abs(lookups[0].lat - 38.5799) < 1e-9,
|
||||
'the screen centre, not Null Island',
|
||||
);
|
||||
assert.ok(Math.abs(lookups[0].lon - -121.4937) < 1e-9);
|
||||
assert.equal(lookups[0].radiusM, 250, 'with the armed radius');
|
||||
});
|
||||
|
||||
test('the action over the real layer: a billed link arms without a lookup, and one press makes exactly one at the point', async (t) => {
|
||||
const { layer, fake, viewer } = await withStreetView(t);
|
||||
// The runner wires pointer tracking to the clock and camera.
|
||||
viewer.clock ??= { onTick: { addEventListener: () => () => {} } };
|
||||
viewer.camera.moveEnd ??= { addEventListener() {} };
|
||||
const dataManager = {
|
||||
layers: new Map([['street-level', { module: layer }]]),
|
||||
isEnabled: () => true,
|
||||
getLayerParams: () => layer.getParams(),
|
||||
setLayerParams: (_id, params) => {
|
||||
layer.setParams(params);
|
||||
return true;
|
||||
},
|
||||
getAll: () => [{ id: 'street-level', name: 'Street Level', enabled: true }],
|
||||
};
|
||||
const styleManager = {
|
||||
mapStackController: { getActiveId: () => 'photoreal' },
|
||||
setMapStack: async () => ({ ok: true, activeStack: 'photoreal' }),
|
||||
};
|
||||
const runner = createGevActionRunner({ viewer, styleManager, dataManager });
|
||||
const before = fake.lookups.length;
|
||||
const armed = await runner('show_street_level', {
|
||||
latitude: 38.57986,
|
||||
longitude: -121.49372,
|
||||
provider: 'google',
|
||||
fly: false,
|
||||
autoOpen: false,
|
||||
});
|
||||
assert.equal(armed.ok, true, armed.error);
|
||||
assert.equal(armed.armed, true);
|
||||
assert.equal(armed.providerName, 'Google Street View');
|
||||
await settle();
|
||||
assert.equal(fake.lookups.length, before, 'arming made no Google request');
|
||||
assert.deepEqual(
|
||||
layer
|
||||
.getUIState()
|
||||
.providers.filter((p) => p.on)
|
||||
.map((p) => p.id),
|
||||
['google'],
|
||||
);
|
||||
assert.equal(layer.getUIState().street.open, false);
|
||||
// The OPEN button.
|
||||
assert.equal(
|
||||
await layer.openNearest(undefined, {
|
||||
providerIds: ['google'],
|
||||
frame: false,
|
||||
aim: 'screen-centre',
|
||||
}),
|
||||
true,
|
||||
);
|
||||
assert.equal(fake.lookups.length, before + 1, 'one request for the press');
|
||||
assert.deepEqual(fake.lookups.at(-1).location, {
|
||||
lat: 38.57986,
|
||||
lng: -121.49372,
|
||||
});
|
||||
assert.equal(fake.lookups.at(-1).radius, 250);
|
||||
assert.equal(layer.getUIState().street.imageId, 'pano-a');
|
||||
// The same call without the gate opens at once, with one request.
|
||||
layer.closeViewer();
|
||||
const opened = await runner('show_street_level', {
|
||||
latitude: 38.57986,
|
||||
longitude: -121.49372,
|
||||
provider: 'google',
|
||||
fly: false,
|
||||
});
|
||||
assert.equal(opened.ok, true, opened.error);
|
||||
assert.equal(opened.imageId, 'pano-a');
|
||||
assert.equal(fake.lookups.length, before + 2);
|
||||
});
|
||||
|
||||
test('coverageLines hands back what a provider draws, and nothing for providers without lines', async (t) => {
|
||||
const drawing = fakeProvider();
|
||||
const create = drawing.create;
|
||||
drawing.create = (context) => ({
|
||||
...create(context),
|
||||
coverageLines: () => [
|
||||
{
|
||||
id: 's1',
|
||||
parts: [
|
||||
[
|
||||
[1, 2],
|
||||
[1, 2.001],
|
||||
],
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
const { layer } = await enabledLayer(t, [drawing]);
|
||||
assert.deepEqual(layer.coverageLines(drawing.id), [
|
||||
{
|
||||
id: 's1',
|
||||
parts: [
|
||||
[
|
||||
[1, 2],
|
||||
[1, 2.001],
|
||||
],
|
||||
],
|
||||
},
|
||||
]);
|
||||
assert.deepEqual(layer.coverageLines('nope'), []);
|
||||
});
|
||||
|
||||
test('coverageLines is empty for a provider that draws no coverage', async (t) => {
|
||||
const { layer } = await enabledLayer(t, [fakeProvider()]);
|
||||
assert.deepEqual(layer.coverageLines(fakeProvider().id), []);
|
||||
});
|
||||
|
||||
test('openNearest keeps honouring the caller after the lookup: an abort while the viewer loads opens nothing', async (t) => {
|
||||
let releaseMount = null;
|
||||
const provider = fakeProvider({ nearestImage: async () => 'img-1' });
|
||||
const create = provider.create;
|
||||
provider.create = (context) => {
|
||||
const instance = create(context);
|
||||
const mount = instance.viewer.mount;
|
||||
instance.viewer.mount = async (...args) => {
|
||||
await new Promise((resolve) => {
|
||||
releaseMount = resolve;
|
||||
});
|
||||
return mount(...args);
|
||||
};
|
||||
return instance;
|
||||
};
|
||||
const { layer } = await enabledLayer(t, [provider]);
|
||||
const { fakeHost } =
|
||||
await import('../../testSupport/googleStreetViewFakes.mjs');
|
||||
layer.attachViewerHost(fakeHost());
|
||||
const controller = new AbortController();
|
||||
const pending = layer.openNearest(
|
||||
{ lat: 1, lon: 2 },
|
||||
{ frame: false, signal: controller.signal },
|
||||
);
|
||||
for (let i = 0; i < 20 && !releaseMount; i++) await settle();
|
||||
assert.ok(releaseMount, 'the lookup answered and the viewer is mounting');
|
||||
controller.abort();
|
||||
releaseMount();
|
||||
assert.equal(await pending, false);
|
||||
assert.deepEqual(provider.calls.open, [], 'the photo was never opened');
|
||||
assert.equal(layer.getUIState().street.open, false);
|
||||
assert.equal(layer.getUIState().street.loading, false);
|
||||
});
|
||||
|
||||
test('an aborted older lookup leaves its replacement’s spinner alone', async (t) => {
|
||||
const answers = [];
|
||||
const provider = fakeProvider({
|
||||
nearestImage: (_point, { signal } = {}) =>
|
||||
new Promise((resolve, reject) => {
|
||||
answers.push(resolve);
|
||||
signal?.addEventListener('abort', () =>
|
||||
reject(Object.assign(new Error('aborted'), { name: 'AbortError' })),
|
||||
);
|
||||
}),
|
||||
});
|
||||
const { layer } = await enabledLayer(t, [provider]);
|
||||
const { fakeHost } =
|
||||
await import('../../testSupport/googleStreetViewFakes.mjs');
|
||||
layer.attachViewerHost(fakeHost());
|
||||
const older = new AbortController();
|
||||
const first = layer.openNearest(
|
||||
{ lat: 1, lon: 2 },
|
||||
{ frame: false, signal: older.signal },
|
||||
);
|
||||
await settle();
|
||||
// A newer request replaces it, and its caller withdraws the old one too.
|
||||
const second = layer.openNearest({ lat: 3, lon: 4 }, { frame: false });
|
||||
older.abort();
|
||||
assert.equal(await first, false);
|
||||
assert.equal(
|
||||
layer.getUIState().street.loading,
|
||||
true,
|
||||
'the newer lookup is still loading',
|
||||
);
|
||||
answers.at(-1)(null);
|
||||
assert.equal(await second, false);
|
||||
assert.equal(layer.getUIState().street.loading, false);
|
||||
assert.match(
|
||||
layer.getUIState().street.error,
|
||||
/No street-level imagery/,
|
||||
'the newer lookup reports its own result',
|
||||
);
|
||||
});
|
||||
|
||||
test('show_street_level opens a KartaView photo, and a plain link opens it at once since it is not billed', async (t) => {
|
||||
const mapillary = fakeProvider();
|
||||
let nearest = 'kv-1';
|
||||
const kartaview = fakeProvider({
|
||||
id: 'kartaview',
|
||||
pickPrefix: 'kv:',
|
||||
nearestImage: async () => nearest,
|
||||
});
|
||||
kartaview.name = 'KartaView';
|
||||
kartaview.label = 'KARTAVIEW';
|
||||
kartaview.defaultOn = false;
|
||||
// As the real provider: 360° / flat and SINCE (the setFilter log stays in
|
||||
// the fake's closure).
|
||||
kartaview.filters = Object.freeze(['pano', 'since']);
|
||||
const { layer, viewer } = await enabledLayer(t, [mapillary, kartaview]);
|
||||
const { fakeHost } =
|
||||
await import('../../testSupport/googleStreetViewFakes.mjs');
|
||||
layer.attachViewerHost(fakeHost());
|
||||
viewer.clock ??= { onTick: { addEventListener: () => () => {} } };
|
||||
viewer.camera.moveEnd ??= { addEventListener() {} };
|
||||
const dataManager = {
|
||||
layers: new Map([['street-level', { module: layer }]]),
|
||||
isEnabled: () => true,
|
||||
getLayerParams: () => layer.getParams(),
|
||||
setLayerParams: (_id, params) => {
|
||||
layer.setParams(params);
|
||||
return true;
|
||||
},
|
||||
getAll: () => [{ id: 'street-level', name: 'Street Level', enabled: true }],
|
||||
};
|
||||
const styleManager = {
|
||||
mapStackController: { getActiveId: () => 'osm' },
|
||||
setMapStack: async () => ({ ok: false, error: 'no map switch expected' }),
|
||||
};
|
||||
const runner = createGevActionRunner({ viewer, styleManager, dataManager });
|
||||
// The way a plain sl=kartaview link calls it: autoOpen false.
|
||||
const result = await runner('show_street_level', {
|
||||
latitude: 52.52,
|
||||
longitude: 13.405,
|
||||
provider: 'kartaview',
|
||||
fly: false,
|
||||
autoOpen: false,
|
||||
});
|
||||
assert.equal(result.ok, true, result.error);
|
||||
assert.equal(result.armed, undefined, 'not armed: KartaView bills nothing');
|
||||
assert.equal(result.provider, 'kartaview');
|
||||
assert.equal(result.providerName, 'KartaView');
|
||||
assert.deepEqual(
|
||||
layer
|
||||
.getUIState()
|
||||
.providers.filter((p) => p.on)
|
||||
.map((p) => p.id),
|
||||
['kartaview'],
|
||||
);
|
||||
assert.deepEqual(kartaview.calls.open, ['kv-1']);
|
||||
assert.equal(layer.providerStatus('kartaview').billed, false);
|
||||
assert.equal(layer.requiredMapStack('kartaview'), null);
|
||||
|
||||
// With 360° only on, an empty search names the filter, not just "no imagery".
|
||||
layer.closeViewer?.();
|
||||
layer.setParams({ pano: 'pano' });
|
||||
nearest = null;
|
||||
const empty = await runner('show_street_level', {
|
||||
latitude: 52.52,
|
||||
longitude: 13.405,
|
||||
provider: 'kartaview',
|
||||
fly: false,
|
||||
});
|
||||
assert.deepEqual([empty.ok, empty.stage], [false, 'imagery']);
|
||||
assert.equal(empty.filter?.pano, 'pano');
|
||||
assert.match(empty.error, /with the 360° filter on$/);
|
||||
layer.setParams({ pano: 'all' });
|
||||
const plain = await runner('show_street_level', {
|
||||
latitude: 52.52,
|
||||
longitude: 13.405,
|
||||
provider: 'kartaview',
|
||||
fly: false,
|
||||
});
|
||||
assert.equal(plain.ok, false);
|
||||
assert.equal(plain.filter, undefined, 'no filter, no hint');
|
||||
assert.doesNotMatch(plain.error, /filter/);
|
||||
});
|
||||
|
||||
test('show_street_level switches from KartaView to Panoramax and opens its photo at once, unbilled', async (t) => {
|
||||
const mapillary = fakeProvider();
|
||||
const kartaview = fakeProvider({ id: 'kartaview', pickPrefix: 'kv:' });
|
||||
kartaview.name = 'KartaView';
|
||||
kartaview.defaultOn = false;
|
||||
const panoramax = fakeProvider({
|
||||
id: 'panoramax',
|
||||
pickPrefix: 'px:',
|
||||
nearestImage: async () => 'px-1',
|
||||
});
|
||||
panoramax.name = 'Panoramax';
|
||||
panoramax.label = 'PANORAMAX';
|
||||
panoramax.defaultOn = false;
|
||||
const { layer, viewer } = await enabledLayer(t, [
|
||||
mapillary,
|
||||
kartaview,
|
||||
panoramax,
|
||||
]);
|
||||
const { fakeHost } =
|
||||
await import('../../testSupport/googleStreetViewFakes.mjs');
|
||||
layer.attachViewerHost(fakeHost());
|
||||
viewer.clock ??= { onTick: { addEventListener: () => () => {} } };
|
||||
viewer.camera.moveEnd ??= { addEventListener() {} };
|
||||
layer.setParams({ mapillary: false, kartaview: true, panoramax: false });
|
||||
const dataManager = {
|
||||
layers: new Map([['street-level', { module: layer }]]),
|
||||
isEnabled: () => true,
|
||||
getLayerParams: () => layer.getParams(),
|
||||
setLayerParams: (_id, params) => {
|
||||
layer.setParams(params);
|
||||
return true;
|
||||
},
|
||||
getAll: () => [{ id: 'street-level', name: 'Street Level', enabled: true }],
|
||||
};
|
||||
const styleManager = {
|
||||
mapStackController: { getActiveId: () => 'osm' },
|
||||
setMapStack: async () => ({ ok: false, error: 'no map switch expected' }),
|
||||
};
|
||||
const runner = createGevActionRunner({ viewer, styleManager, dataManager });
|
||||
// The way a plain sl=panoramax link calls it: autoOpen false.
|
||||
const result = await runner('show_street_level', {
|
||||
latitude: 48.8874,
|
||||
longitude: 2.3495,
|
||||
provider: 'panoramax',
|
||||
fly: false,
|
||||
autoOpen: false,
|
||||
});
|
||||
assert.equal(result.ok, true, result.error);
|
||||
assert.equal(result.armed, undefined, 'not armed: Panoramax bills nothing');
|
||||
assert.equal(result.providerName, 'Panoramax');
|
||||
assert.deepEqual(
|
||||
layer
|
||||
.getUIState()
|
||||
.providers.filter((p) => p.on)
|
||||
.map((p) => p.id),
|
||||
['panoramax'],
|
||||
'KartaView switched off',
|
||||
);
|
||||
assert.deepEqual(panoramax.calls.open, ['px-1']);
|
||||
assert.deepEqual(kartaview.calls.open, [], 'nothing asked of KartaView');
|
||||
assert.equal(layer.providerStatus('panoramax').billed, false);
|
||||
assert.equal(layer.requiredMapStack('panoramax'), null);
|
||||
});
|
||||
|
||||
test('the panel says why a lit Street View draws nothing off Google 3D', async (t) => {
|
||||
const { presentStreetLevelPanel } =
|
||||
await import('../../ui/streetLevelPresentation.js');
|
||||
|
||||
@@ -531,6 +531,25 @@ export function createLineCoverage({
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The sequence lines drawn now, as `[lon, lat]` parts per sequence: for
|
||||
* diagnostics and the browser gate, which aims its clicks at them instead
|
||||
* of scanning pixels: what each tile drew (`attachPrimitive` keeps it in
|
||||
* `entry.sequences`). Read-only copies.
|
||||
*/
|
||||
function drawnLines() {
|
||||
const lines = [];
|
||||
for (const entry of state.coverage.tiles.values())
|
||||
for (const sequence of entry.sequences.values())
|
||||
lines.push({
|
||||
id: sequence.id,
|
||||
parts: (sequence.parts || []).map((part) =>
|
||||
part.map(([lon, lat]) => [lon, lat]),
|
||||
),
|
||||
});
|
||||
return lines;
|
||||
}
|
||||
|
||||
return {
|
||||
attach,
|
||||
detach,
|
||||
@@ -543,5 +562,6 @@ export function createLineCoverage({
|
||||
highlight,
|
||||
sequenceCount,
|
||||
stats,
|
||||
drawnLines,
|
||||
};
|
||||
}
|
||||
@@ -654,3 +654,67 @@ test('the selected sequence is drawn and highlighted even past the per-tile cap'
|
||||
assert.ok(state.coverage.highlight, 'the selected line is highlighted');
|
||||
coverage.clear();
|
||||
});
|
||||
|
||||
test('drawnLines reports the lines on the globe as [lon, lat] copies, filtered like the drawing', async () => {
|
||||
const { source, state, coverage, centre } = setup();
|
||||
assert.deepEqual(coverage.drawnLines(), [], 'nothing before a tile');
|
||||
const sequences = [
|
||||
{
|
||||
id: 'flat-1',
|
||||
parts: [
|
||||
[
|
||||
[centre.lon - 0.001, centre.lat],
|
||||
[centre.lon + 0.001, centre.lat],
|
||||
],
|
||||
],
|
||||
capturedAt: 2_000_000_000_000,
|
||||
},
|
||||
{
|
||||
id: 'pano-1',
|
||||
parts: [
|
||||
[
|
||||
[centre.lon, centre.lat - 0.001],
|
||||
[centre.lon, centre.lat],
|
||||
[centre.lon, centre.lat + 0.001],
|
||||
],
|
||||
],
|
||||
capturedAt: 1_000_000_000_000,
|
||||
isPano: true,
|
||||
},
|
||||
];
|
||||
state.filter = { pano: 'pano', sinceDays: 0 };
|
||||
coverage.refresh();
|
||||
source.calls[0].resolve(encodeCoverageTile(centre.tile, { sequences }));
|
||||
await settle();
|
||||
const lines = coverage.drawnLines();
|
||||
assert.deepEqual(
|
||||
lines.map((line) => line.id),
|
||||
['pano-1'],
|
||||
'only the drawn (filtered) lines',
|
||||
);
|
||||
assert.equal(lines[0].parts.length, 1);
|
||||
assert.equal(lines[0].parts[0].length, 3);
|
||||
// Tile coordinates are quantised to the tile grid (a few metres at z14).
|
||||
const [midLon, midLat] = lines[0].parts[0][1];
|
||||
assert.ok(
|
||||
Math.abs(midLon - centre.lon) < 1e-4 &&
|
||||
Math.abs(midLat - centre.lat) < 1e-4,
|
||||
`coordinates as [lon, lat]: ${midLon}, ${midLat} vs ${centre.lon}, ${centre.lat}`,
|
||||
);
|
||||
assert.ok(
|
||||
lines[0].parts[0][0][1] < lines[0].parts[0][2][1],
|
||||
'vertex order kept: south to north',
|
||||
);
|
||||
// Copies: a caller cannot bend the drawn line.
|
||||
lines[0].parts[0][1][0] = 0;
|
||||
assert.notEqual(coverage.drawnLines()[0].parts[0][1][0], 0);
|
||||
state.filter = { pano: 'all', sinceDays: 0 };
|
||||
coverage.rebuild();
|
||||
assert.deepEqual(
|
||||
coverage
|
||||
.drawnLines()
|
||||
.map((line) => line.id)
|
||||
.sort(),
|
||||
['flat-1', 'pano-1'],
|
||||
);
|
||||
});
|
||||
@@ -40,6 +40,14 @@ export const FILTER_DEFAULT = Object.freeze({ pano: 'all', sinceDays: 0 });
|
||||
/** Nearest-image search radius in metres. */
|
||||
export const NEAREST_RADIUS_M = 50;
|
||||
|
||||
/**
|
||||
* Widest nearest-image radius a caller may ask for, in metres. A geocoded
|
||||
* landmark sits at its centroid, often further than 50 m from the nearest
|
||||
* street; providers that can search wider (Google) honour it, the rest keep
|
||||
* their own cap.
|
||||
*/
|
||||
export const NEAREST_RADIUS_MAX_M = 250;
|
||||
|
||||
/** The Google 3D map stack: Street View may be shown only on it. */
|
||||
export const GOOGLE_3D_MAP_STACK_ID = 'photoreal';
|
||||
|
||||
|
||||
@@ -12,6 +12,7 @@ import {
|
||||
GROUND_CLICK_HINT,
|
||||
KEY_REJECTED_MESSAGE,
|
||||
NEAREST_RADIUS_M,
|
||||
NEAREST_RADIUS_MAX_M,
|
||||
NEAREST_TIMEOUT_MS,
|
||||
NO_ANSWER_MESSAGE,
|
||||
PICK_PREFIX,
|
||||
@@ -67,6 +68,7 @@ export function createGoogleProvider({
|
||||
requiresMapStack: GOOGLE_3D_MAP_STACK_ID,
|
||||
// Every panorama is billed to the Maps key.
|
||||
defaultOn: false,
|
||||
billedPerImage: true,
|
||||
// All 360°, and no coverage for a date filter to thin.
|
||||
filters: [],
|
||||
marker: Object.freeze({ kind: 'view-cone', color: COLORS.coverage }),
|
||||
@@ -136,8 +138,12 @@ export function createGoogleProvider({
|
||||
* Nearest Google-collected outdoor panorama, or null. The imagery
|
||||
* filters do not apply (see `filters`).
|
||||
*/
|
||||
async nearestImage({ lat, lon }, { signal } = {}) {
|
||||
async nearestImage({ lat, lon }, { signal, radiusM } = {}) {
|
||||
if (loader.authFailed()) throw new Error(KEY_REJECTED_MESSAGE);
|
||||
// Wider than the shared default only on request, never past the cap.
|
||||
const radius = Number.isFinite(radiusM)
|
||||
? Math.min(NEAREST_RADIUS_MAX_M, Math.max(1, radiusM))
|
||||
: NEAREST_RADIUS_M;
|
||||
signal?.throwIfAborted();
|
||||
// Set once the caller has its answer (aborted, timed out, refused):
|
||||
// a lookup still waiting on Google's script then asks nothing.
|
||||
@@ -150,7 +156,7 @@ export function createGoogleProvider({
|
||||
try {
|
||||
const { data } = await service.getPanorama({
|
||||
location: { lat, lng: lon },
|
||||
radius: NEAREST_RADIUS_M,
|
||||
radius,
|
||||
// Both: Google's own imagery, outdoors (sources intersect).
|
||||
sources: [GOOGLE, OUTDOOR],
|
||||
preference: lib.StreetViewPreference.NEAREST,
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import { COLORS as SHARED_COLORS, PROVIDER_COLORS } from '../../policy.js';
|
||||
import { msg } from '../../../../i18n/index.js';
|
||||
|
||||
export { NEAREST_RADIUS_M } from '../../policy.js';
|
||||
export { NEAREST_RADIUS_M, NEAREST_RADIUS_MAX_M } from '../../policy.js';
|
||||
|
||||
export const GOOGLE_PROVIDER_ID = 'google';
|
||||
export const GOOGLE_NAME = msg('Google Street View');
|
||||
|
||||
@@ -291,3 +291,13 @@ test('the panorama a lookup found is dated without a second lookup', async () =>
|
||||
'no getPanorama({pano}) for a panorama the lookup already described',
|
||||
);
|
||||
});
|
||||
|
||||
test('a wider lookup radius is honoured up to the cap', async () => {
|
||||
const { instance, fake } = setup();
|
||||
await instance.nearestImage({ lat: 38.58, lon: -121.49 }, { radiusM: 250 });
|
||||
assert.equal(fake.lookups.at(-1).radius, 250);
|
||||
await instance.nearestImage({ lat: 38.58, lon: -121.49 }, { radiusM: 9999 });
|
||||
assert.equal(fake.lookups.at(-1).radius, 250);
|
||||
await instance.nearestImage({ lat: 38.58, lon: -121.49 }, { radiusM: NaN });
|
||||
assert.equal(fake.lookups.at(-1).radius, 50);
|
||||
});
|
||||
@@ -535,6 +535,7 @@ export function createKartaViewProvider({
|
||||
loading: state.sequence.loading,
|
||||
error: state.sequence.error,
|
||||
}),
|
||||
coverageLines: () => coverage.drawnLines(),
|
||||
|
||||
/**
|
||||
* The nearest photo within the search radius that can be shown, or
|
||||
|
||||
@@ -191,6 +191,7 @@ export function createMapillaryProvider({ source, photoViewer = null }) {
|
||||
loading: state.sequence.loading,
|
||||
error: state.sequence.error,
|
||||
}),
|
||||
coverageLines: () => parts.coverage.drawnLines(),
|
||||
|
||||
viewer:
|
||||
photoViewer ||
|
||||
|
||||
@@ -526,6 +526,9 @@ export function createPanoramaxProvider({
|
||||
cones.clearSelection();
|
||||
drawn = null;
|
||||
},
|
||||
// The lines drawn now (current and stale tiles), as [lon, lat]
|
||||
// parts, for diagnostics and the browser gate's line clicks.
|
||||
coverageLines: () => coverage.drawnLines(),
|
||||
sequenceStats: () => ({
|
||||
selectedId: state.sequence.selectedId,
|
||||
images: state.sequence.images.length,
|
||||
|
||||
@@ -1182,3 +1182,9 @@ test('a busy or timed-out tile keeps its own message; only a body that is not a
|
||||
assert.equal(env.instance.sequenceStats().error, failure.message);
|
||||
}
|
||||
});
|
||||
|
||||
test('coverageLines exposes the drawn lines, none before any tile', () => {
|
||||
const { instance } = setup();
|
||||
assert.equal(typeof instance.coverageLines, 'function');
|
||||
assert.deepEqual(instance.coverageLines(), []);
|
||||
});
|
||||
@@ -20,6 +20,7 @@ export function filtersOf(provider) {
|
||||
* @property {boolean} [groundClick] No coverage: a ground click at street zoom opens its nearest image.
|
||||
* @property {string} [requiresMapStack] Usable only on this map stack.
|
||||
* @property {boolean} [defaultOn] Default true; the first that defaults on is lit.
|
||||
* @property {boolean} [billedPerImage] Every image load costs the key's owner: a link never opens one without a click.
|
||||
* @property {{kind: 'view-cone', color: string}} [marker] Default: GEV's pin.
|
||||
* @property {Array<'pano'|'since'>} [filters] Filters it honours (default both).
|
||||
* @property {{noun: string, action: string}} [coverageLabel] How the panel counts its lines and says what a click does (default: sequences, "click a line for its photos").
|
||||
@@ -48,7 +49,8 @@ export function filtersOf(provider) {
|
||||
* @property {(sequenceId: string) => Promise<void>} [selectSequence]
|
||||
* @property {() => void} [clearSequence]
|
||||
* @property {() => {selectedId: string|null, images: number, loading: boolean, error?: string|null}} [sequenceStats]
|
||||
* @property {(point: {lat: number, lon: number}, options?: {signal?: AbortSignal}) => Promise<string|null>} [nearestImage] For ground clicks and `openNearest`; an aborted lookup gives up (it may reject with an AbortError).
|
||||
* @property {() => Array<{id: string, parts: Array<Array<[number, number]>>}>} [coverageLines] The coverage lines drawn now, as [lon, lat] parts (diagnostics and the browser gate).
|
||||
* @property {(point: {lat: number, lon: number}, options?: {signal?: AbortSignal, radiusM?: number}) => Promise<string|null>} [nearestImage] For ground clicks and `openNearest`; an aborted lookup gives up (it may reject with an AbortError). `radiusM` asks for a wider search than NEAREST_RADIUS_M; a provider that cannot search wider ignores it.
|
||||
* @property {ViewerAdapter} viewer
|
||||
*
|
||||
* @typedef {object} ViewerAdapter
|
||||
|
||||
@@ -29,6 +29,8 @@ export function freshStreet() {
|
||||
externalUrl: null,
|
||||
loading: false,
|
||||
error: null,
|
||||
// A lookup a link prepared but left to a click: {point, providerIds, radiusM}.
|
||||
armed: null,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -99,12 +99,17 @@ export function createViewerHost({ state, parts }) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Open an image: true once its first pose is in, false if it failed or was
|
||||
* overtaken. `frame: false` leaves the camera where it is.
|
||||
* Open an image: true once its first pose is in, false if it failed, was
|
||||
* overtaken, or `signal` fired first. An abort while the viewer mounts or
|
||||
* loads closes the photo: nothing opens for a request that was withdrawn.
|
||||
*/
|
||||
async function open(providerId, imageId, { frame = true } = {}) {
|
||||
async function open(
|
||||
providerId,
|
||||
imageId,
|
||||
{ frame = true, signal = null } = {},
|
||||
) {
|
||||
const entry = state.providers.get(providerId);
|
||||
if (!entry || !imageId) return false;
|
||||
if (!entry || !imageId || signal?.aborted) return false;
|
||||
if (!state.street.host) {
|
||||
// A nearest-image lookup may have set it; nothing is loading now.
|
||||
state.street.loading = false;
|
||||
@@ -115,6 +120,10 @@ export function createViewerHost({ state, parts }) {
|
||||
}
|
||||
const seq = ++openSeq;
|
||||
const current = () => seq === openSeq;
|
||||
const onAbort = () => {
|
||||
if (current()) close();
|
||||
};
|
||||
signal?.addEventListener('abort', onAbort, { once: true });
|
||||
// Claimed now, honoured after loading only if nothing newer took the camera.
|
||||
const ticket = frame ? parts.framing.begin() : null;
|
||||
Object.assign(state.street, {
|
||||
@@ -138,6 +147,7 @@ export function createViewerHost({ state, parts }) {
|
||||
if (current())
|
||||
state.street.error = error?.message || msg('Image could not be opened');
|
||||
} finally {
|
||||
signal?.removeEventListener('abort', onAbort);
|
||||
if (current()) state.street.loading = false;
|
||||
notify();
|
||||
}
|
||||
|
||||
@@ -557,6 +557,51 @@ test('an adapter that can frame but says this image has no frame offers no FIT /
|
||||
assert.equal(state.street.renderModes, true, 'a flat image can be framed');
|
||||
});
|
||||
|
||||
test('a caller that withdraws while the viewer is still mounting gets no photo', async () => {
|
||||
const gate = deferred();
|
||||
const adapter = fakeAdapter({ gate });
|
||||
const { state, host } = harness(adapter);
|
||||
const controller = new AbortController();
|
||||
const pending = host.open('mapillary', 'a', { signal: controller.signal });
|
||||
assert.equal(state.street.open, true, 'opening');
|
||||
controller.abort(); // the library is still loading
|
||||
gate.resolve();
|
||||
assert.equal(await pending, false);
|
||||
assert.deepEqual(adapter.calls.open, [], 'the image was never opened');
|
||||
assert.equal(state.street.open, false, 'the photo is closed');
|
||||
assert.equal(state.street.loading, false, 'no stuck spinner');
|
||||
assert.equal(state.street.imageId, null);
|
||||
});
|
||||
|
||||
test('a caller that withdraws while the photo is loading gets it closed', async () => {
|
||||
const openGate = deferred();
|
||||
const adapter = fakeAdapter({ openGate });
|
||||
const { state, host } = harness(adapter);
|
||||
const controller = new AbortController();
|
||||
const pending = host.open('mapillary', 'a', { signal: controller.signal });
|
||||
await settle();
|
||||
assert.deepEqual(adapter.calls.open, ['a'], 'loading');
|
||||
controller.abort();
|
||||
openGate.resolve();
|
||||
assert.equal(await pending, false);
|
||||
assert.equal(state.street.open, false, 'the withdrawn photo is closed');
|
||||
assert.equal(state.street.imageId, null);
|
||||
// An already-withdrawn request asks nothing at all.
|
||||
const done = new AbortController();
|
||||
done.abort();
|
||||
assert.equal(
|
||||
await host.open('mapillary', 'b', { signal: done.signal }),
|
||||
false,
|
||||
);
|
||||
assert.deepEqual(adapter.calls.open, ['a']);
|
||||
// A signal that never fires changes nothing.
|
||||
assert.equal(
|
||||
await host.open('mapillary', 'c', { signal: new AbortController().signal }),
|
||||
true,
|
||||
);
|
||||
assert.equal(state.street.imageId, 'c');
|
||||
});
|
||||
|
||||
test('a pose’s licence reaches the caption state, and a closed viewer forgets it', async () => {
|
||||
const { state, host, google } = twoProviders();
|
||||
await host.open('google', 'g-1');
|
||||
|
||||
Reference in new issue
Block a user