fix(picking): settle which layers act on a click when it resolves

The flights and military layers treat the aircraft they already track as
a passive pick, but they start tracking during the click itself. A card
handler running later in the same click then saw the plane as passive and
acted too: a quake card opened its source while the plane started
tracking, and fire, CCTV and vessel cards could do the same.

The pick registry now records the acting owners of a click's exact hit and
touch contact when the dispatcher first resolves them, and the quake,
FIRMS, CCTV, vessel and Context checks read that record for the rest of
the click. Calls without a click keep the live lookup.
This commit is contained in:
manjunath22466 committed 2026-11-17 15:51:14 +05:30
1 parent 830c980ca6
commit 54fd3d3bed
13 files changed
+239 -48

No files matched your search

+44 -1
View File
@@ -1012,7 +1012,12 @@ function makeCesiumEvent() {
};
}
function installWireHarness(picked, stateOverrides = {}, sceneExtras = {}) {
function installWireHarness(
picked,
stateOverrides = {},
sceneExtras = {},
firstClick = null,
) {
const hadWindow = Object.hasOwn(globalThis, 'window');
const hadDocument = Object.hasOwn(globalThis, 'document');
const priorWindow = globalThis.window;
@@ -1041,6 +1046,8 @@ function installWireHarness(picked, stateOverrides = {}, sceneExtras = {}) {
scene: { pick: () => picked, ...sceneExtras },
};
const input = fakeInput(viewer);
// A subscriber that runs before the layer's own (an aircraft layer).
if (firstClick) input.input.onClick(firstClick);
// The camera port other layers follow through, with no pose to read; its
// followChanged event counts who listens.
const followChanged = makeCesiumEvent();
@@ -1993,6 +2000,42 @@ test('vessel interaction wire: a sibling-owned pick wins without selection mutat
}
});
// The aircraft layer runs first and starts tracking the plane under the
// vessel's card, making it passive. The card reads the owners that acted
// when the click resolved, so it still yields: one action.
test('vessel interaction wire: a card yields to an aircraft that starts tracking in the same click', (t) => {
let tracked = null;
registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', {
expanded: true,
passive: (pickedId) => pickedId === tracked,
});
t.after(() => unregisterPickOwner('test-planes'));
const harness = installWireHarness(
{ id: 'plane:9' },
{ selectedRecord: null },
{},
(event) => {
if (event.hit?.id === 'plane:9') tracked = 'plane:9';
},
);
const requests = [];
harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) =>
requests.push(event.detail),
);
_setVesselOverlayHostForTest(
hostWithCardHit(`vessel:${harness.record.mmsi}`),
);
try {
harness.handler.click({ position: { x: 10, y: 20 } });
assert.equal(tracked, 'plane:9', 'the aircraft starts tracking');
assert.equal(requests.length, 0, 'the vessel card yields');
assert.equal(aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, null);
} finally {
_setVesselOverlayHostForTest(null);
harness.cleanup();
}
});
// A trail acts for nobody: the vessel's card painted over it still selects,
// and a bare trail pick stays a no-op that keeps the selection.
test('vessel interaction wire: a card over a trail selects; a bare trail is a no-op', () => {
+32
View File
@@ -64,6 +64,7 @@ function harness({
withGlobe = false,
feed = null,
drilled = null,
firstClick = null,
} = {}) {
const hadWindow = Object.hasOwn(globalThis, 'window');
const priorWindow = globalThis.window;
@@ -137,6 +138,8 @@ function harness({
if (!withGlobe)
layer.attachShellServices({ imageryHost: () => ({ kind: 'none' }) });
const input = fakeInput(viewer);
// A subscriber that runs before the layer's own (an aircraft layer).
if (firstClick) input.input.onClick(firstClick);
// The LOD rebuild (and with it the context-registration sweep) is inert
// without a data source, so tests that drive a real refresh need one.
if (withDataSource) layer.init(viewer);
@@ -576,6 +579,35 @@ test('a fire card keeps a tap whose contact does not act; bare taps still clear'
}
});
// The aircraft layer runs first and starts tracking the plane it was clicked
// on, which makes that plane passive. The fire card painted over it reads
// the owners that acted when the click resolved, so it still yields.
test('a fire card yields to an aircraft that starts tracking in the same click', (t) => {
const fire = makeFire();
let tracked = null;
registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', {
expanded: true,
passive: (pickedId) => pickedId === tracked,
});
t.after(() => unregisterPickOwner('test-planes'));
const h = harness({
fires: [fire],
picked: { id: 'plane:9' },
cardHit: `fire:${fireDetectionKey(fire)}`,
firstClick: (event) => {
if (event.hit?.id === 'plane:9') tracked = 'plane:9';
},
});
try {
h.click();
assert.equal(tracked, 'plane:9', 'the aircraft starts tracking');
assert.equal(h.requests.length, 0, 'the fire card yields');
assert.equal(h.layer.getSelectedInfo(), null);
} finally {
h.cleanup();
}
});
test('a stale card id resolves to nothing instead of an arbitrary fire', () => {
const h = harness({
picked: { primitive: {}, content: {}, featureId: 0 },
+41 -14
View File
@@ -35,6 +35,8 @@ const _owners = new Map();
const _passive = new Map();
/** Owners whose click handlers also select nearby contacts. */
const _expanded = new Set();
/** @type {WeakMap<object, Map<string, [string, boolean][]>>} */
const clickActions = new WeakMap();
/**
* Layers whose shapes are background to any card painted over them: their
* click handlers stand aside under a card, so the card's layer may act there.
@@ -130,33 +132,58 @@ export function isOwnedByOtherLayer(layerId, pickedId) {
return false;
}
/** @param {string} pickedId @returns {Generator<[string, boolean]>} */
function* actingPickOwners(pickedId) {
for (const [ownerId, predicate] of _owners) {
try {
if (!predicate(pickedId)) continue;
const passive = _passive.get(ownerId);
if (passive === true) continue;
if (typeof passive === 'function' && passive(pickedId)) continue;
yield [ownerId, _expanded.has(ownerId)];
} catch {
// a broken predicate must never break click handling
}
}
}
/**
* Hold the acting owners as soon as a click resolves a hit. A handler can
* start tracking the hit and make it passive before later handlers run.
* @param {object} click The shared dispatcher event.
* @param {import('../render/contract/query').Hit|null} hit The resolved hit.
*/
export function rememberClickPickActions(click, hit) {
const pickedId = resolvePickId(hit);
if (!pickedId) return;
let actions = clickActions.get(click);
if (!actions) clickActions.set(click, (actions = new Map()));
if (!actions.has(pickedId)) {
actions.set(pickedId, [...actingPickOwners(pickedId)]);
}
}
/**
* True when some OTHER registered layer owns the picked id and acts on a
* click on it: {@link isOwnedByOtherLayer} without passive owners. A card
* painted over a passive pick (a flight trail) is still the card's click.
* @param {string} layerId - The asking layer's id (excluded from the scan).
* @param {string} pickedId - Picked primitive/entity id.
* @param {{expanded?: boolean}} [options] A nearby rather than exact hit:
* only owners whose handlers select nearby contacts take precedence.
* @param {{expanded?: boolean, click?: object}} [options] For a nearby hit,
* only expanded owners take precedence. Pass the shared click to use the
* acting owners from when it first resolved this hit.
* @returns {boolean}
*/
export function isActedOnByOtherLayer(
layerId,
pickedId,
{ expanded = false } = {},
{ expanded = false, click } = {},
) {
if (!pickedId) return false;
for (const [ownerId, predicate] of _owners) {
if (ownerId === layerId || (expanded && !_expanded.has(ownerId))) continue;
try {
if (!predicate(pickedId)) continue;
const passive = _passive.get(ownerId);
if (passive === true) continue;
if (typeof passive === 'function' && passive(pickedId)) continue;
return true;
} catch {
// a broken predicate must never break click handling
}
const owners =
clickActions.get(click)?.get(pickedId) ?? actingPickOwners(pickedId);
for (const [ownerId, selectsNearby] of owners) {
if (ownerId !== layerId && (!expanded || selectsNearby)) return true;
}
return false;
}
+1 -1
View File
@@ -147,5 +147,5 @@ export function cardKeepsClick(click, underCard) {
const pickId = resolvePickId(click.hit);
if (!pickId) return false;
const expanded = pickId !== resolvePickId(click.topHit ?? null);
return !isActedOnByOtherLayer('', pickId, { expanded });
return !isActedOnByOtherLayer('', pickId, { expanded, click });
}
+21 -1
View File
@@ -11,7 +11,7 @@ globalThis.CustomEvent ||= class CustomEvent {
globalThis.dispatchEvent ||= () => true;
const { registerEntityContext } = await import('./contextStore.js');
const { registerPickOwner, unregisterPickOwner, findPickOwner } = await import('./pickRegistry.js');
const { registerPickOwner, unregisterPickOwner, findPickOwner, rememberClickPickActions } = await import('./pickRegistry.js');
const { resolvePickedContext, pickedKindForLayer, cardKeepsClick } = await import('./pickedContext.js');
function manager({ enabled = new Set(['flights', 'local-datacenters']), modules = {} } = {}) {
@@ -147,3 +147,23 @@ test('a card keeps a click from items whose layer does not act on that hit', (t)
);
assert.equal(cardKeepsClick({ topHit: null, hit: null }, true), false);
});
// An aircraft layer can start tracking the plane it was clicked on before
// Context runs, making that plane passive. Context reads the owners that
// acted when the click resolved, so the card over it does not keep the click.
test('a card keeps a click by the owners that acted when it resolved', (t) => {
let tracked = null;
registerPickOwner('test-planes', (id) => id === 'plane:9', {
expanded: true,
passive: (id) => id === tracked,
});
t.after(() => unregisterPickOwner('test-planes'));
const plane = { set: 'planes:1', id: 'plane:9' };
const click = { topHit: plane, hit: plane };
rememberClickPickActions(click, plane);
tracked = 'plane:9';
assert.equal(cardKeepsClick(click, true), false, 'the aircraft acted');
// A click that resolves now sees the tracked plane as passive.
const later = { topHit: { ...plane }, hit: { ...plane } };
assert.equal(cardKeepsClick(later, true), true);
});