mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
- src/app/layers/renderers.js: the layer renderer registry
(registerLayerRenderers(engineKind, { [layerId]: factory }),
rendererFor(layerId, engine), layerAvailableOn(layerId, engineKind)).
Every application layer is registered for Cesium as CESIUM_BUILTIN (it
still draws itself until its render/cesium.js); Navara factories come with
the layer tasks. On it, the stable availability API phase 4 injects into
its layer list: createLayerAvailability(engineKind) →
{ engine, isAvailable(id), available(), unavailable() } with { id, name }
rows (src/app/layers/directory.js holds the ids and names in catalog
order; a test keeps it equal to the constructed catalog).
- createApplicationCatalog({ engineKind, availability }) constructs only the
layers the engine can show, in the same order (shared instances made
once, on demand); the catalog carries `availability` and the others'
metadata (`unavailableMetadata`). Cesium builds the same 30 layers in the
same order as before; Navara builds none yet (no Navara renderers) - the
standalone app now asks the catalog for it instead of making an empty one.
- catalogControlServices: a role whose layer the engine leaves out gets an
empty stand-in (absentLayerControlServices folded in); any other missing
layer is still a wiring error.
- LayerLifecycle(viewer, { engine }): every module call (init, enable,
update, disable, destroy) gets { signal, engine } as its second argument;
viewer is null on Navara.
- Links: a link that turns on layers this engine leaves out keeps them in
the durable state (re-saved links carry them; back on Cesium they turn
on) and activates nothing; a notice names them ("NOT ON THIS ENGINE · Kept
in the link: …"). The Navara notice lists the engine's data layers from
the registry.
- The dev launcher's CCTV wiring check matches the new catalog form.
230 lines
7.0 KiB
JavaScript
230 lines
7.0 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
absentLayerControlServices,
|
|
createLayerCatalog,
|
|
catalogControlServices,
|
|
} from './catalog.js';
|
|
import { createApplicationData } from './data.js';
|
|
|
|
const metadata = (layers) =>
|
|
layers.map(({ id }) => ({ id, disposition: 'enabled-only' }));
|
|
|
|
test('catalog captures membership and metadata while preserving the supplied instances', () => {
|
|
const first = { id: 'first' };
|
|
const layers = [first];
|
|
const schema = metadata(layers);
|
|
const catalog = createLayerCatalog(layers, schema);
|
|
layers.push({ id: 'later' });
|
|
schema[0].disposition = 'invalid';
|
|
assert.deepEqual(catalog.layers, [first]);
|
|
assert.equal(catalog.get('first'), first);
|
|
assert.equal(catalog.get('later'), undefined);
|
|
assert.equal(catalog.metadata[0].disposition, 'enabled-only');
|
|
assert.throws(() => catalog.layers.push({ id: 'later' }), TypeError);
|
|
});
|
|
|
|
test('duplicate, missing and extra metadata fail before application registration', () => {
|
|
const layers = [{ id: 'first' }];
|
|
assert.throws(
|
|
() => createLayerCatalog([...layers, ...layers], metadata(layers)),
|
|
/duplicate/,
|
|
);
|
|
assert.throws(() => createLayerCatalog(layers, []), /incomplete/);
|
|
assert.throws(
|
|
() => createLayerCatalog(layers, metadata([{ id: 'other' }])),
|
|
/Unmatched/,
|
|
);
|
|
assert.throws(
|
|
() =>
|
|
createLayerCatalog(layers, [...metadata(layers), ...metadata(layers)]),
|
|
/duplicate/,
|
|
);
|
|
});
|
|
|
|
test('data setup seals the caller catalog before controls can restore and drains its exact instances', async (t) => {
|
|
const previous = globalThis.document;
|
|
globalThis.document = { getElementById: () => null };
|
|
t.after(() => {
|
|
if (previous === undefined) delete globalThis.document;
|
|
else globalThis.document = previous;
|
|
});
|
|
const attached = [];
|
|
const layers = [
|
|
{
|
|
id: 'one',
|
|
attachDataManager: (manager) => attached.push([...manager.layers.keys()]),
|
|
},
|
|
{ id: 'two' },
|
|
];
|
|
const releases = [];
|
|
let observed;
|
|
const { dataManager } = createApplicationData({
|
|
scene: { viewer: {} },
|
|
controls: {
|
|
styleManager: {
|
|
attachDataManager(manager) {
|
|
assert.equal(manager.registrationsFinalized, true);
|
|
assert.equal(manager.layers.get('one').module, layers[0]);
|
|
},
|
|
},
|
|
},
|
|
catalog: {
|
|
...createLayerCatalog(layers, metadata(layers)),
|
|
getSourceAvailability: (id) =>
|
|
id === 'one'
|
|
? {
|
|
available: false,
|
|
reason: 'One: data source not configured',
|
|
}
|
|
: undefined,
|
|
},
|
|
defer: (release) => releases.push(release),
|
|
onData: (manager) => {
|
|
observed = manager;
|
|
},
|
|
});
|
|
assert.equal(observed, dataManager);
|
|
assert.equal(await dataManager.setEnabled('one', true), false);
|
|
assert.equal(dataManager.layers.get('one').initialized, false);
|
|
assert.equal(
|
|
dataManager.getAll().find(({ id }) => id === 'one').stats.error,
|
|
'One: data source not configured',
|
|
);
|
|
assert.deepEqual(attached, [['one', 'two']]);
|
|
assert.deepEqual([...dataManager.layers.keys()], ['one', 'two']);
|
|
assert.throws(() => dataManager.register({ id: 'late' }), /finalized/);
|
|
for (const release of releases.reverse()) await release();
|
|
assert.equal(dataManager.layers.size, 0);
|
|
});
|
|
|
|
test('controls bind catalog instances rather than similarly named defaults', () => {
|
|
const ids = [
|
|
'traffic',
|
|
'flights',
|
|
'military',
|
|
'satellites',
|
|
'cctv',
|
|
'radio',
|
|
'bikeshare',
|
|
'transit',
|
|
'ais-live-vessels',
|
|
'military-awareness',
|
|
'military-installations',
|
|
'rocket-launches',
|
|
'street-level',
|
|
'local-adsb',
|
|
];
|
|
const layers = ids.map((id) => ({ id }));
|
|
const catalog = createLayerCatalog(layers, metadata(layers));
|
|
const services = catalogControlServices(catalog);
|
|
assert.equal(services.flightsLayer, layers[1]);
|
|
assert.equal(services.transitLayer, layers[7]);
|
|
assert.equal(services.aisLiveVesselsLayer, layers[8]);
|
|
assert.equal(services.localAdsbLayer, layers[13]);
|
|
assert.equal(new Set(Object.values(services)).size, layers.length);
|
|
assert.throws(
|
|
() => catalogControlServices(createLayerCatalog([], [])),
|
|
/Control layer missing/,
|
|
);
|
|
});
|
|
|
|
test('without data layers the controls get one empty stand-in per layer role', () => {
|
|
const ids = [
|
|
'traffic',
|
|
'flights',
|
|
'military',
|
|
'satellites',
|
|
'cctv',
|
|
'street-level',
|
|
'radio',
|
|
'bikeshare',
|
|
'transit',
|
|
'ais-live-vessels',
|
|
'military-awareness',
|
|
'military-installations',
|
|
'rocket-launches',
|
|
'local-adsb',
|
|
];
|
|
const layers = ids.map((id) => ({ id }));
|
|
const roles = Object.keys(
|
|
catalogControlServices(createLayerCatalog(layers, metadata(layers))),
|
|
);
|
|
const absent = absentLayerControlServices();
|
|
assert.deepEqual(Object.keys(absent), roles);
|
|
for (const role of roles) {
|
|
assert.deepEqual(Object.keys(absent[role]), [], role);
|
|
assert.equal(absent[role].subscribe, undefined);
|
|
}
|
|
assert.notEqual(absent.flightsLayer, absent.trafficLayer);
|
|
assert.notEqual(
|
|
absentLayerControlServices().flightsLayer,
|
|
absent.flightsLayer,
|
|
);
|
|
});
|
|
|
|
test('data setup without a viewer registers an empty catalog and no sonar scene', async (t) => {
|
|
const previous = globalThis.document;
|
|
globalThis.document = { getElementById: () => null };
|
|
t.after(() => {
|
|
if (previous === undefined) delete globalThis.document;
|
|
else globalThis.document = previous;
|
|
});
|
|
const releases = [];
|
|
let attached = null;
|
|
const { dataManager } = createApplicationData({
|
|
scene: { viewer: null, mapStackController: null },
|
|
controls: {
|
|
styleManager: {
|
|
attachDataManager(manager) {
|
|
attached = manager;
|
|
},
|
|
},
|
|
},
|
|
catalog: createLayerCatalog([], []),
|
|
defer: (release) => releases.push(release),
|
|
});
|
|
assert.equal(attached, dataManager);
|
|
assert.equal(dataManager.viewer, null);
|
|
assert.equal(dataManager.layers.size, 0);
|
|
assert.equal(dataManager.registrationsFinalized, true);
|
|
for (const release of releases.reverse()) await release();
|
|
});
|
|
|
|
test('a catalog for an engine gives stand-ins only for the layers it leaves out', () => {
|
|
const flights = { id: 'flights' };
|
|
const catalog = {
|
|
...createLayerCatalog(
|
|
[flights],
|
|
[{ id: 'flights', disposition: 'enabled-only' }],
|
|
),
|
|
unavailableMetadata: Object.keys({
|
|
traffic: 1,
|
|
military: 1,
|
|
satellites: 1,
|
|
cctv: 1,
|
|
'street-level': 1,
|
|
radio: 1,
|
|
bikeshare: 1,
|
|
transit: 1,
|
|
'ais-live-vessels': 1,
|
|
'military-awareness': 1,
|
|
'military-installations': 1,
|
|
'rocket-launches': 1,
|
|
'local-adsb': 1,
|
|
}).map((id) => ({ id })),
|
|
};
|
|
const services = catalogControlServices(catalog);
|
|
assert.equal(services.flightsLayer, flights);
|
|
assert.deepEqual(services.trafficLayer, {});
|
|
assert.notEqual(services.trafficLayer, services.militaryFlightsLayer);
|
|
const missing = {
|
|
...catalog,
|
|
unavailableMetadata: catalog.unavailableMetadata.slice(1),
|
|
};
|
|
assert.throws(
|
|
() => catalogControlServices(missing),
|
|
/Control layer missing from catalog: traffic/,
|
|
);
|
|
});
|