Street Level: a landed link, a replaced photo and a retired lookup keep their state

- A link's photo step compares with the navigation token its own restore
  flight owned, so a navigation after the flight landed (while the layers
  still load) keeps the camera.
- A request that switches the source keeps the open photo up until it is
  replaced (holdViewer), so EXPAND stays across sources.
- A lookup given up while it looked leaves the open photo and the panel as
  they were, also when it found nothing or failed.
- A failed replacement shows its error inside the expanded viewer.
- A replacing lookup stops a playing Mapillary sequence before the found
  photo opens.
- The action refuses coordinates outside the globe, keeps a name given with
  coordinates as its label, and fly: false keeps the camera only for
  coordinates (its test-only entity and query branches are gone).
- Numbered entities carry their label; a view's street-level point is a pair.
- Mapillary's nearest search always asks for 50 m and 100 images.
- Tests: the lifecycle reproductions, PLAY on replacement, out-of-range
  coordinates, half a point, and the named label; three layer tests share
  enabledLayer; the second payload digest is gone.
- Docs: the tool count, the panel freshness rule, armed: false, the photo
  replacement, the browser-gate comment and a shorter changelog fragment.
This commit is contained in:
German Khokhlov committed 2026-11-10 23:48:57 +04:00
1 parent 9c73939425
commit f3996da0af
26 files changed
+470 -327

No files matched your search

