mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
- A count click stands aside when an overlay label or another layer's card already took the click, and CCTV now claims a count click in the shared pick registry, so the flights layer no longer reads it as an empty-map click and keeps tracking its aircraft. - The flight to a group halves the distance only while the group stays in frame; otherwise it flies to the nearest ground cell of the group, so a tilted click no longer ends with no camera on screen. - Counts hidden under the HUD no longer push the active icon aside, and a lone camera that would move a merged count under the HUD leaves the original count and its icon as they were. - Cameras on one mount are spread before counts merge, so a spread icon no longer slides under a neighbouring count. - The ground module comment says how a camera without a batch height takes the drawn terrain.
281 lines
9.9 KiB
JavaScript
281 lines
9.9 KiB
JavaScript
/**
|
|
* Pick-ownership contract tests (pre-ship audit H2).
|
|
*
|
|
* Locks the cross-layer pick coercion rules:
|
|
* - resolvePickId reads a click's hit (the contract's `Hit`, or one with no
|
|
* set for something drawn outside the draw port) as ONE canonical String
|
|
* id: its item's id.
|
|
* - isOwnedByOtherLayer consults sibling predicates only, never the asker's,
|
|
* and never throws on a broken predicate.
|
|
*/
|
|
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
registerPickOwner,
|
|
unregisterPickOwner,
|
|
isOwnedByOtherLayer,
|
|
resolvePickId,
|
|
pickContact,
|
|
clickCard,
|
|
isUnderOtherCard,
|
|
setClickCardHitTest,
|
|
registerClickClaim,
|
|
unregisterClickClaim,
|
|
} from './pickRegistry.js';
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// resolvePickId — canonical String coercion for every layer's pick shape
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const item = (set, id) => ({ set, id, surface: false });
|
|
const SURFACE = { set: '', id: '', surface: true };
|
|
|
|
test("resolvePickId: a draw-set item's hit → its item id", () => {
|
|
assert.equal(resolvePickId(item('flights:1', 'aaa001')), 'aaa001');
|
|
assert.equal(resolvePickId(item('satellites:1:dots', '25544')), '25544');
|
|
});
|
|
|
|
test('resolvePickId: something drawn outside the draw port → its own id', () => {
|
|
assert.equal(resolvePickId(item('', 'transit:bus-1')), 'transit:bus-1');
|
|
assert.equal(resolvePickId(item('', null)), null, 'it has none');
|
|
assert.equal(resolvePickId(item('', '')), '', 'an empty id is still an id');
|
|
});
|
|
|
|
test('resolvePickId: the map and nothing → null', () => {
|
|
assert.equal(resolvePickId(null), null);
|
|
assert.equal(resolvePickId(undefined), null);
|
|
assert.equal(resolvePickId(SURFACE), null);
|
|
assert.equal(resolvePickId({ ...SURFACE, id: 'tile' }), null);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// isOwnedByOtherLayer — sibling-only scan over String-coerced ids
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test('ownership: sibling layers recognize each other via String-coerced ids', () => {
|
|
const points = new Map([[25544, {}], [43013, {}]]); // satellites: numeric keys
|
|
const vessels = new Map([['367123450', {}]]); // AIS: string id keys
|
|
registerPickOwner('satellites', (pickedId) => {
|
|
const norad = Number(pickedId);
|
|
return Number.isFinite(norad) && points.has(norad);
|
|
});
|
|
registerPickOwner('ais-live-vessels', (pickedId) => vessels.has(pickedId));
|
|
try {
|
|
// Flights asking about a satellite pick (raw numeric id → String upstream)
|
|
assert.equal(isOwnedByOtherLayer('flights', resolvePickId(item('sat:1', '25544'))), true);
|
|
// Flights asking about a vessel pick (an icon row id: the vessel's id)
|
|
assert.equal(isOwnedByOtherLayer('flights', resolvePickId(item('ais:1', '367123450'))), true);
|
|
// A layer never owns its own pick via the sibling scan
|
|
assert.equal(isOwnedByOtherLayer('satellites', '25544'), false);
|
|
// Unknown ids belong to nobody
|
|
assert.equal(isOwnedByOtherLayer('flights', 'zzz999'), false);
|
|
assert.equal(isOwnedByOtherLayer('flights', null), false);
|
|
} finally {
|
|
unregisterPickOwner('satellites');
|
|
unregisterPickOwner('ais-live-vessels');
|
|
}
|
|
});
|
|
|
|
test('ownership: a throwing predicate never breaks click handling', () => {
|
|
registerPickOwner('broken', () => { throw new Error('boom'); });
|
|
registerPickOwner('cctv', (pickedId) => pickedId === 'atx-cam-3');
|
|
try {
|
|
assert.equal(isOwnedByOtherLayer('flights', 'atx-cam-3'), true);
|
|
assert.equal(isOwnedByOtherLayer('flights', 'nothing'), false);
|
|
} finally {
|
|
unregisterPickOwner('broken');
|
|
unregisterPickOwner('cctv');
|
|
}
|
|
});
|
|
|
|
test('ownership: unregister removes the predicate', () => {
|
|
registerPickOwner('bikeshare', (pickedId) => pickedId === 'station:1');
|
|
assert.equal(isOwnedByOtherLayer('flights', 'station:1'), true);
|
|
unregisterPickOwner('bikeshare');
|
|
assert.equal(isOwnedByOtherLayer('flights', 'station:1'), false);
|
|
});
|
|
|
|
function primaryPointer(t, coarse) {
|
|
const previous = Object.getOwnPropertyDescriptor(globalThis, 'matchMedia');
|
|
Object.defineProperty(globalThis, 'matchMedia', {
|
|
configurable: true,
|
|
value: (query) => ({ matches: query === '(pointer: coarse)' && coarse }),
|
|
});
|
|
t.after(() => {
|
|
if (previous) Object.defineProperty(globalThis, 'matchMedia', previous);
|
|
else delete globalThis.matchMedia;
|
|
});
|
|
}
|
|
|
|
function contactOwners(t) {
|
|
registerPickOwner('flights', (id) => id === 'civil');
|
|
registerPickOwner('military', (id) => id === 'military');
|
|
registerPickOwner('ais-live-vessels', (id) => id === '123456789');
|
|
t.after(() => {
|
|
for (const id of ['flights', 'military', 'ais-live-vessels'])
|
|
unregisterPickOwner(id);
|
|
});
|
|
}
|
|
|
|
/** A query port double: one pick, and a drill that records its asks. */
|
|
function query(picked, drillPick = () => assert.fail('must not drill')) {
|
|
return {
|
|
pick: () => picked,
|
|
drillPick,
|
|
};
|
|
}
|
|
|
|
test('touch contact pick expands only a surface miss, bounded to 8 hits in 14 CSS pixels', (t) => {
|
|
primaryPointer(t, true);
|
|
contactOwners(t);
|
|
const position = { x: 30, y: 50 };
|
|
const contact = item('flights:1', 'civil');
|
|
let drills = 0;
|
|
const port = query(SURFACE, (...args) => {
|
|
drills++;
|
|
assert.deepEqual(args, [30, 50, { width: 14, height: 14, limit: 8 }]);
|
|
return [contact];
|
|
});
|
|
assert.equal(pickContact(port, position), contact);
|
|
assert.equal(drills, 1);
|
|
});
|
|
|
|
test("touch contact pick uses the click's own pick and drill", (t) => {
|
|
primaryPointer(t, true);
|
|
contactOwners(t);
|
|
const contact = item('flights:1', 'civil');
|
|
const asked = [];
|
|
const found = pickContact(query(null), { x: 1, y: 1 }, {
|
|
picked: null,
|
|
drill: (...args) => (asked.push(args), [contact]),
|
|
});
|
|
assert.equal(found, contact);
|
|
assert.deepEqual(asked, [[8, 14, 14]]);
|
|
});
|
|
|
|
test('touch contact pick returns the first registered sibling, never a caller-specific preference', (t) => {
|
|
primaryPointer(t, true);
|
|
contactOwners(t);
|
|
for (const first of [item('mil:1', 'military'), item('ais:1', '123456789')]) {
|
|
const port = query(SURFACE, () => [first, item('flights:1', 'civil')]);
|
|
assert.equal(pickContact(port, { x: 1, y: 1 }), first);
|
|
}
|
|
});
|
|
|
|
test('touch contact pick does not drill through exact registered or unregistered interactive picks', (t) => {
|
|
primaryPointer(t, true);
|
|
contactOwners(t);
|
|
for (const exact of [
|
|
item('mil:1', 'military'),
|
|
item('notes:1', 'custom-annotation'),
|
|
item('', 'custom-gizmo'),
|
|
])
|
|
assert.equal(pickContact(query(exact), { x: 1, y: 1 }), exact);
|
|
});
|
|
|
|
test('touch expansion stops at an unowned item and respects the drill bound', (t) => {
|
|
primaryPointer(t, true);
|
|
contactOwners(t);
|
|
for (const hits of [
|
|
[item('notes:1', 'custom-annotation'), item('flights:1', 'civil')],
|
|
[...Array(8).fill(item('notes:1', 'x')), item('flights:1', 'civil')],
|
|
[],
|
|
])
|
|
assert.equal(pickContact(query(SURFACE, () => hits), { x: 1, y: 1 }), SURFACE);
|
|
});
|
|
|
|
test('fine primary pointers keep the exact mouse pick without a drill', (t) => {
|
|
primaryPointer(t, false);
|
|
contactOwners(t);
|
|
assert.equal(pickContact(query(SURFACE), { x: 1, y: 1 }), SURFACE);
|
|
});
|
|
|
|
test('touch picking tolerates a failing drill and preserves empty sky', (t) => {
|
|
primaryPointer(t, true);
|
|
contactOwners(t);
|
|
for (const drillPick of [
|
|
() => {
|
|
throw new Error('context lost');
|
|
},
|
|
() => [],
|
|
])
|
|
assert.equal(pickContact(query(null, drillPick), { x: 1, y: 1 }), null);
|
|
});
|
|
|
|
test("the card on top is read once per click, and only another layer's card counts", () => {
|
|
let top = { sourceId: 'quake-card', entryId: 'q1' };
|
|
let reads = 0;
|
|
setClickCardHitTest((x, y) => {
|
|
reads++;
|
|
assert.deepEqual([x, y], [4, 5]);
|
|
return top;
|
|
});
|
|
try {
|
|
const click = { screenPosition: { x: 4, y: 5 } };
|
|
assert.equal(isUnderOtherCard(click, ['vessel-card']), true);
|
|
assert.equal(isUnderOtherCard(click, ['quake-card']), false, 'own card');
|
|
// A card published later in the same click does not change it.
|
|
top = { sourceId: 'vessel-card', entryId: 'v1' };
|
|
assert.equal(clickCard(click).sourceId, 'quake-card');
|
|
assert.equal(reads, 1);
|
|
assert.equal(isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), true);
|
|
top = null;
|
|
assert.equal(isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), false);
|
|
} finally {
|
|
setClickCardHitTest(null);
|
|
}
|
|
assert.equal(
|
|
isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }),
|
|
false,
|
|
'no host',
|
|
);
|
|
setClickCardHitTest(() => {
|
|
throw new Error('broken');
|
|
});
|
|
try {
|
|
assert.equal(clickCard({ screenPosition: { x: 1, y: 1 } }), null);
|
|
} finally {
|
|
setClickCardHitTest(null);
|
|
}
|
|
});
|
|
|
|
test('a click claim is the card on top only where no card or label is painted', () => {
|
|
const event = (x) => ({ screenPosition: { x, y: 5 } });
|
|
let calls = 0;
|
|
registerClickClaim('counts', (click) => {
|
|
calls++;
|
|
return click.screenPosition.x === 4
|
|
? { sourceId: 'counts', entryId: 'k' }
|
|
: null;
|
|
});
|
|
try {
|
|
registerClickClaim('counts', null);
|
|
const click = event(4);
|
|
assert.equal(isUnderOtherCard(click), true);
|
|
assert.equal(isUnderOtherCard(click, ['counts']), false);
|
|
assert.equal(calls, 1);
|
|
assert.equal(clickCard(event(9)), null);
|
|
const quake = { sourceId: 'quake-card', entryId: 'q1' };
|
|
setClickCardHitTest(() => quake);
|
|
assert.deepEqual(clickCard(event(4)), quake);
|
|
assert.equal(calls, 2);
|
|
setClickCardHitTest(() => {
|
|
throw new Error('broken overlay hit test');
|
|
});
|
|
assert.equal(clickCard(event(4)), null);
|
|
assert.equal(calls, 2);
|
|
setClickCardHitTest(null);
|
|
|
|
unregisterClickClaim('counts');
|
|
assert.equal(clickCard(event(4)), null);
|
|
registerClickClaim('counts', () => {
|
|
throw new Error('broken claim');
|
|
});
|
|
assert.equal(clickCard(event(4)), null);
|
|
} finally {
|
|
unregisterClickClaim('counts');
|
|
setClickCardHitTest(null);
|
|
}
|
|
});
|