Merge origin/main: Google Street View, KartaView and Panoramax on the slim Street Level

Main gained three imagery providers (Google Street View, KartaView,
Panoramax), shared line-coverage, cone and photo-viewer modules, one source
lit at a time and the translated interface. Their shared modules still
carried what this branch removes, so the merge ports them onto it:

- lineCoverage.js is this branch's coverage.js made provider-neutral
  (draped lines near the ground only, the selection drawn over them, key
  and rate-limit blocking); sequenceCones.js is sequences.js the same way.
  Mapillary, KartaView and Panoramax all build on them; Mapillary moves
  back to providers/mapillary/ beside the others.
- No ground casting, mesh sampling, surface modes, FOLLOW, legend, prewarm,
  orbit overview points (Panoramax's density dots included), stale-tile
  swaps or water-filled point budget come back.
- Kept from main because the new providers need them: requiresMapStack and
  attachMapStackController (Street View on Google 3D only), ground clicks,
  openNearest with an optional provider nearestImage, openImage {frame},
  reportError, the view-cone marker (now an SVG glyph), filters /
  coverageLabel / sinceBasis, OPEN STREET VIEW, keyAlternatives and i18n.
- photoViewer.js treats the viewer as expanded when its wrap is full screen
  or the iPhone popover, as EXPAND now is.
- The fixture browser gate keeps its 8 steps and adds one each for
  KartaView and Panoramax; catalogs, docs, boundaries and format scope
  follow.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
German KhokhlovandClaude Opus 5.5 committed 2026-10-19 13:51:45 +04:00
commit 6390a3346f
809 files changed
+81825 -6035

No files matched your search

+538
View File
@@ -0,0 +1,538 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { createPhotoViewer } from './photoViewer.js';
import { fakeHost, until } from '../../testSupport/kartaViewFakes.mjs';
const PHOTOS = {
a: { id: 'a', sequenceId: 's', lon: 1, lat: 2, heading: 0, isPano: true },
b: { id: 'b', sequenceId: 's', lon: 1, lat: 2, heading: 0, isPano: true },
f: { id: 'f', sequenceId: 's', lon: 1, lat: 2, heading: 0, isPano: false },
g: { id: 'g', sequenceId: 's', lon: 1, lat: 2, heading: 0, isPano: false },
};
/** Sources whose panoramas and sharper flat versions are named after the photo. */
const SOURCES = {
hasPano: (photo) => photo.isPano,
panoFirst: (photo) => ({ url: `${photo.id}-first`, width: 2048 }),
panoSharp: (photo) => ({ url: `${photo.id}-sharp` }),
flatFirst: (photo) => [`${photo.id}-first`],
flatSharp: (photo, pixels) => (pixels > 1000 ? `${photo.id}-sharp` : null),
describe: () => ({ externalUrl: 'https://example.org' }),
};
/** A viewer whose loads wait until `release(url)` (or fail with `fail(url)`). */
function setup() {
const pending = new Map();
const loads = [];
const images = [];
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
load: (url) =>
new Promise((resolve, reject) => {
loads.push(url);
pending.set(url, { resolve, reject });
}),
createRenderer: () => ({
setImage: (image) => images.push(image.src),
setView() {},
getView: () => ({ yaw: 0, pitch: 0, fov: 80 }),
resize() {},
clear() {},
destroy() {},
}),
});
const release = (url) => {
const closed = { value: false };
pending.get(url).resolve({ src: url, close: () => (closed.value = true) });
pending.delete(url);
return closed;
};
const fail = (url) => {
pending.get(url).reject(new Error('gone'));
pending.delete(url);
};
return { viewer, loads, images, release, fail, host: fakeHost() };
}
const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
const parts = (host) => {
const [picture, canvas] = host.children[0].children;
return { picture, canvas };
};
test('a panorama that arrives after another photo opened is released, not shown', async () => {
const env = setup();
await env.viewer.mount(env.host);
const first = env.viewer.open('a');
await tick();
const second = env.viewer.open('b');
await tick();
const stale = env.release('a-first');
await first;
assert.equal(stale.value, true, 'its bitmap is closed');
env.release('b-first');
await second;
assert.deepEqual(env.images, ['b-first']);
});
test('one sharp panorama download per open, even across a quick switch and a burst of resizes', async (t) => {
const env = setup();
t.after(() => delete globalThis.devicePixelRatio);
globalThis.devicePixelRatio = 1;
await env.viewer.mount(env.host);
const { canvas } = parts(env.host);
canvas.clientWidth = 1800;
const opening = env.viewer.open('a');
await tick();
env.release('a-first');
await opening;
await tick();
assert.ok(env.loads.includes('a-sharp'), 'expanded: the sharp one is asked');
// Photo b opens while a's sharp version is still on its way.
const next = env.viewer.open('b');
await tick();
env.release('b-first');
await next;
await tick();
assert.ok(env.loads.includes('b-sharp'));
// a's download finishes late; resizes must not ask for b's again.
env.release('a-sharp');
await tick();
env.viewer.resize();
env.viewer.resize();
await tick();
assert.equal(env.loads.filter((url) => url === 'b-sharp').length, 1);
env.release('b-sharp');
await tick();
assert.deepEqual(env.images, ['a-first', 'b-first', 'b-sharp']);
});
test('a sharper flat version that failed is tried again on the next resize', async (t) => {
const env = setup();
t.after(() => delete globalThis.devicePixelRatio);
globalThis.devicePixelRatio = 1;
await env.viewer.mount(env.host);
const { picture } = parts(env.host);
picture.clientWidth = 1200;
const opening = env.viewer.open('f');
await tick();
env.release('f-first');
await opening;
await tick();
env.fail('f-sharp');
await tick();
assert.equal(picture.src, 'f-first');
env.viewer.resize();
await tick();
assert.equal(env.loads.filter((url) => url === 'f-sharp').length, 2);
env.release('f-sharp');
assert.ok(await until(() => picture.src === 'f-sharp'));
});
test('Esc: the docked viewer offers it to the provider first; expanded, it is the dialog’s', async () => {
let asked = 0;
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
onEscape: () => ++asked > 0,
load: async (url) => ({ src: url }),
});
const host = fakeHost();
await viewer.mount(host);
const root = host.children[0];
const press = () => {
const event = { key: 'Escape', prevented: false, stopped: false };
event.preventDefault = () => (event.prevented = true);
event.stopPropagation = () => (event.stopped = true);
root.fire('keydown', event);
return event;
};
const docked = press();
assert.equal(asked, 1);
assert.equal(docked.prevented && docked.stopped, true);
root.closest = (selector) =>
selector.includes('sl-viewer-wrap:fullscreen') ? {} : null;
const expanded = press();
assert.equal(asked, 1, 'not asked while expanded');
assert.equal(expanded.prevented, false);
});
test('a sharp panorama still downloading when another photo opens is aborted', async (t) => {
const signals = [];
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
load: (url, options) =>
url.endsWith('-sharp')
? new Promise((_, reject) => {
signals.push(options.signal);
options.signal?.addEventListener('abort', () =>
reject(new Error('aborted')),
);
})
: Promise.resolve({ src: url }),
createRenderer: () => ({
setImage() {},
setView() {},
getView: () => ({ yaw: 0, pitch: 0, fov: 80 }),
resize() {},
clear() {},
destroy() {},
}),
});
t.after(() => delete globalThis.devicePixelRatio);
globalThis.devicePixelRatio = 1;
const host = fakeHost();
await viewer.mount(host);
parts(host).canvas.clientWidth = 1800;
await viewer.open('a');
await tick();
assert.equal(signals.length, 1);
assert.equal(signals[0].aborted, false);
await viewer.open('f');
assert.equal(signals[0].aborted, true, 'not needed any more');
});
test('a lost WebGL context while the first panorama loads releases its bitmap', async () => {
let closed = false;
let built = 0;
let land = null;
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
load: (url) =>
new Promise((resolve) => {
land = () => resolve({ src: url, close: () => (closed = true) });
}),
// The first renderer is lost mid-load; a new one cannot be built.
createRenderer: () => {
built++;
if (built > 1) throw new Error('context lost');
return {
setImage() {},
setView() {},
getView: () => ({ yaw: 0, pitch: 0, fov: 80 }),
resize() {},
clear() {},
destroy() {},
};
},
});
const host = fakeHost();
await viewer.mount(host);
const opening = viewer.open('a');
assert.ok(await until(() => land !== null), 'the panorama is loading');
parts(host).canvas.fire('webglcontextlost', {});
const first = land;
first();
// The panorama failed: the front view is loaded flat instead.
assert.ok(await until(() => land !== first), 'the flat fallback loads');
land();
await opening;
assert.equal(built, 2, 'a new renderer was tried');
assert.equal(closed, true, 'the bitmap no renderer took is closed');
});
test('docked, Esc anywhere in the viewer’s box (toolbar, caption) is offered to the provider', async () => {
let asked = 0;
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
onEscape: () => ++asked > 0,
load: async (url) => ({ src: url }),
});
const host = fakeHost();
const wrap = fakeHost();
host.closest = (selector) => (selector === '.sl-viewer-wrap' ? wrap : null);
await viewer.mount(host);
const flags = { stopped: false, prevented: false };
// Focus back on EXPAND after a shrink: the key reaches the wrap, not the photo.
wrap.fire('keydown', {
key: 'Escape',
stopPropagation: () => (flags.stopped = true),
preventDefault: () => (flags.prevented = true),
});
assert.equal(asked, 1);
assert.deepEqual(flags, { stopped: true, prevented: true });
viewer.unmount();
wrap.fire('keydown', { key: 'Escape' });
assert.equal(asked, 1, 'unmounted: the listener is gone');
});
test('a picture file or bitmap past any real photo’s size is refused', async (t) => {
const { loadImage, MAX_IMAGE_BYTES, MAX_IMAGE_SIDE } =
await import('./photoViewer.js');
const saved = {
fetch: globalThis.fetch,
createImageBitmap: globalThis.createImageBitmap,
};
t.after(() => Object.assign(globalThis, saved));
let closed = 0;
const bitmap = (width, height) => ({ width, height, close: () => closed++ });
globalThis.createImageBitmap = async (blob) => blob.bitmap;
const respond = ({ length, size, width = 100, height = 50 }) =>
(globalThis.fetch = async () => ({
ok: true,
headers: new Map([['content-length', String(length ?? '')]]),
blob: async () => ({
size: size ?? 10,
bitmap: bitmap(width, height),
slice: () => ({ arrayBuffer: async () => new ArrayBuffer(0) }),
}),
}));
const refusedForSize = (error) => {
assert.match(error.message, /could not be loaded/);
assert.equal(error.tooLarge, true, 'marked as a size refusal');
return true;
};
respond({ length: MAX_IMAGE_BYTES + 1 });
await assert.rejects(loadImage('https://x/a.jpg'), refusedForSize);
respond({ size: MAX_IMAGE_BYTES + 1 });
await assert.rejects(loadImage('https://x/a.jpg'), refusedForSize);
respond({ width: MAX_IMAGE_SIDE + 1 });
await assert.rejects(loadImage('https://x/a.jpg'), refusedForSize);
assert.equal(closed, 1, 'the oversize bitmap is released');
// No length given, a body that keeps coming: cut off while it streams.
let pulled = 0;
globalThis.fetch = async () => ({
ok: true,
headers: new Map(),
body: new ReadableStream({
pull(controller) {
pulled++;
controller.enqueue(new Uint8Array(8 * 1024 * 1024));
},
}),
});
await assert.rejects(loadImage('https://x/a.jpg'), refusedForSize);
assert.ok(pulled * 8 * 1024 * 1024 <= MAX_IMAGE_BYTES + 16 * 1024 * 1024);
// Other failures are not size refusals.
globalThis.fetch = async () => ({ ok: false, headers: new Map() });
await assert.rejects(
loadImage('https://x/a.jpg'),
(error) => !error.tooLarge,
);
respond({});
assert.equal((await loadImage('https://x/a.jpg')).width, 100);
});
/** A viewer whose loads are held, recording each load's signal by url. */
function heldViewer() {
const pending = new Map();
const signals = new Map();
const loads = [];
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
load: (url, options = {}) =>
new Promise((resolve, reject) => {
loads.push(url);
signals.set(url, options.signal);
options.signal?.addEventListener('abort', () =>
reject(new Error('aborted')),
);
pending.set(url, { resolve, reject });
}),
});
const release = (url) => {
pending.get(url).resolve({ src: url });
pending.delete(url);
};
return { viewer, pending, signals, loads, release, host: fakeHost() };
}
test('a new open, a close or an unmount stops the downloads of the open before it', async () => {
const env = heldViewer();
await env.viewer.mount(env.host);
const first = env.viewer.open('f');
assert.ok(await until(() => env.signals.has('f-first')));
const second = env.viewer.open('g');
assert.equal(env.signals.get('f-first').aborted, true, 'f is not wanted now');
await first.catch(() => {});
assert.ok(await until(() => env.signals.has('g-first')));
env.viewer.close();
assert.equal(env.signals.get('g-first').aborted, true, 'closed');
await second.catch(() => {});
const third = env.viewer.open('f');
assert.ok(await until(() => env.pending.has('f-first')));
env.viewer.unmount();
assert.equal(env.signals.get('f-first').aborted, true, 'unmounted');
await third.catch(() => {});
});
test('a sharper flat version on its way stops when another photo opens, and is asked again later', async (t) => {
t.after(() => delete globalThis.devicePixelRatio);
globalThis.devicePixelRatio = 1;
const env = heldViewer();
await env.viewer.mount(env.host);
parts(env.host).picture.clientWidth = 1200;
const opening = env.viewer.open('f');
assert.ok(await until(() => env.pending.has('f-first')));
env.release('f-first');
await opening;
assert.ok(
await until(() => env.pending.has('f-sharp')),
'the 1,200 px viewer asks for more',
);
// Resizes while it loads (the panel animating) do not ask again.
env.viewer.resize();
env.viewer.resize();
await new Promise((resolve) => setTimeout(resolve, 0));
assert.equal(env.loads.filter((url) => url === 'f-sharp').length, 1);
// g opens (and fails): f's sharp download stops, f stays on screen.
const failing = env.viewer.open('g');
assert.equal(env.signals.get('f-sharp').aborted, true);
assert.ok(await until(() => env.pending.has('g-first')));
env.pending.get('g-first').reject(new Error('gone'));
env.pending.delete('g-first');
await failing.catch(() => {});
// The discarded response does not block f's sharp version for good.
env.signals.delete('f-sharp');
env.viewer.resize();
assert.ok(await until(() => env.signals.has('f-sharp')), 'asked again');
});
test('a resize while another photo opens does not upgrade the photo still shown', async (t) => {
t.after(() => delete globalThis.devicePixelRatio);
globalThis.devicePixelRatio = 1;
const env = heldViewer();
await env.viewer.mount(env.host);
const opening = env.viewer.open('f');
assert.ok(await until(() => env.pending.has('f-first')));
env.release('f-first');
await opening;
// g is opening; EXPAND resizes the viewer meanwhile.
const next = env.viewer.open('g');
assert.ok(await until(() => env.pending.has('g-first')));
parts(env.host).picture.clientWidth = 1200;
env.viewer.resize();
await new Promise((resolve) => setTimeout(resolve, 0));
assert.equal(env.pending.has('f-sharp'), false, 'f is on its way out');
env.release('g-first');
await next;
assert.ok(await until(() => env.pending.has('g-sharp')), 'g gets it');
});
test('a panorama is always decoded at a bounded size', async () => {
const env = heldViewer();
const options = [];
const viewer = createPhotoViewer({
providerId: 'test',
name: 'Test',
sources: SOURCES,
getPhoto: async (id) => PHOTOS[id],
step: async () => null,
onStep() {},
load: async (url, opts) => {
options.push(opts);
return { src: url };
},
createRenderer: () => ({
setImage() {},
setView() {},
getView: () => ({ yaw: 0, pitch: 0, fov: 80 }),
resize() {},
clear() {},
destroy() {},
}),
});
await viewer.mount(env.host);
await viewer.open('a');
// SOURCES' panoFirst names no size: the viewer still bounds it.
assert.deepEqual(options[0].resize, [2048, 1024]);
});
test('a header that declares a huge image is refused before anything decodes it', async (t) => {
const { loadImage } = await import('./photoViewer.js');
const saved = {
fetch: globalThis.fetch,
createImageBitmap: globalThis.createImageBitmap,
};
t.after(() => Object.assign(globalThis, saved));
let decoded = 0;
globalThis.createImageBitmap = async () => {
decoded++;
return { width: 10, height: 10 };
};
// A 1 kB PNG that says it is 16,384 × 16,384.
const png = new Uint8Array(1024);
png.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0, 0, 13]);
png.set(
[...'IHDR'].map((c) => c.charCodeAt(0)),
12,
);
png.set([0, 0, 0x40, 0, 0, 0, 0x40, 0], 16);
globalThis.fetch = async () => new Response(png);
await assert.rejects(
loadImage('https://x/bomb.png'),
(error) => error.tooLarge === true,
);
assert.equal(decoded, 0, 'never decoded');
});
test('an <img> that turns out too large is refused and let go', async (t) => {
const { loadImage, MAX_IMAGE_SIDE } = await import('./photoViewer.js');
const saved = globalThis.Image;
t.after(() => (globalThis.Image = saved));
let size = [MAX_IMAGE_SIDE + 1, 100];
const images = [];
globalThis.Image = class {
constructor() {
images.push(this);
}
set src(value) {
this._src = value;
if (value)
queueMicrotask(() => {
[this.naturalWidth, this.naturalHeight] = size;
this.onload?.();
});
}
get src() {
return this._src;
}
};
await assert.rejects(
loadImage('https://x/a.jpg', { crossOrigin: false }),
(error) => error.tooLarge === true,
);
assert.equal(images.at(-1).src, '', 'its pixels let go');
size = [4000, 3000];
const ok = await loadImage('https://x/b.jpg', { crossOrigin: false });
assert.equal(ok.naturalWidth, 4000);
// An aborted <img> load stops and rejects.
size = [10, 10];
const controller = new AbortController();
const aborted = loadImage('https://x/c.jpg', {
crossOrigin: false,
signal: controller.signal,
});
controller.abort();
await assert.rejects(aborted);
assert.equal(images.at(-1).src, '', 'its download stops');
});