+194
View File
@@ -0,0 +1,194 @@
import './testSupport/registerDom.mjs';
import test from 'node:test';
import assert from 'node:assert/strict';
import { createStreetLevelLayer } from './layers/streetLevel/index.js';
import { fakeStreetLevelProvider, fakeCesiumViewer } from './testSupport/streetLevelFakes.mjs';
import { showStreetLevel } from './voice/gevActions.js';
import { installViews } from './app/embed.js';
import { ShareRestoration } from './ui/shareRestoration.js';
import { createView } from './view/index.js';
import { StreetLevelControls } from './ui/streetLevelControls.js';
import { createApp, nextTick } from 'vue';
import { createPinia } from 'pinia';
import StreetLevelPanel from './ui/views/panels/StreetLevelPanel.vue';
import { useStreetLevelStore } from './ui/stores/streetLevel.js';
// Street-level request lifecycle across the action, the layer, links and the
// panel. Offline: providers and camera flights are fixtures.
globalThis.fetch = async () => { throw new Error('Unexpected network use in offline test'); };
const settle = () => new Promise(resolve => setTimeout(resolve, 0));
function deferred() {
let resolve;
const promise = new Promise(done => { resolve = done; });
return { promise, resolve };
}
async function harness(t, { nearestImage = async () => 'A', failImage = null, billed = false, extraProviders = [] } = {}) {
document.body.className = '';
document.body.replaceChildren();
const provider = fakeStreetLevelProvider({ nearestImage });
provider.billedPerImage = billed;
const originalCreate = provider.create;
const opened = [];
provider.create = context => {
const instance = originalCreate(context);
let pose;
instance.viewer.onPose = listener => { pose = listener; return () => { pose = null; }; };
instance.viewer.open = async id => {
opened.push(id);
if (id === failImage) throw new Error('Fixture image load failed');
pose?.({ imageId: id });
};
return instance;
};
const viewer = fakeCesiumViewer();
viewer.canvas = viewer.scene.canvas;
viewer.canvas.setPointerCapture = () => {};
const layer = createStreetLevelLayer({ providers: [provider, ...extraProviders] });
layer.init(viewer);
layer.enable(viewer);
const host = document.body.appendChild(document.createElement('div'));
layer.attachViewerHost(host);
t.after(() => { layer.destroy(); document.body.className = ''; document.body.replaceChildren(); });
await settle();
assert.equal(layer.providerStatus('mapillary').billed, billed);
const dataManager = {
layers: new Map([['street-level', { module: layer }]]),
getAll: () => [{ id: 'street-level', enabled: true }],
isEnabled: () => true,
getLayerParams: () => ({ mapillary: true }),
setLayerParams: (_id, params) => layer.setParams(params),
};
const styleManager = { _navigationGeneration: 1 };
const flights = [];
const context = {
viewer, dataManager, styleManager,
runOptions: { signal: new AbortController().signal },
runGevAction: async (name, args) => {
assert.equal(name, 'fly_to_location');
flights.push(args);
return { ok: true, latitude: 48, longitude: 2, label: 'fixture point' };
},
};
let result;
const run = async (name, args) => {
if (name !== 'show_street_level') return { ok: true };
result = await showStreetLevel(args, context);
return result;
};
const view = createView({ camera: { lat: 48, lon: 2 }, layers: ['street-level'], street_level: { provider: 'mapillary', lat: 48, lon: 2 } });
return { layer, viewer, dataManager, context, run, view, opened, flights, result: () => result };
}
test('a landed link does not reclaim a camera the user moved while its layers load', async t => {
const h = await harness(t);
const location = { search: '', hash: '' };
const shell = h.context.styleManager;
shell.initialRestorePromise = Promise.resolve();
const remove = installViews({ ...h, shell, location, windowRef: window });
t.after(remove);
await settle();
location.hash = '#sl=mapillary,48,2';
const layers = deferred();
const landed = deferred();
const restoration = Object.assign(Object.create(ShareRestoration.prototype), {
_shareRestoreGeneration: 1, _disposed: false,
shareLinkManager: {
applyState: async () => { landed.resolve(); return { camera: 'applied' }; },
completeInitialRestore() {},
},
_sharedVessel: () => null,
});
const restoring = restoration._runShareRestore({}, {
applyCamera: true, navigationToken: 1, layersPromise: layers.promise,
settle: detail => window.dispatchEvent(new CustomEvent('gev:share-navigation-restore-settled', { detail })),
});
await landed.promise;
shell._navigationGeneration++;
layers.resolve([]);
await restoring;
await settle(); await settle();
assert.equal(h.flights.length, 0, 'an old landed link must not fly after later navigation');
});
test('a replacement from another source keeps EXPAND', async t => {
const h = await harness(t, {
extraProviders: [fakeStreetLevelProvider({ id: 'panoramax', pickPrefix: 'pm:', nearestImage: async () => 'B' })],
});
const root = document.body.appendChild(document.createElement('div'));
root.innerHTML = '<button id="sl-status"></button><div id="sl-viewer-wrap"><div id="sl-viewer"></div></div><button id="sl-viewer-expand"></button>';
const wrap = root.querySelector('#sl-viewer-wrap');
let fullscreen = null;
Object.defineProperty(document, 'fullscreenElement', { configurable: true, get: () => fullscreen });
const oldExit = document.exitFullscreen;
// As a browser does: the change is announced after the switch.
const announce = () => setTimeout(() => document.dispatchEvent(new Event('fullscreenchange')), 0);
document.exitFullscreen = async () => { fullscreen = null; announce(); };
wrap.requestFullscreen = async () => { fullscreen = wrap; announce(); };
const store = { attach: () => 1, detach() {}, publish() {}, setExpandAvailable() {}, setExpanded() {}, setEmbedOverlay() {} };
const controls = new StreetLevelControls({ root, layer: h.layer, actions: {}, store });
const off = h.layer.subscribe(state => controls.render(state));
t.after(() => { off(); controls.destroy(); delete document.fullscreenElement; document.exitFullscreen = oldExit; });
assert.equal(await h.layer.openImage('mapillary', 'previous', { frame: false }), true);
await controls._toggleExpanded();
assert.equal(controls.isViewerExpanded(), true);
const result = await showStreetLevel({ provider: 'panoramax', latitude: 48, longitude: 2 }, h.context);
assert.equal(result.ok, true);
assert.equal(h.layer.getUIState().street.providerId, 'panoramax');
assert.equal(controls.isViewerExpanded(), true, 'replacement must preserve the expanded viewing surface');
});
for (const outcome of ['empty', 'error', 'image']) {
test(`a replacement retired by a navigation keeps the open photo (${outcome})`, async t => {
const lookup = deferred();
const entered = deferred();
const h = await harness(t, { nearestImage: async () => {
entered.resolve(); await lookup.promise;
if (outcome === 'error') throw new Error('Fixture lookup failure');
return outcome === 'image' ? 'B' : null;
} });
await h.layer.openImage('mapillary', 'A', { frame: false });
const action = showStreetLevel({ provider: 'mapillary', latitude: 48, longitude: 2 }, h.context);
await entered.promise;
h.context.styleManager._navigationGeneration++;
lookup.resolve();
const result = await action;
assert.ok(result.cancelled || result.superseded);
assert.deepEqual(h.opened, ['A']);
assert.equal(h.layer.getUIState().street.open, true, 'retired lookup must preserve A');
assert.equal(h.layer.getUIState().street.error, null, 'retired lookup must not publish an error');
});
}
test('a failed replacement shows its error inside the expanded viewer', async t => {
const h = await harness(t, { nearestImage: async () => 'B', failImage: 'B' });
const root = document.body.appendChild(document.createElement('div'));
const pinia = createPinia();
const app = createApp(StreetLevelPanel); app.use(pinia); app.mount(root);
const store = useStreetLevelStore(pinia);
const wrap = root.querySelector('#sl-viewer-wrap');
let fullscreen = null;
Object.defineProperty(document, 'fullscreenElement', { configurable: true, get: () => fullscreen });
const oldExit = document.exitFullscreen;
// As a browser does: the change is announced after the switch.
const announce = () => setTimeout(() => document.dispatchEvent(new Event('fullscreenchange')), 0);
document.exitFullscreen = async () => { fullscreen = null; announce(); };
wrap.requestFullscreen = async () => { fullscreen = wrap; announce(); };
const controls = new StreetLevelControls({ root, layer: h.layer, actions: {}, store });
const off = h.layer.subscribe(state => controls.render(state));
t.after(() => { off(); controls.destroy(); app.unmount(); delete document.fullscreenElement; document.exitFullscreen = oldExit; });
await h.layer.openImage('mapillary', 'A', { frame: false });
await nextTick();
await controls._toggleExpanded();
await settle();
const result = await showStreetLevel({ provider: 'mapillary', latitude: 48, longitude: 2 }, h.context);
await nextTick();
assert.equal(result.ok, false);
assert.equal(controls.isViewerExpanded(), true);
assert.equal(document.fullscreenElement, wrap);
assert.equal(h.layer.getUIState().street.imageId, 'A');
assert.match(h.layer.getUIState().street.error, /Fixture image load failed/);
assert.equal(wrap.contains(root.querySelector('#sl-error')), false);
const error = wrap.querySelector('#sl-viewer-error');
assert.match(error.textContent, /Fixture image load failed/);
assert.equal(error.hidden, false, 'error must be visible inside fullscreen');
});