mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
From review: - Card lines the actions write in English (area basis, part counts, merged duplicates, OSM caveats, the imagery window) are shown in the UI language through the analyst card's note path; the model still gets the English. One OSM place reads "1 hospital". - Same-named clarification choices show their region code (WA, DC). - OSM Places shows as unavailable once the server says no Overpass is configured, and its points are depth-tested past 2.5 km so they never show through the globe. - find_imagery puts the operator's sources and mode back when a box is refused, and a voice search cancelled mid-flight leaves "Search cancelled" instead of an empty strip. - The README lists OSM Places with the other Utilities.
533 lines
15 KiB
JavaScript
533 lines
15 KiB
JavaScript
// find_imagery over the Recent Imagery layer: which acquisition is chosen,
|
|
// that it is shown through the layer's own pin, and the honest refusals.
|
|
//
|
|
// Run with: npm test
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
findImagery,
|
|
imageryDateRange,
|
|
selectImagery,
|
|
} from './imageryActions.js';
|
|
import { createAreaStore } from '../data/areaStore.js';
|
|
|
|
const NOW = Date.parse('2026-09-23T12:00:00Z');
|
|
|
|
const hls = (day, cloud, extra = {}) => ({
|
|
key: `S30:${day}`,
|
|
product: 'S30',
|
|
day,
|
|
granules: [{ cloud, timeStart: `${day}T17:00:00Z` }],
|
|
cloud: { min: cloud, max: cloud },
|
|
timeRange: { start: `${day}T17:00:00Z`, end: `${day}T17:05:00Z` },
|
|
availability: 'present',
|
|
coverage: 'full',
|
|
...extra,
|
|
});
|
|
|
|
const CANDIDATES = [
|
|
hls('2026-09-21', 80),
|
|
hls('2026-09-18', 12),
|
|
hls('2026-09-10', 3),
|
|
hls('2026-09-05', 0, { availability: 'empty' }),
|
|
];
|
|
|
|
/** A stand-in for the layer: the same method names and snapshot fields. */
|
|
function fakeLayer({
|
|
candidates = CANDIDATES,
|
|
refuse = null,
|
|
error = null,
|
|
} = {}) {
|
|
let snapshot = {
|
|
searching: false,
|
|
candidates: [],
|
|
box: null,
|
|
boxError: null,
|
|
error: null,
|
|
pins: { a: { key: null } },
|
|
shown: { a: null },
|
|
notes: [],
|
|
sources: { hls: false, viirs: true },
|
|
mode: 'basemap',
|
|
};
|
|
const listeners = new Set();
|
|
const calls = [];
|
|
let searchTimer = null;
|
|
const set = (patch) => {
|
|
snapshot = { ...snapshot, ...patch };
|
|
for (const l of listeners) l(snapshot);
|
|
};
|
|
const search = (box) => {
|
|
set({ box, searching: true, candidates: [] });
|
|
searchTimer = setTimeout(
|
|
() => set({ searching: false, candidates, error }),
|
|
5,
|
|
);
|
|
return true;
|
|
};
|
|
return {
|
|
calls,
|
|
setBox(box) {
|
|
calls.push(['setBox', box]);
|
|
if (refuse) {
|
|
set({ boxError: refuse });
|
|
return false;
|
|
}
|
|
return search(box);
|
|
},
|
|
useCurrentView() {
|
|
calls.push(['useCurrentView']);
|
|
if (refuse) {
|
|
set({ boxError: refuse });
|
|
return false;
|
|
}
|
|
return search({ west: 0, south: 0, east: 1, north: 1 });
|
|
},
|
|
boxFromPinAt(lon, lat) {
|
|
calls.push(['boxFromPinAt', lon, lat]);
|
|
return search({
|
|
west: lon - 0.05,
|
|
south: lat - 0.05,
|
|
east: lon + 0.05,
|
|
north: lat + 0.05,
|
|
});
|
|
},
|
|
setSources(sources) {
|
|
calls.push(['setSources', sources]);
|
|
set({ sources: { ...sources } });
|
|
},
|
|
setMode(mode) {
|
|
calls.push(['setMode', mode]);
|
|
set({ mode });
|
|
},
|
|
setAssignment(slot, key) {
|
|
calls.push(['setAssignment', slot, key]);
|
|
set({ pins: { a: { key, label: `${key} label` } } });
|
|
setTimeout(() => set({ shown: { a: key } }), 5);
|
|
return true;
|
|
},
|
|
cancelPendingSearch() {
|
|
calls.push(['cancelPendingSearch']);
|
|
clearTimeout(searchTimer);
|
|
searchTimer = null;
|
|
set({ searching: false });
|
|
},
|
|
getSnapshot: () => snapshot,
|
|
subscribe(listener) {
|
|
listeners.add(listener);
|
|
return () => listeners.delete(listener);
|
|
},
|
|
};
|
|
}
|
|
|
|
function deps(layer, { enabled = true, area = null } = {}) {
|
|
const toggles = [];
|
|
return {
|
|
toggles,
|
|
value: {
|
|
dataManager: {
|
|
layers: new Map([['recent-imagery', { module: layer }]]),
|
|
isEnabled: () => enabled,
|
|
},
|
|
viewer: {},
|
|
getArea: (id) => (area && id === area.areaId ? area : null),
|
|
enableLayer: async (on) => {
|
|
toggles.push(on);
|
|
return { ok: true };
|
|
},
|
|
now: () => NOW,
|
|
},
|
|
};
|
|
}
|
|
|
|
test('the newest clear acquisition is chosen and pinned through the layer', async () => {
|
|
const layer = fakeLayer();
|
|
const { value } = deps(layer);
|
|
const result = await findImagery(value, {});
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.count, 3, 'the confirmed-empty day is not a match');
|
|
assert.deepEqual(result.shown, {
|
|
date: '2026-09-18',
|
|
source: 'Sentinel-2',
|
|
resolutionM: 30,
|
|
cloudPct: 12,
|
|
onMap: true,
|
|
});
|
|
assert.equal(result.say, 'Sentinel-2 from 2026-09-18, 12% cloud');
|
|
assert.deepEqual(
|
|
layer.calls.map((c) => c[0]),
|
|
['setSources', 'setMode', 'useCurrentView', 'setAssignment'],
|
|
);
|
|
assert.deepEqual(layer.calls.at(-1), [
|
|
'setAssignment',
|
|
'a',
|
|
'S30:2026-09-18',
|
|
]);
|
|
});
|
|
|
|
test('filters on cloud and dates narrow the choice', async () => {
|
|
const cloudFree = await findImagery(deps(fakeLayer()).value, {
|
|
maxCloudPct: 5,
|
|
});
|
|
assert.equal(cloudFree.shown.date, '2026-09-10');
|
|
assert.equal(cloudFree.count, 1);
|
|
const lastWeek = await findImagery(deps(fakeLayer()).value, {
|
|
dateRange: { days: 7 },
|
|
});
|
|
assert.equal(lastWeek.shown.date, '2026-09-18');
|
|
const none = await findImagery(deps(fakeLayer()).value, {
|
|
dateRange: { from: '2026-09-22', to: '2026-09-23' },
|
|
});
|
|
assert.equal(none.ok, true);
|
|
assert.equal(none.count, 0);
|
|
assert.equal(none.shown, null);
|
|
assert.match(none.say, /last 30 days/);
|
|
});
|
|
|
|
test('an area handle searches its bounding box; the view and pointer have their own boxes', async () => {
|
|
const area = {
|
|
areaId: 'osm:r1',
|
|
name: 'Bagamati Province',
|
|
bbox: [83.9, 26.9, 86.6, 28.4],
|
|
};
|
|
const layer = fakeLayer();
|
|
const result = await findImagery(deps(layer, { area }).value, {
|
|
areaId: 'osm:r1',
|
|
});
|
|
assert.equal(result.area, 'Bagamati Province');
|
|
assert.deepEqual(layer.calls.find((c) => c[0] === 'setBox')[1], {
|
|
west: 83.9,
|
|
south: 26.9,
|
|
east: 86.6,
|
|
north: 28.4,
|
|
});
|
|
const tiny = fakeLayer();
|
|
await findImagery(
|
|
deps(tiny, {
|
|
area: {
|
|
areaId: 'a',
|
|
name: 'Ferry Building',
|
|
bbox: [-122.396, 37.793, -122.391, 37.798],
|
|
},
|
|
}).value,
|
|
{ areaId: 'a' },
|
|
);
|
|
assert.equal(
|
|
tiny.calls.find((c) => c[0] === 'boxFromPinAt')[0],
|
|
'boxFromPinAt',
|
|
'a landmark gets a 10 km box',
|
|
);
|
|
const pinned = fakeLayer();
|
|
// The runner resolves 'pointer' to the turn snapshot's point (deixis).
|
|
await findImagery(deps(pinned).value, {
|
|
center: { lat: 27.7, lon: 85.3 },
|
|
});
|
|
assert.deepEqual(
|
|
pinned.calls.find((c) => c[0] === 'boxFromPinAt'),
|
|
['boxFromPinAt', 85.3, 27.7],
|
|
);
|
|
const noPointer = await findImagery(deps(fakeLayer()).value, {
|
|
area: 'pointer',
|
|
});
|
|
assert.equal(noPointer.code, 'NO_POINTER');
|
|
const unknown = await findImagery(deps(fakeLayer()).value, {
|
|
areaId: 'osm:r9',
|
|
});
|
|
assert.equal(unknown.code, 'AREA_UNKNOWN');
|
|
});
|
|
|
|
test('a mixed antimeridian area gets the deliberate imagery date-line refusal', async () => {
|
|
const square = (w, s, e, n) => [
|
|
[w, s],
|
|
[e, s],
|
|
[e, n],
|
|
[w, n],
|
|
[w, s],
|
|
];
|
|
const crossing = [
|
|
[178, 0],
|
|
[-178, 0],
|
|
[-178, 1],
|
|
[178, 1],
|
|
[178, 0],
|
|
];
|
|
const store = createAreaStore();
|
|
const area = store.put({
|
|
geometry: [[crossing], [square(-176, 0.2, -174, 0.8)]],
|
|
name: 'Dateline Islands',
|
|
source: 'osm',
|
|
});
|
|
assert.deepEqual(area.bbox, [178, 0, -174, 1]);
|
|
const result = await findImagery(deps(fakeLayer(), { area }).value, {
|
|
areaId: area.areaId,
|
|
});
|
|
assert.equal(result.ok, false);
|
|
assert.equal(result.code, 'DATELINE');
|
|
});
|
|
|
|
test('a box the layer refuses is refused with its reason, and the layer is turned on first', async () => {
|
|
const layer = fakeLayer({ refuse: 'Box is 1,200 km wide · limit 1,000 km' });
|
|
const { value, toggles } = deps(layer, { enabled: false });
|
|
const result = await findImagery(value, {});
|
|
assert.equal(result.ok, false);
|
|
assert.equal(result.code, 'BOX_REFUSED');
|
|
assert.match(result.error, /limit 1,000 km/);
|
|
assert.deepEqual(toggles, [true]);
|
|
});
|
|
|
|
test('a refused box leaves the operator panel sources and mode as they were', async () => {
|
|
const layer = fakeLayer({ refuse: 'Box is 1,200 km wide · limit 1,000 km' });
|
|
const result = await findImagery(deps(layer).value, {});
|
|
assert.equal(result.code, 'BOX_REFUSED');
|
|
const snap = layer.getSnapshot();
|
|
assert.deepEqual(snap.sources, { hls: false, viirs: true });
|
|
assert.equal(snap.mode, 'basemap');
|
|
});
|
|
|
|
test('a superseded search is cancelled before anything is pinned', async () => {
|
|
const layer = fakeLayer();
|
|
let current = true;
|
|
const pending = findImagery(
|
|
deps(layer).value,
|
|
{},
|
|
{ isCurrent: () => current },
|
|
);
|
|
current = false;
|
|
const result = await pending;
|
|
assert.equal(result.code, 'CANCELLED');
|
|
assert.equal(
|
|
layer.calls.some((c) => c[0] === 'setAssignment'),
|
|
false,
|
|
);
|
|
});
|
|
|
|
test('an already-aborted search does not change the imagery panel', async () => {
|
|
const layer = fakeLayer();
|
|
const controller = new AbortController();
|
|
controller.abort();
|
|
const result = await findImagery(
|
|
deps(layer).value,
|
|
{},
|
|
{ signal: controller.signal },
|
|
);
|
|
assert.equal(result.code, 'CANCELLED');
|
|
assert.equal(result.cancelled, true);
|
|
assert.deepEqual(layer.calls, []);
|
|
});
|
|
|
|
test('caller abort stops the owned catalog search before a late render', async () => {
|
|
const layer = fakeLayer();
|
|
const controller = new AbortController();
|
|
const pending = findImagery(
|
|
deps(layer).value,
|
|
{},
|
|
{
|
|
signal: controller.signal,
|
|
isCurrent: () => !controller.signal.aborted,
|
|
},
|
|
);
|
|
controller.abort();
|
|
const result = await pending;
|
|
assert.equal(result.code, 'CANCELLED');
|
|
assert.equal(
|
|
layer.calls.some((call) => call[0] === 'cancelPendingSearch'),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
layer.calls.some((call) => call[0] === 'setAssignment'),
|
|
false,
|
|
);
|
|
});
|
|
|
|
test('a catalog failure is not reported as "no imagery"', async () => {
|
|
const result = await findImagery(
|
|
deps(fakeLayer({ candidates: [], error: 'HLS S30 catalog unavailable' }))
|
|
.value,
|
|
{},
|
|
);
|
|
assert.equal(result.code, 'CATALOG_UNAVAILABLE');
|
|
});
|
|
|
|
test('date ranges and selection helpers', () => {
|
|
assert.deepEqual(imageryDateRange({ days: 7 }, NOW), {
|
|
from: NOW - 7 * 86_400_000,
|
|
to: NOW,
|
|
});
|
|
assert.equal(
|
|
imageryDateRange({ from: 'yesterday' }, NOW).error !== undefined,
|
|
true,
|
|
);
|
|
const to = imageryDateRange({ to: '2026-09-10' }, NOW).to;
|
|
assert.equal(new Date(to).toISOString(), '2026-09-10T23:59:59.999Z');
|
|
const { best } = selectImagery(CANDIDATES, { maxCloudPct: 20 });
|
|
assert.equal(best.day, '2026-09-18');
|
|
});
|
|
|
|
// ── Review regressions: the real layer, and the operator taking it back ──
|
|
|
|
import { createRecentImageryLayer } from '../layers/recentImagery/index.js';
|
|
import {
|
|
candidate,
|
|
fakeCatalog,
|
|
fakeRenderer,
|
|
fakeThumbnails,
|
|
} from '../layers/recentImagery/testDoubles.mjs';
|
|
|
|
const AREA_BOX = { west: 85.2, south: 27.6, east: 85.4, north: 27.8 };
|
|
const OTHER_BOX = { west: -97.8, south: 30.2, east: -97.7, north: 30.3 };
|
|
|
|
function realLayer() {
|
|
const catalog = fakeCatalog();
|
|
const thumbnails = fakeThumbnails();
|
|
const layer = createRecentImageryLayer({
|
|
catalog,
|
|
renderer: fakeRenderer(),
|
|
thumbnails,
|
|
host: () => ({ collection: {}, kind: 'globe' }),
|
|
now: () => new Date('2026-09-23T12:00:00Z'),
|
|
});
|
|
layer.init({ camera: {} });
|
|
layer.enable();
|
|
return { layer, catalog, thumbnails };
|
|
}
|
|
|
|
function realDeps(layer) {
|
|
return {
|
|
dataManager: {
|
|
layers: new Map([['recent-imagery', { module: layer }]]),
|
|
isEnabled: () => true,
|
|
},
|
|
viewer: {},
|
|
getArea: () => ({
|
|
areaId: 'osm:r1',
|
|
name: 'Kathmandu',
|
|
bbox: [AREA_BOX.west, AREA_BOX.south, AREA_BOX.east, AREA_BOX.north],
|
|
}),
|
|
enableLayer: async () => ({ ok: true }),
|
|
};
|
|
}
|
|
|
|
function ownedVisibilityDeps(layer) {
|
|
let enabled = true;
|
|
const requestListeners = new Set();
|
|
const settledListeners = new Set();
|
|
const dataManager = {
|
|
layers: new Map([['recent-imagery', { module: layer }]]),
|
|
isEnabled: () => enabled,
|
|
getLayerLifecycleState: () => ({
|
|
enabled,
|
|
lifecycleState: enabled ? 'enabled' : 'disabled',
|
|
uncertain: false,
|
|
}),
|
|
subscribeVisibilityRequests(listener) {
|
|
requestListeners.add(listener);
|
|
return () => requestListeners.delete(listener);
|
|
},
|
|
subscribe(listener) {
|
|
settledListeners.add(listener);
|
|
return () => settledListeners.delete(listener);
|
|
},
|
|
};
|
|
return {
|
|
...realDeps(layer),
|
|
dataManager,
|
|
requestOff({ settle = true } = {}) {
|
|
const change = {
|
|
type: 'visibility-requested',
|
|
layerId: 'recent-imagery',
|
|
enabled: false,
|
|
origin: 'user',
|
|
};
|
|
for (const listener of requestListeners) listener(change);
|
|
if (settle) {
|
|
enabled = false;
|
|
layer.disable();
|
|
for (const listener of settledListeners)
|
|
listener({ ...change, type: 'visibility-changed' });
|
|
}
|
|
},
|
|
activeVisibilityListeners: () =>
|
|
requestListeners.size + settledListeners.size,
|
|
};
|
|
}
|
|
|
|
const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
|
|
test('a box changed by hand mid-search is left alone, not pinned under the old name', async () => {
|
|
const { layer, catalog } = realLayer();
|
|
const pending = findImagery(realDeps(layer), { areaId: 'osm:r1' });
|
|
await tick();
|
|
assert.equal(catalog.searches.length, 1, 'searching the area box');
|
|
layer.setBox(OTHER_BOX); // the operator picks another box
|
|
catalog.resolveLast([candidate('S30', '2026-09-18', 3)]);
|
|
const result = await pending;
|
|
assert.equal(result.ok, false);
|
|
assert.equal(result.code, 'DISPLACED');
|
|
assert.equal(result.cancelled, true);
|
|
assert.equal(
|
|
layer.getSnapshot().pins.a.key,
|
|
null,
|
|
'nothing pinned on their box',
|
|
);
|
|
});
|
|
|
|
test('a pin replaced by hand while it loads is not narrated as still loading', async () => {
|
|
const { layer, catalog } = realLayer();
|
|
const slow = {
|
|
...candidate('S30', '2026-09-18', 3),
|
|
availability: 'unknown',
|
|
};
|
|
const other = candidate('L30', '2026-09-16', 5);
|
|
const pending = findImagery(realDeps(layer), { areaId: 'osm:r1' });
|
|
await tick();
|
|
catalog.resolveLast([slow, other]);
|
|
await tick();
|
|
await tick();
|
|
assert.equal(
|
|
layer.getSnapshot().pins.a.key,
|
|
slow.key,
|
|
'voice pinned its choice',
|
|
);
|
|
layer.setAssignment('a', other.key); // the operator shows another day
|
|
const result = await pending;
|
|
assert.equal(result.code, 'DISPLACED');
|
|
assert.equal(layer.getSnapshot().pins.a.key, other.key, 'their pin stays');
|
|
});
|
|
|
|
test('with nobody touching the panel the real layer shows the chosen day', async () => {
|
|
const { layer, catalog } = realLayer();
|
|
const pending = findImagery(realDeps(layer), { areaId: 'osm:r1' });
|
|
await tick();
|
|
catalog.resolveLast([
|
|
candidate('S30', '2026-09-18', 3),
|
|
candidate('L30', '2026-09-10', 60),
|
|
]);
|
|
const result = await pending;
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.shown.date, '2026-09-18');
|
|
assert.equal(result.shown.onMap, true);
|
|
assert.equal(layer.getSnapshot().shown.a, 'S30:2026-09-18');
|
|
});
|
|
|
|
test('manual OFF owns a pending imagery search before its fake catalog completes', async () => {
|
|
const { layer, catalog } = realLayer();
|
|
const deps = ownedVisibilityDeps(layer);
|
|
const pending = findImagery(deps, { areaId: 'osm:r1' });
|
|
await tick();
|
|
assert.equal(catalog.searches.length, 1);
|
|
deps.requestOff({ settle: false });
|
|
catalog.resolveLast([candidate('S30', '2026-09-18', 3)]);
|
|
const result = await pending;
|
|
assert.equal(result.ok, false);
|
|
assert.equal(result.code, 'DISPLACED');
|
|
assert.equal(result.cancelled, true);
|
|
assert.equal(result.requestedEnabled, false);
|
|
assert.equal(
|
|
layer.getSnapshot().pins.a.key,
|
|
null,
|
|
'late result is not pinned',
|
|
);
|
|
assert.equal(result.say, undefined, 'no success narration is published');
|
|
assert.equal(deps.activeVisibilityListeners(), 0, 'ownership watchers stop');
|
|
});
|