mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The launches layer's sites, markers, reticles, mission lines, live orbit rings and pad zone are now renderer draw sets. Picks go through the query port, double-click follow through the camera port (shared with other layers in src/data/stockFollow.js), and per-frame work through the frame port. rendering.js, orbitRendering.js and launchPad.js leave the Cesium list. The Cesium draw port gains what these need: pattern line styles, lines in the inertial frame turned each frame by the set's motion clock, radial-rim fills on clamped ellipses with a depth bias, and parking for hidden lines that cannot settle into a static batch, so a hidden line no longer costs a draw each frame. A roster writes each set once, and a followed live payload shares one position sample with its marker each frame.
247 lines
7.3 KiB
JavaScript
247 lines
7.3 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { readFileSync } from 'node:fs';
|
|
import { createInfrastructureLayers } from 'gods-eye-view/infrastructure';
|
|
import { createLocalGeoJsonLayer } from 'gods-eye-view/infrastructure/geojson';
|
|
import { fakeInput } from '../input/testDoubles.mjs';
|
|
import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs';
|
|
|
|
function services() {
|
|
const records = new Map();
|
|
const credited = [];
|
|
let selection;
|
|
return {
|
|
records,
|
|
credited,
|
|
showOsmCredit: (viewer) => credited.push(viewer),
|
|
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
|
registerEntityContext(entity, metadata) {
|
|
records.set(metadata.id, { entity, ...metadata });
|
|
},
|
|
selectEntityContext(entity) {
|
|
selection = entity;
|
|
},
|
|
clearSelectedEntityContextForLayer() {
|
|
selection = undefined;
|
|
},
|
|
removeEntityContextsForLayer(id) {
|
|
for (const [key, record] of records)
|
|
if (record.layerId === id) records.delete(key);
|
|
},
|
|
governorRequestRender() {},
|
|
selection: () => selection,
|
|
};
|
|
}
|
|
|
|
test('package exports import without an application, DOM, fetch, or timers', () => {
|
|
const result = spawnSync(
|
|
process.execPath,
|
|
[
|
|
'--input-type=module',
|
|
'-e',
|
|
`
|
|
globalThis.fetch = () => { throw new Error('unexpected fetch'); };
|
|
globalThis.setTimeout = () => { throw new Error('unexpected timer'); };
|
|
for (const key of ['window', 'document']) {
|
|
delete globalThis[key];
|
|
}
|
|
await import('gods-eye-view/infrastructure');
|
|
await import('gods-eye-view/infrastructure/geojson');
|
|
await import('gods-eye-view/infrastructure/lod');
|
|
`,
|
|
],
|
|
{ cwd: new URL('../..', import.meta.url), encoding: 'utf8' },
|
|
);
|
|
assert.equal(result.status, 0, result.stderr);
|
|
});
|
|
|
|
test('infrastructure factory preserves identity and creates independent state without loading', (t) => {
|
|
t.mock.method(globalThis, 'fetch', () => {
|
|
throw new Error('factory must not fetch');
|
|
});
|
|
const first = createInfrastructureLayers(services());
|
|
const second = createInfrastructureLayers(services());
|
|
assert.deepEqual(
|
|
first.map(({ id, name, source }) => ({ id, name, source })),
|
|
[
|
|
{ id: 'local-datacenters', name: 'Datacenters', source: 'Local' },
|
|
{ id: 'local-dams', name: 'Dams', source: 'USACE' },
|
|
],
|
|
);
|
|
first.forEach((layer, index) => {
|
|
assert.notEqual(layer, second[index]);
|
|
layer.destroy();
|
|
assert.deepEqual(second[index].getStats(), {
|
|
count: 0,
|
|
lastUpdate: null,
|
|
error: null,
|
|
});
|
|
second[index].destroy();
|
|
});
|
|
});
|
|
|
|
test('dataset URLs still name the complete bundled sources', () => {
|
|
for (const [file, count] of [
|
|
['datacenters', 4351],
|
|
['dams', 704],
|
|
]) {
|
|
const lines = readFileSync(
|
|
new URL(`./local_data/${file}/${file}.geojsonl`, import.meta.url),
|
|
'utf8',
|
|
)
|
|
.split('\n')
|
|
.filter((line) => line.trim());
|
|
assert.equal(lines.length, count);
|
|
}
|
|
});
|
|
|
|
test('two viewers use their supplied contexts and dispose independently', async (t) => {
|
|
t.mock.method(globalThis, 'fetch', async () => ({
|
|
ok: true,
|
|
text: async () =>
|
|
JSON.stringify({
|
|
type: 'Feature',
|
|
id: 'same-id',
|
|
properties: { name: 'Dam' },
|
|
geometry: {
|
|
type: 'Polygon',
|
|
coordinates: [
|
|
[
|
|
[0, 0],
|
|
[0.01, 0],
|
|
[0, 0.01],
|
|
[0, 0],
|
|
],
|
|
],
|
|
},
|
|
}),
|
|
}));
|
|
const hosts = [services(), services()];
|
|
const instances = hosts.map((host) => {
|
|
const layer = createLocalGeoJsonLayer(
|
|
{
|
|
id: 'local-dams',
|
|
name: 'Dams',
|
|
osmDerived: true,
|
|
color: '#0088ff',
|
|
url: '/dams.geojsonl',
|
|
},
|
|
host,
|
|
);
|
|
// A click picks the feature's stem, as the renderer's pick names it.
|
|
const viewer = {
|
|
scene: {
|
|
screenSpaceCameraController: { enableInputs: true },
|
|
pick: () => {
|
|
const [stem] = fake.set('stems').items.values();
|
|
return {
|
|
id: {
|
|
set: fake.set('stems').spec.id,
|
|
id: stem.id,
|
|
meta: stem.meta,
|
|
},
|
|
};
|
|
},
|
|
},
|
|
};
|
|
const fake = bindFakeGroundRenderer(viewer);
|
|
const input = fakeInput(viewer);
|
|
return { layer, viewer, fake, click: () => input.click({ x: 0, y: 0 }) };
|
|
});
|
|
t.after(() =>
|
|
instances.forEach(({ layer, viewer }) => layer.destroy(viewer)),
|
|
);
|
|
await Promise.all(instances.map(({ layer, viewer }) => layer.enable(viewer)));
|
|
assert.equal(hosts[0].records.size, 1);
|
|
assert.deepEqual(
|
|
hosts.map((host) => host.credited),
|
|
instances.map(({ viewer }) => [viewer]),
|
|
);
|
|
assert.equal(hosts[1].records.size, 1);
|
|
instances[0].click();
|
|
assert.ok(hosts[0].selection());
|
|
assert.equal(hosts[1].selection(), undefined);
|
|
assert.deepEqual(
|
|
instances[0].fake.flights.map(({ destination }) => destination.height),
|
|
[5000],
|
|
'the click flies to the feature',
|
|
);
|
|
instances[0].layer.destroy(instances[0].viewer);
|
|
assert.equal(hosts[0].records.size, 0);
|
|
assert.equal(hosts[1].records.size, 1);
|
|
assert.equal(instances[0].fake.liveSets().length, 0);
|
|
assert.equal(instances[1].fake.liveSets().length, 6);
|
|
});
|
|
|
|
test('consumer build includes only infrastructure code and resolves assets under a non-root base', async () => {
|
|
const { build } = await import('vite');
|
|
const { fileURLToPath } = await import('node:url');
|
|
const result = await build({
|
|
configFile: false,
|
|
logLevel: 'silent',
|
|
base: '/example/',
|
|
build: {
|
|
write: false,
|
|
assetsInlineLimit: 0,
|
|
rollupOptions: {
|
|
input: fileURLToPath(
|
|
import.meta.resolve('gods-eye-view/infrastructure'),
|
|
),
|
|
external: ['cesium'],
|
|
preserveEntrySignatures: 'strict',
|
|
},
|
|
},
|
|
});
|
|
const output = result.output;
|
|
const entry = output.find((item) => item.type === 'chunk' && item.isEntry);
|
|
const sources = Object.keys(entry.modules).filter((id) => id.endsWith('.js'));
|
|
// It draws through the renderer's ports: a viewer of the caller's own
|
|
// draws once the caller has loaded `./render/cesium/unbound`.
|
|
assert.deepEqual(sources.map((id) => id.split('/').at(-1)).sort(), [
|
|
'cameraControls.js',
|
|
'cameraInput.js',
|
|
'color.js',
|
|
'ctrlWheelZoom.js',
|
|
'dispatcher.js',
|
|
'drawHit.js',
|
|
'ellipsoid.js',
|
|
'follow.js',
|
|
'frames.js',
|
|
'geojsonPins.js',
|
|
'heights.js',
|
|
'infrastructure.js',
|
|
'infrastructureData.js',
|
|
'infrastructureOverlayEntry.js',
|
|
'input.js',
|
|
'inputOwnership.js',
|
|
'localGeojsonCore.js',
|
|
'localGeojsonLod.js',
|
|
'pickRegistry.js',
|
|
'rendererOf.js',
|
|
'rhumb.js',
|
|
'router.js',
|
|
'scenePick.js',
|
|
'sensorPick.js',
|
|
'sphere.js',
|
|
'stockFollow.js',
|
|
'styleStages.js',
|
|
'vector.js',
|
|
]);
|
|
assert.deepEqual(
|
|
entry.imports,
|
|
['cesium'],
|
|
'the viewer supplies the same Cesium dependency',
|
|
);
|
|
for (const name of ['datacenters', 'dams']) {
|
|
const asset = output.find(
|
|
(item) => item.type === 'asset' && item.fileName.includes(name),
|
|
);
|
|
assert.ok(asset, `${name} must be emitted`);
|
|
assert.ok(
|
|
entry.code.includes(`/example/${asset.fileName}`),
|
|
`${name} must retain the consumer base path`,
|
|
);
|
|
}
|
|
});
|