Files
gods-eye-view/src/stories/controller.test.mjs
T
Manjunath 472cc35c47 Stories: phone entry, centred framing, review follow-ups
- On GEV's phone layout, where neither the style readout nor the account
  avatar shows, the Stories button goes icon-only under the corner-actions
  column instead of covering the top row of icon buttons.
- Explore frames its start view and a picked story in the middle of the
  map it leaves visible (beside the feed, above the phone sheet), with one
  short correction if that area moved during the flight.
- The share icon stays visible in icon-only header buttons.
- A world clock nothing moved while Stories was open (no jump, same mode
  and rate) is left alone on Close.
- Card images use the globe's own Esri tile URL; the credit list keeps the
  application's full-screen placement on phones.
- Tests cover the live and playing clock restores, the clock coming back
  after the share state, the tile-settling hold being released (settled,
  10 s, Close), the visible-map aim, and the near-end Play fix in the
  director's real order. One changelog fragment covers the PR.
2026-11-16 21:08:23 +05:30

1275 lines
43 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// The Stories controller: what it leaves behind in history and on GEV's
// globe when Stories opens and closes.
import '../testSupport/registerDom.mjs';
import { registerHooks } from 'node:module';
import test from 'node:test';
import assert from 'node:assert/strict';
import { createPinia, setActivePinia } from 'pinia';
import { createStateChannel } from '../app/stateChannel.js';
import { bindRenderer } from '../render/rendererOf.js';
import { getRenderGovernorDiagnostics } from '../renderGovernor.js';
const holds = () => getRenderGovernorDiagnostics().holds;
registerHooks({
load(url, context, next) {
if (url.endsWith('.webp'))
return {
format: 'module',
source: `export default ${JSON.stringify(url)};`,
shortCircuit: true,
};
return next(url, context);
},
});
const context = new Proxy(
{},
{ get: (target, name) => target[name] ?? (() => context), set: () => true },
);
globalThis.HTMLCanvasElement.prototype.getContext = (kind) =>
kind === 'webgl' ? null : context;
globalThis.requestAnimationFrame = () => 0;
globalThis.cancelAnimationFrame = () => {};
const { createStoriesController } = await import('./controller.js');
const { COCKPIT_REFUSAL_NOUNS } = await import('../navigationPolicy.js');
const { useStoriesStore } = await import('../ui/stores/stories.js');
const { listStories } = await import('./catalog.js');
/**
* The scene object Stories is handed, bound to a renderer double with the
* ports Stories uses: the camera, the frame loop (postRender listeners run
* on `draw()`), screen projection with the horizon test, and the globe's
* settling. The doubles are returned beside it for the tests to drive.
*/
function fakeScene() {
const canvas = document.createElement('canvas');
const camera = {
position: { x: 1, y: 2, z: 3 },
views: [],
flights: [],
cancels: 0,
pose() {
return {
position: { ...this.position },
heading: 0,
pitch: -1,
roll: 0,
lon: 11.46,
lat: 28.65,
height: 2e6,
};
},
setView(v) {
this.views.push(v);
},
cancelFlight() {
this.cancels += 1;
},
flyTo(destination, options) {
this.flights.push({ destination, ...options });
},
flyToBounds(sphere, options) {
this.flights.push({ sphere, ...options });
},
};
const frame = {
listeners: new Set(),
requests: [],
on(phase, fn) {
assert.equal(phase, 'postRender');
this.listeners.add(fn);
return () => this.listeners.delete(fn);
},
draw() {
for (const fn of [...this.listeners]) fn({});
},
requestRender(reason) {
this.requests.push(reason);
},
holdContinuous: () => () => {},
};
const query = {
hidden: new Set(),
project: ({ x, y }) => ({ x: x / 1e5, y: y / 1e5 }),
isOccluded(at) {
return this.hidden.has(at);
},
};
const globe = { settled: false, isSettled: () => globe.settled };
const viewer = { isDestroyed: () => false };
bindRenderer(viewer, { canvas, camera, frame, query, globe });
return { viewer, camera, frame, query, globe, canvas };
}
/** A world clock double: its state, and the calls made on it. */
function fakeClock(state = {}) {
const calls = [];
const clock = {
calls,
state: {
live: true,
timeMs: Date.UTC(2026, 0, 1),
playing: false,
rate: 1,
stepping: false,
jumps: 0,
...state,
},
getState: () => ({ ...clock.state }),
goLive() {
calls.push(['goLive']);
Object.assign(clock.state, { live: true, playing: false });
clock.state.jumps += 1;
},
seek(ms) {
calls.push(['seek', ms]);
Object.assign(clock.state, { live: false, timeMs: ms });
clock.state.jumps += 1;
},
pause() {
calls.push(['pause']);
clock.state.playing = false;
},
play(options) {
calls.push(['play', options]);
clock.state.playing = true;
},
};
return clock;
}
function fakeDirector({ refuse = false } = {}) {
const claims = [];
return {
claims,
running: false,
stops: 0,
stopScene() {
this.stops += 1;
},
whenIdle() {
return new Promise((resolve) => {
const check = () => (this.running ? setTimeout(check, 10) : resolve());
check();
});
},
listShots: () => [],
subscribeSceneClock: () => () => {},
seekScene() {},
startScene: async () => ({ started: true }),
selected: [],
selectShot(sceneId, shotId) {
this.selected.push([sceneId, shotId]);
return true;
},
styleManager: {
runImmediateNavigation: (noun) => {
claims.push(noun);
return !refuse;
},
panels: [],
setPanelCollapsed(id, collapsed) {
this.panels.push([id, collapsed]);
},
shareLinkManager: {
restored: [],
restore(hash) {
this.restored.push(hash);
return true;
},
},
},
};
}
function setup(options = {}) {
setActivePinia(createPinia());
history.replaceState(null, '', '/?x=1#v=2&lat=1');
const store = useStoriesStore();
const scene = fakeScene();
const clock = options.clock ?? fakeClock();
const director = fakeDirector(options);
const controller = createStoriesController({
viewer: scene.viewer,
director,
store,
onEnter: options.onEnter,
clock,
});
store.connect(controller, listStories());
return { ...scene, clock, store, director, controller };
}
test('Close steps back over every entry Stories pushed', async () => {
const entered = [];
const { controller } = setup({
onEnter: () =>
entered.push(document.body.classList.contains('stories-mode')),
});
const steps = [];
const go = history.go;
history.go = (n) => steps.push(n);
try {
assert.equal(controller.open(), true);
assert.equal(history.state.gevStories.depth, 1);
controller.openStory('gev:flights-radar');
assert.equal(history.state.gevStories.depth, 2);
assert.deepEqual(entered, [true]);
await controller.close();
// Back after Close would otherwise land on ?story=… and reopen it.
assert.deepEqual(steps, [-2]);
} finally {
history.go = go;
controller.destroy();
}
});
test('Close from a Stories link clears Stories from the URL in place', async () => {
const { controller } = setup();
history.replaceState(null, '', '/?stories=explore#v=2');
controller.open({ fromHistory: true });
await controller.close();
assert.equal(new URL(location.href).searchParams.has('stories'), false);
assert.equal(location.hash, '#v=2');
controller.destroy();
});
test('Cockpit keeps the camera: Stories does not open', () => {
const { controller, store, director } = setup({
refuse: true,
onEnter: () => assert.fail('refused entry should not stop voice'),
});
assert.equal(controller.open({ isCurrent: () => false }), false);
assert.deepEqual(director.claims, []);
assert.equal(controller.open(), false);
assert.equal(store.mode, 'closed');
assert.equal(director.stops, 0);
// The navigation policy shows the refusal; it needs a sentence for the noun.
assert.deepEqual(director.claims, ['stories']);
assert.ok(COCKPIT_REFUSAL_NOUNS.includes('stories'));
controller.destroy();
});
test('reopening while a scene tears down keeps the view from before Stories', async () => {
const { controller, director, store, camera } = setup();
const before = { ...camera.position };
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
const toast = store.hostedToast;
const closing = controller.openInGev();
// The scene has moved the camera; the person opens Stories again at once.
camera.position = { x: 9, y: 9, z: 9 };
controller.open();
director.running = false;
await closing;
assert.deepEqual(director.selected, []);
assert.deepEqual(director.styleManager.panels, []);
assert.equal(store.hostedToast, toast);
assert.equal(camera.views.length, 0, 'no restore under the reopened Stories');
await controller.close();
const { x, y, z } = camera.views.at(-1).destination;
assert.deepEqual({ x, y, z }, { x: before.x, y: before.y, z: before.z });
controller.destroy();
});
test('after a GEV scene, the person’s view comes back once the scene has torn down', async () => {
const { controller, director, camera } = setup();
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
const closing = controller.close();
assert.equal(camera.views.length, 0, 'not under the stopping scene');
setTimeout(() => (director.running = false), 120);
await closing;
assert.equal(camera.views.length, 1);
controller.destroy();
});
test('Share links to the selection and captures the playing story’s timeline', () => {
const { controller, store } = setup();
controller.open();
assert.equal(new URL(controller.shareLink()).search, '?stories=explore');
controller.pick('gev:orbital-watch');
assert.equal(
new URL(controller.shareLink()).search,
'?stories=explore&selectedStory=gev%3Aorbital-watch',
);
controller.openStory('gev:flights-radar');
store.playback = { ...store.playback, playing: true, wallMs: 1250.6 };
const link = new URL(controller.shareLink());
assert.deepEqual(
[...link.searchParams],
[
['story', 'gev:flights-radar'],
['storyTime', '1251'],
],
);
assert.equal(link.hash, '');
store.playback.wallMs = 1850;
assert.equal(
new URL(controller.shareLink()).searchParams.get('storyTime'),
'1850',
);
controller.backToExplore({ fromHistory: true });
assert.equal(
new URL(controller.shareLink()).search,
'?stories=explore&selectedStory=gev%3Aflights-radar',
);
controller.destroy();
});
/** Record history.go calls instead of traversing. */
function recordGo(t) {
const steps = [];
const go = history.go;
history.go = (n) => steps.push(n);
t.after(() => {
history.go = go;
});
return steps;
}
test('Back to Explore after a related story steps past both stories', (t) => {
const { controller, store } = setup();
const steps = recordGo(t);
controller.open();
controller.openStory('gev:flights-radar');
controller.openStory('gev:orbital-watch'); // a related story
assert.equal(history.state.gevStories.depth, 3);
assert.equal(history.state.gevStories.explore, 1);
controller.backToExplore();
controller.openStory('gev:flights-radar'); // queued behind Back
// The latest Back cancels that queued story without another traversal.
controller.backToExplore();
assert.deepEqual(steps, [-2]);
history.replaceState(
{ gevStories: { stories: 'explore', depth: 1, explore: 1 } },
'',
'/?stories=explore',
);
dispatchEvent(new PopStateEvent('popstate'));
assert.equal(store.mode, 'explore');
assert.equal(store.storyId, null);
assert.equal(history.state.gevStories.depth, 1, 'no queued story pushed');
controller.destroy();
});
test('a second Close after a quick reopen still waits for the scene to tear down', async () => {
const { controller, director, camera } = setup();
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
const first = controller.close({ keepCamera: true });
controller.open(); // reopened while the scene is still stopping
const closing = controller.close(); // Explore: no GEV story on screen
assert.ok(closing, 'this Close waits too');
assert.equal(camera.views.length, 0, 'nothing restored yet');
setTimeout(() => (director.running = false), 120);
await Promise.all([first, closing]);
assert.equal(camera.views.length, 1);
controller.destroy();
});
test('a reload of a Stories entry keeps its history; Close steps all of it back', async (t) => {
setActivePinia(createPinia());
history.replaceState(
{ gevStories: { story: 'gev:flights-radar', depth: 2, explore: 1 } },
'',
'/?story=gev%3Aflights-radar&storyTime=1250',
);
const steps = recordGo(t);
const store = useStoriesStore();
const controller = createStoriesController({
viewer: fakeScene().viewer,
director: fakeDirector(),
store,
});
store.connect(controller, listStories());
await new Promise((resolve) => setTimeout(resolve, 400));
assert.equal(store.storyId, 'gev:flights-radar');
assert.equal(store.playback.wallMs, 1250);
assert.equal(store.playback.playing, false);
assert.equal(history.state.gevStories.depth, 2, 'no extra entry pushed');
await controller.close();
assert.deepEqual(steps, [-2]);
controller.destroy();
});
test('a new story link puts Explore under the story', async (t) => {
setActivePinia(createPinia());
history.replaceState(null, '', '/?story=gev%3Aflights-radar&storyTime=1250');
const steps = recordGo(t);
const store = useStoriesStore();
const controller = createStoriesController({
viewer: fakeScene().viewer,
director: fakeDirector(),
store,
});
store.connect(controller, listStories());
await new Promise((resolve) => setTimeout(resolve, 400));
assert.equal(store.storyId, 'gev:flights-radar');
assert.equal(store.playback.wallMs, 1250);
assert.equal(store.playback.playing, false);
assert.deepEqual(history.state.gevStories, {
story: 'gev:flights-radar',
storyTime: 1250,
depth: 1,
explore: 0,
});
controller.backToExplore();
assert.deepEqual(steps, [-1]);
controller.destroy();
});
test('Open in GEV hands a GEV scene to the Scenes panel at its current shot', async () => {
const { controller, store, director, camera } = setup();
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
store.playback = { ...store.playback, chapterIndex: 0 };
const shotId =
store.byId('gev:bhote-koshi-nepal-scene').chapters[0]?.id ?? null;
await controller.openInGev();
assert.equal(store.mode, 'closed');
assert.equal(camera.views.length, 0, 'the globe stays where the story was');
assert.deepEqual(director.selected, [['bhote-koshi-nepal-scene', shotId]]);
assert.deepEqual(director.styleManager.panels, [['scene-panel', false]]);
controller.destroy();
});
const tick = (ms = 30) => new Promise((resolve) => setTimeout(resolve, ms));
test('Close while Back to Explore is landing steps back only the rest of the way', async (t) => {
const { controller } = setup();
const steps = recordGo(t);
controller.open();
controller.openStory('gev:flights-radar');
controller.backToExplore();
controller.close(); // before the Back has landed
assert.deepEqual(steps, [-1], 'Close waits for the Back to land');
// The Back lands on the Explore entry.
history.replaceState(
{ gevStories: { stories: 'explore', depth: 1, explore: 1 } },
'',
'/?stories=explore',
);
dispatchEvent(new PopStateEvent('popstate'));
await tick();
assert.deepEqual(steps, [-1, -1], 'two entries in all, as Stories pushed');
controller.destroy();
});
test('history steps back only after the scene has torn down', async (t) => {
const { controller, director } = setup();
const steps = recordGo(t);
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
const closing = controller.close();
await tick(60);
assert.deepEqual(steps, [], 'no traversal while the scene is stopping');
director.running = false;
await closing;
assert.deepEqual(steps, [-2]);
controller.destroy();
});
test('Back out of Stories after a scene puts the share state back directly', async () => {
const { controller, director } = setup();
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
// Back has already landed on the page Stories opened from.
await controller.close({ fromHistory: true });
assert.deepEqual(director.styleManager.shareLinkManager.restored, [
'v=2&lat=1',
]);
controller.destroy();
});
/** Land a recorded traversal: the page Stories opened from becomes current. */
function land(hash = '#v=2&lat=1') {
history.replaceState(null, '', `/?x=1${hash}`);
dispatchEvent(new PopStateEvent('popstate'));
}
test('a second browser Back during scene teardown supersedes the Stories restore', async () => {
const { controller, director, store, camera } = setup();
const share = director.styleManager.shareLinkManager;
const holds = [];
share.holdWrites = (held) => holds.push(held);
director.selection = () => ({ sceneId: 'previous', shotId: 'shot-1' });
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
land();
assert.equal(store.mode, 'closed');
land('#v=2&lat=2');
director.running = false;
await tick(0);
assert.equal(location.hash, '#v=2&lat=2');
assert.equal(camera.views.length, 0);
assert.deepEqual(share.restored, []);
assert.deepEqual(director.selected, []);
assert.deepEqual(holds, [true, false]);
assert.equal(document.body.classList.contains('stories-mode'), false);
controller.destroy();
});
test('Close after a GEV scene puts the share state back once the step back lands', async (t) => {
const { controller, director } = setup();
const steps = recordGo(t);
const restored = director.styleManager.shareLinkManager.restored;
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
await controller.close();
assert.deepEqual(steps, [-2]);
assert.deepEqual(restored, [], 'not before the landing');
assert.equal(document.body.classList.contains('stories-mode'), true);
land();
assert.deepEqual(restored, ['v=2&lat=1']);
assert.equal(document.body.classList.contains('stories-mode'), false);
controller.destroy();
});
test('Open in GEV steps back over Stories without putting the old view back', async (t) => {
const { controller, director, camera } = setup();
const steps = recordGo(t);
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
await controller.openInGev();
assert.deepEqual(steps, [-2], 'Back never reopens Stories');
land();
assert.deepEqual(director.styleManager.shareLinkManager.restored, []);
assert.equal(camera.views.length, 0);
controller.destroy();
});
test('a drag on the globe while a scene tears down keeps the camera where it went', async () => {
const { controller, director, camera, canvas } = setup();
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
const closing = controller.close();
canvas.dispatchEvent(new Event('pointerdown'));
director.running = false;
await closing;
assert.equal(camera.views.length, 0, 'no snap back');
controller.destroy();
});
test('a step back that never lands gives up and runs what was waiting', async (t) => {
const { controller, store } = setup();
recordGo(t);
controller.open();
controller.openStory('gev:flights-radar');
await controller.close(); // no popstate will come
controller.open(); // queued behind the traversal
assert.equal(store.mode, 'closed');
await new Promise((resolve) => setTimeout(resolve, 2200));
assert.equal(store.mode, 'explore', 'opened once the traversal gave up');
controller.destroy();
});
test('a reloaded Stories entry drops the share hash GEV wrote on boot', async () => {
setActivePinia(createPinia());
history.replaceState(
{ gevStories: { stories: 'explore', depth: 1, explore: 1 } },
'',
'/?stories=explore&selectedStory=gev%3Aorbital-watch#v=2&lat=7',
);
const store = useStoriesStore();
const controller = createStoriesController({
viewer: fakeScene().viewer,
director: fakeDirector(),
store,
});
store.connect(controller, listStories());
await new Promise((resolve) => setTimeout(resolve, 400));
assert.equal(store.mode, 'explore');
assert.equal(location.hash, '');
assert.equal(store.picked, 'gev:orbital-watch');
assert.equal(
location.search,
'?stories=explore&selectedStory=gev%3Aorbital-watch',
);
const exploreState = history.state;
const exploreUrl = location.href;
controller.openStory('gev:flights-radar');
assert.equal(location.search, '?story=gev%3Aflights-radar');
history.replaceState(exploreState, '', exploreUrl);
dispatchEvent(new PopStateEvent('popstate'));
assert.equal(store.mode, 'explore');
assert.equal(store.picked, 'gev:orbital-watch');
controller.destroy();
});
test('a scene saved to Stories from AUTHORING joins the list at once', () => {
setActivePinia(createPinia());
history.replaceState(null, '', '/');
const store = useStoriesStore();
const director = fakeDirector();
let listener = null;
let mine = [];
director.subscribe = (fn) => {
listener = fn;
return () => (listener = null);
};
director.storyScenes = () => mine;
const controller = createStoriesController({
viewer: fakeScene().viewer,
director,
store,
});
store.connect(controller, listStories());
assert.equal(store.byId('gev:my-scene'), null);
mine = [
{
id: 'my-scene',
title: 'Harbour at dawn',
camera: { lat: 51.5, lon: -0.1, alt: 2000, heading: 0, pitch: -30 },
shotCount: 2,
},
];
listener({ change: { type: 'stories-changed' } });
const story = store.byId('gev:my-scene');
assert.equal(story?.title, 'Harbour at dawn');
assert.equal(story.mine, true);
assert.equal(store.stories[0].id, 'gev:my-scene', 'the person’s own first');
mine = [];
listener({ change: { type: 'stories-changed' } });
assert.equal(store.byId('gev:my-scene'), null, 'removed from Stories');
controller.destroy();
assert.equal(listener, null, 'unsubscribed');
});
test('Back to Explore after a scene puts the look back once the scene has torn down, then frames Explore', async () => {
const { controller, director, camera } = setup();
history.replaceState(null, '', '/');
const flights = [];
camera.flyTo = (f) => flights.push(f);
camera.flyToBounds = (f) => flights.push(f);
const share = director.styleManager.shareLinkManager;
const original = 'v=2&lat=1&style=normal';
share.snapshotHash = () => original;
// GEV's restore writes the hash it applies; Explore's address drops it.
share.restore = function (hash) {
this.restored.push(hash);
history.replaceState(history.state, '', `${location.search}#${hash}`);
return true;
};
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
flights.length = 0;
history.replaceState(
{ gevStories: { stories: 'explore', depth: 1, explore: 1 } },
'',
'/?stories=explore',
);
dispatchEvent(new PopStateEvent('popstate'));
await tick(30);
assert.deepEqual(share.restored, [], 'not under the stopping scene');
assert.equal(flights.length, 0, 'Explore waits for the scene');
director.running = false;
await tick(40);
assert.deepEqual(share.restored, [original]);
assert.equal(location.hash, '', 'the address names only Stories');
assert.equal(flights.length, 1, 'then Explore frames the globe');
// A later Back to Explore with no scene in between restores nothing more.
controller.openStory('gev:bhote-koshi-nepal-scene');
controller.pause();
controller.backToExplore({ fromHistory: true });
await tick(40);
assert.equal(share.restored.length, 2, 'each scene is undone once');
controller.destroy();
});
test('a story opened while the scene tears down is not undone by the late restore', async () => {
const { controller, director } = setup();
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
director.running = true;
controller.backToExplore({ fromHistory: true });
controller.openStory('gev:flights-radar');
director.running = false;
await tick(40);
assert.deepEqual(director.styleManager.shareLinkManager.restored, []);
controller.destroy();
});
test('Explore tours from story to story once idle, stops on a pick or a touch, and on Close', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
const { controller, store, camera, canvas } = setup();
const flights = [];
camera.flyTo = (f) => flights.push(f);
camera.flyToBounds = (f) => flights.push(f);
controller.open();
assert.equal(flights.length, 1, 'the fly-in to the first story');
t.mock.timers.tick(7000);
assert.equal(flights.length, 1, 'a moment on the first story');
t.mock.timers.tick(1000);
assert.equal(flights.length, 2, 'then on to the next');
t.mock.timers.tick(8500);
assert.equal(flights.length, 3, 'and the next');
// A press holds the tour however long the drag lasts; letting go starts
// the wait again.
canvas.dispatchEvent(new Event('pointerdown'));
t.mock.timers.tick(20000);
assert.equal(flights.length, 3, 'nothing flies under a drag');
canvas.dispatchEvent(new Event('pointerup'));
t.mock.timers.tick(5000);
assert.equal(flights.length, 3);
t.mock.timers.tick(1500);
assert.equal(flights.length, 4);
// A picked story stops it.
controller.pick(store.stories[0].id);
const picked = flights.length;
t.mock.timers.tick(30000);
assert.equal(flights.length, picked);
// Unpicked, it tours again, for a minute at most.
controller.pick(null);
for (let i = 0; i < 24; i++) t.mock.timers.tick(5000);
const after = flights.length;
assert.ok(after > picked + 3, 'touring again');
for (let i = 0; i < 12; i++) t.mock.timers.tick(5000);
assert.equal(flights.length, after, 'stopped on its own');
controller.pick(null);
controller.destroy();
});
test('a new Explore link keeps the address free of the share hash GEV writes as Stories opens', async () => {
setActivePinia(createPinia());
history.replaceState(
null,
'',
'/?stories=explore&selectedStory=gev%3Aorbital-watch',
);
const store = useStoriesStore();
const director = fakeDirector();
const playbackCalls = [];
director.startScene = () => playbackCalls.push('start');
director.seekScene = () => playbackCalls.push('seek');
// Holding writes first writes the view change still waiting.
director.styleManager.shareLinkManager.holdWrites = (held) => {
if (held) history.replaceState(history.state, '', `${location.search}#v=2`);
};
const controller = createStoriesController({
viewer: fakeScene().viewer,
director,
store,
});
store.connect(controller, listStories());
await tick(400);
assert.equal(store.mode, 'explore');
assert.equal(location.hash, '');
assert.equal(
location.search,
'?stories=explore&selectedStory=gev%3Aorbital-watch',
);
assert.equal(store.picked, 'gev:orbital-watch');
assert.equal(store.storyId, null);
assert.deepEqual(playbackCalls, []);
controller.destroy();
});
test('a saved scene’s topics become Explore chips, and its captured card image is used', async () => {
const { metaFor, topicsOf } = await import('./storyMeta.js');
setActivePinia(createPinia());
history.replaceState(null, '', '/');
const store = useStoriesStore();
const director = fakeDirector();
director.subscribe = () => () => {};
director.storyScenes = () => [
{
id: 'harbour',
title: 'Harbour at dawn',
camera: { lat: 51.5, lon: -0.1, alt: 2000 },
shotCount: 1,
thumb: 'data:image/jpeg;base64,BBBB',
tags: ['Maritime', 'Floods'],
},
];
const controller = createStoriesController({
viewer: fakeScene().viewer,
director,
store,
});
store.connect(controller, listStories());
const story = store.byId('gev:harbour');
assert.deepEqual(metaFor(story).topics, ['Maritime', 'Floods']);
const chips = topicsOf(store.stories);
assert.ok(chips.includes('Maritime') && chips.includes('Floods'));
assert.ok(
chips.indexOf('Floods') < chips.indexOf('Maritime'),
'in AUTHORING’s tag order',
);
controller.open();
await tick(20);
assert.equal(store.thumbs['gev:harbour'], 'data:image/jpeg;base64,BBBB');
controller.destroy();
});
test('Close after a story puts AUTHORING’s own selection back; Open in GEV keeps the story’s', async () => {
const { controller, director } = setup();
director.selection = () => ({ sceneId: null, shotId: null });
controller.open();
controller.openStory('gev:flights-radar');
await controller.close({ fromHistory: true });
assert.deepEqual(director.selected.at(-1), [null, null], 'back to none');
director.selected.length = 0;
controller.open();
controller.openStory('gev:flights-radar');
await controller.openInGev();
assert.deepEqual(
director.selected.map(([sceneId]) => sceneId),
['flights-radar'],
'the story’s scene, nothing put back',
);
controller.destroy();
});
test('a built-in scene no longer in the project does not list; an unknown story link says so', async () => {
setActivePinia(createPinia());
history.replaceState(null, '', '/?story=gev%3Asomeone-elses');
const store = useStoriesStore();
const director = fakeDirector();
director.hasScene = (id) => id !== 'flights-radar';
const toasts = [];
store.flashToast = (text) => toasts.push(text);
const controller = createStoriesController({
viewer: fakeScene().viewer,
director,
store,
});
store.connect(controller, listStories());
assert.equal(store.byId('gev:flights-radar'), null);
assert.ok(store.byId('gev:orbital-watch'));
await tick(400);
assert.equal(store.mode, 'explore');
assert.equal(toasts.length, 1, 'the person is told');
controller.destroy();
assert.equal(document.body.classList.contains('stories-mode'), false);
});
test('Close after Back to Explore still puts AUTHORING’s selection back', async () => {
const { controller, director } = setup();
director.selection = () => ({ sceneId: null, shotId: null });
controller.open();
controller.openStory('gev:flights-radar');
controller.backToExplore({ fromHistory: true });
await tick(40);
await controller.close({ fromHistory: true });
assert.deepEqual(director.selected.at(-1), [null, null]);
controller.destroy();
});
test('unsaved scenes appear as local drafts and disappear when deleted', () => {
setActivePinia(createPinia());
history.replaceState(null, '', '/');
const store = useStoriesStore();
const director = fakeDirector();
const drafts = [
{
id: 'sketch',
title: 'Sketch',
camera: { lat: 1, lon: 2, alt: 3000 },
shotCount: 1,
thumb: '',
tags: [],
},
];
const channel = createStateChannel(() => ({ scenes: drafts }));
director.subscribe = channel.subscribe;
director.draftScenes = () => drafts;
const controller = createStoriesController({
viewer: fakeScene().viewer,
director,
store,
});
store.connect(controller, listStories());
const draft = store.byId('gev:sketch');
assert.equal(draft?.draft, true);
assert.equal(draft.mine, true, 'local only: no Share');
drafts.length = 0;
channel.publish({ type: 'scene-deleted' });
controller.open();
assert.equal(store.byId('gev:sketch'), null);
controller.destroy();
});
test('under imagery other than Esri, a card drawn from Esri earlier is dropped', async () => {
const { controller, director, store } = setup();
director.styleManager.mapStackController = { getActiveId: () => 'osm' };
store.thumbs = { 'gev:flights-radar': 'data:image/jpeg;base64,ESRI' };
controller.open();
await tick(20);
assert.equal(store.thumbs['gev:flights-radar'], undefined);
controller.destroy();
});
test('the tour waits again after a wheel turn or a cancelled press, and a list change during a drag does not restart it', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
const { controller, viewer, director, camera, canvas } = setup();
let listener = null;
director.subscribe = (fn) => ((listener = fn), () => {});
const flights = [];
camera.flyTo = (f) => flights.push(f);
camera.flyToBounds = (f) => flights.push(f);
controller.destroy();
const store = useStoriesStore();
const again = createStoriesController({ viewer, director, store });
store.connect(again, listStories());
again.open();
for (const type of ['wheel', 'pointercancel']) {
const before = flights.length;
canvas.dispatchEvent(new Event(type));
t.mock.timers.tick(5900);
assert.equal(flights.length, before, `${type}: waits`);
t.mock.timers.tick(200);
assert.equal(flights.length, before + 1, `${type}: then tours`);
}
canvas.dispatchEvent(new Event('pointerdown'));
listener({ change: { type: 'stories-changed' } });
const held = flights.length;
t.mock.timers.tick(30000);
assert.equal(flights.length, held, 'nothing flies under the drag');
again.destroy();
});
test('teardown mid-close releases share writes and cancels a queued reopen', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const { controller, director, store, camera } = setup();
recordGo(t);
const held = [];
director.styleManager.shareLinkManager.holdWrites = (on) => held.push(on);
let flights = 0;
camera.flyTo = () => flights++;
controller.open();
await controller.close();
controller.open(); // queued until the Close traversal lands
controller.destroy();
const before = flights;
assert.equal(held.at(-1), false);
t.mock.timers.tick(3000);
assert.equal(store.mode, 'closed');
assert.equal(held.at(-1), false, 'no late reopen holds writes again');
assert.equal(flights, before, 'no late flight after teardown');
});
test('place names name only a shipped scene’s untitled shots', () => {
const { controller, director, store } = setup();
director.listShots = () => [
{ id: 'a', title: 'Shot 1', startSec: 0, durationSec: 5 },
{ id: 'b', title: 'Over the harbour', startSec: 5, durationSec: 5 },
];
controller.openStory('gev:flights-radar');
const story = store.byId('gev:flights-radar');
assert.deepEqual(
story.chapters.map((c) => c.title),
['The Atlantic', 'Over the harbour'],
);
controller.destroy();
});
test('new navigation cancels a delayed initial story link', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
for (const action of ['back', 'open', 'close']) {
setActivePinia(createPinia());
history.replaceState(null, '', '/?story=gev%3Aflights-radar');
const store = useStoriesStore();
const controller = createStoriesController({
viewer: fakeScene().viewer,
director: fakeDirector(),
store,
});
store.connect(controller, listStories());
try {
if (action === 'back') land();
else if (action === 'open') controller.open();
else controller.close();
const url = location.href;
t.mock.timers.tick(400);
assert.equal(
store.mode,
action === 'open' ? 'explore' : 'closed',
action,
);
assert.equal(store.storyId, null, action);
assert.equal(
location.href,
url,
'the old link does not rewrite navigation',
);
} finally {
controller.destroy();
}
}
});
test('an earlier Back timeout cannot release a later traversal', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const { controller, store } = setup();
const steps = recordGo(t);
const landExplore = () => {
history.replaceState(
{ gevStories: { stories: 'explore', depth: 1, explore: 1 } },
'',
'/?stories=explore',
);
dispatchEvent(new PopStateEvent('popstate'));
};
try {
controller.open();
controller.openStory('gev:flights-radar');
controller.backToExplore();
landExplore();
t.mock.timers.tick(1500);
controller.openStory('gev:orbital-watch');
controller.backToExplore();
controller.close();
t.mock.timers.tick(600);
assert.equal(store.mode, 'story', 'Close still waits for the second Back');
assert.deepEqual(steps, [-1, -1]);
landExplore();
// Drain the director's already-idle promise without advancing timers.
for (let i = 0; i < 12; i++) await Promise.resolve();
assert.equal(store.mode, 'closed');
assert.deepEqual(
steps,
[-1, -1, -1],
'queued Close runs once after landing',
);
} finally {
controller.destroy();
}
});
test('Explore’s pins follow the camera on every frame drawn, moved in place', () => {
const { controller, store, frame, query } = setup();
controller.open();
assert.equal(frame.listeners.size, 1, 'one postRender listener');
frame.draw();
const pins = store.pins;
assert.equal(pins.length, store.stories.length);
assert.ok(pins.every((pin) => pin.visible));
// Vue renders the pins once; a move alone writes each pin's transform.
const layer = document.createElement('div');
layer.id = 'pins';
for (const pin of pins) {
const el = document.createElement('div');
el.className = 'pin';
el.dataset.id = pin.id;
layer.append(el);
}
document.body.append(layer);
try {
query.project = ({ x, y }) => ({ x: x / 1e5 + 40, y: y / 1e5 + 10 });
frame.draw();
assert.equal(store.pins, pins, 'the same pins: no Vue render');
const first = layer.querySelector(`.pin[data-id="${pins[0].id}"]`);
assert.match(first.style.transform, /^translate\(/);
// A pin going behind the horizon changes the set: Vue renders it.
let once = true;
query.isOccluded = () => {
const behind = once;
once = false;
return behind;
};
frame.draw();
assert.notEqual(store.pins, pins);
assert.equal(store.pins[0].visible, false);
} finally {
layer.remove();
controller.close();
}
assert.equal(frame.listeners.size, 0, 'no frame work once Stories closes');
controller.destroy();
});
test('Explore frames country level straight down, a picked story at −60°, and tiles settle for at most 10 s', (t) => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
const { controller, store, camera, frame, globe } = setup();
controller.open();
const open = camera.flights.at(-1);
assert.equal(open.destination.height, 2.5e6);
assert.deepEqual(open.orientation, {
heading: 0,
pitch: -Math.PI / 2,
roll: 0,
});
controller.pick(store.stories[0].id);
const picked = camera.flights.at(-1);
assert.equal(picked.sphere.radius, 0);
assert.equal(picked.offset.heading, 0);
assert.ok(Math.abs(picked.offset.pitch + Math.PI / 3) < 1e-12);
assert.ok(picked.offset.range >= 60000 && picked.offset.range <= 4e6);
// Landing keeps frames coming until the globe has settled...
picked.onComplete();
assert.equal(frame.listeners.size, 2, 'pins and settling');
frame.draw();
assert.equal(frame.listeners.size, 2, 'not settled yet');
globe.settled = true;
frame.draw();
assert.equal(frame.listeners.size, 1, 'settled: only the pins listen');
assert.ok(!holds().includes('stories-tiles'), 'settled: the hold is let go');
// ...and for 10 s at most.
globe.settled = false;
picked.onComplete();
assert.equal(frame.listeners.size, 2);
assert.ok(holds().includes('stories-tiles'), 'frames held while settling');
t.mock.timers.tick(10000);
assert.equal(frame.listeners.size, 1, 'given up after 10 s');
assert.ok(!holds().includes('stories-tiles'), 'given up: the hold is let go');
// Close lets go of a hold still waiting.
picked.onComplete();
assert.ok(holds().includes('stories-tiles'));
controller.destroy();
assert.ok(!holds().includes('stories-tiles'), 'closed: the hold is let go');
});
test('Close puts back the world clock the person had, and the camera readout follows a story', async () => {
const clock = fakeClock({
live: false,
playing: false,
timeMs: Date.UTC(2025, 5, 1),
});
const { controller, store, frame, camera } = setup({ clock });
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
frame.draw();
assert.deepEqual(store.camera, { lat: 28.65, lon: 11.46, altKm: 2000 });
// A scene moved the world clock.
clock.state = { ...clock.state, live: true, jumps: clock.state.jumps + 1 };
await controller.close();
assert.equal(camera.views.length, 1);
assert.deepEqual(clock.calls, [['pause'], ['seek', Date.UTC(2025, 5, 1)]]);
// A clock left where it was is not touched.
clock.calls.length = 0;
controller.open();
await controller.close();
assert.deepEqual(clock.calls, []);
controller.destroy();
});
test('Close puts a live clock back live, and a playing clock plays on from where it would be', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1_000_000 });
// Live: a scene seeked the clock; Close goes live again.
const live = fakeClock({ live: true });
const a = setup({ clock: live });
a.controller.open();
live.seek(Date.UTC(2020, 0, 1));
live.calls.length = 0;
const closingA = a.controller.close({ fromHistory: true });
t.mock.timers.tick(100);
await closingA;
assert.deepEqual(live.calls, [['goLive']]);
a.controller.destroy();
// Playing at 2×: paused by a scene; Close seeks to where it would be
// after the time Stories was open, and plays on at its rate.
const playing = fakeClock({
live: false,
playing: true,
rate: 2,
timeMs: Date.UTC(2025, 0, 1),
});
const b = setup({ clock: playing });
b.controller.open();
playing.pause();
playing.seek(Date.UTC(2019, 0, 1));
playing.calls.length = 0;
t.mock.timers.tick(5000);
const closingB = b.controller.close({ fromHistory: true });
t.mock.timers.tick(100);
await closingB;
const seek = playing.calls.find(([name]) => name === 'seek');
assert.ok(
Math.abs(seek[1] - (Date.UTC(2025, 0, 1) + 5100 * 2)) <= 200,
'extrapolated by the time away at its rate',
);
assert.deepEqual(playing.calls.at(-1), [
'play',
{ rate: 2, continuous: true },
]);
b.controller.destroy();
});
test('a playing clock nothing moved is left alone on Close, even if it fell behind', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1_000_000 });
const clock = fakeClock({
live: false,
playing: true,
rate: 1,
timeMs: Date.UTC(2025, 0, 1),
});
const { controller } = setup({ clock });
controller.open();
// Held by buffering: no jump, same mode and rate, but behind the wall.
t.mock.timers.tick(30000);
const closing = controller.close({ fromHistory: true });
t.mock.timers.tick(100);
await closing;
assert.deepEqual(clock.calls, []);
controller.destroy();
});
test('the clock comes back after the share state on Close, so a shared paused time does not stop a playing clock', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1_000_000 });
const clock = fakeClock({
live: false,
playing: true,
rate: 1,
timeMs: Date.UTC(2025, 0, 1),
});
const { controller, director } = setup({ clock });
// The share state arrives with its world time paused.
director.styleManager.shareLinkManager.restore = () => {
clock.pause();
clock.seek(Date.UTC(2025, 0, 1));
return true;
};
controller.open();
controller.openStory('gev:bhote-koshi-nepal-scene');
clock.pause();
const closing = controller.close({ fromHistory: true });
t.mock.timers.tick(100);
await closing;
assert.equal(clock.state.playing, true, 'playing again after the share');
controller.destroy();
});
test('Explore aims a story at the middle of the visible map, not of the canvas', () => {
const { controller, store, camera, canvas } = setup();
canvas.getBoundingClientRect = () => ({
left: 0,
top: 0,
width: 400,
height: 800,
});
// Explore's map is the top half of an 800 px canvas (a phone's sheet
// below it).
const root = document.createElement('div');
root.id = 'gev-stories';
const map = document.createElement('div');
map.className = 'ex-map';
root.append(map);
document.body.append(root);
map.getBoundingClientRect = () => ({
left: 0,
top: 0,
width: 400,
height: 400,
});
controller.open();
const story = store.stories[0];
controller.pick(null);
const flight = camera.flights.at(-1);
const { lat } = story.area ?? story.cover;
assert.ok(
flight.destination.lat < lat,
'aims south, so the story shows above the sheet',
);
root.remove();
controller.destroy();
});