Files
gods-eye-view/src/data/pickedContext.js
T
Sameh Khamis 805c9b5ccd fix(voice): point-and-ask over a Street Level coverage line names its sequence again
The coverage lines were one primitive per sequence, picked as the
sequence's id. Drawn in parts, a part after the first carries its own
#n id, which point-and-ask passed on. A hit whose item names the id its
parts pick as (meta.pick) resolves as that id, as the line's click
already does.
2026-11-14 01:47:20 -08:00

126 lines
4.1 KiB
JavaScript

import { getContextStore, isContextRecordActive } from './contextStore.js';
import { readEntityRecord } from './entityRecords.js';
import { findPickOwner, resolvePickId } from './pickRegistry.js';
/**
* Resolve a pick (the contract's `Hit`, as `pickAt` in
* src/input/dispatcher.js gives it) to the identity a person would name:
* which layer, which record, and its display label.
*
* Two lanes, in order:
* 1. Context-store carriers. Layers drawing through the draw port
* (infrastructure GeoJSON, ALPR) write a `contextId` into a draw item's
* `meta`; the store record already carries the label and position voice
* uses everywhere else.
* 2. Pick owners. Layers (aircraft, satellites, vessels) register an
* ownership predicate in `pickRegistry`; the owning layer's
* `findByQuery` turns the pick id into a live descriptor.
*
* Trails claim their pick ids only to make clicks inert, so they never
* resolve. Disabled layers never resolve: what the user cannot see is not
* what they are pointing at.
*/
const KIND_BY_LAYER = Object.freeze({
flights: 'aircraft',
military: 'aircraft',
'local-adsb': 'aircraft',
'ais-live-vessels': 'vessel',
satellites: 'satellite',
'local-firms': 'fire',
});
const IGNORED_OWNERS = new Set(['trails']);
function text(value) {
return String(value ?? '').trim();
}
function finite(value) {
if (value === null || value === undefined || value === '') return null;
const number = Number(value);
return Number.isFinite(number) ? number : null;
}
/** Kind of thing a layer holds, for deixis ("this aircraft", "this place"). */
export function pickedKindForLayer(layerId) {
return KIND_BY_LAYER[layerId] || 'feature';
}
function contextCarrierRecord(hit, dataManager) {
const contextId = readEntityRecord(hit?.meta)?.contextId;
if (!contextId) return null;
const record = getContextStore().entities.get(contextId);
return record && isContextRecordActive(record, dataManager) ? record : null;
}
function fromRecord(record) {
const layerId = record.layerId || null;
const id =
layerId === 'ais-live-vessels' && record.properties?.vesselId
? String(record.properties.vesselId)
: String(record.id);
return {
layerId,
id,
label:
text(record.label) ||
text(record.properties?.name) ||
text(record.layerName) ||
id,
kind: pickedKindForLayer(layerId),
lat: finite(record.latitude),
lon: finite(record.longitude),
};
}
function descriptorLabel(found, fallback) {
return (
text(found?.callsign) ||
text(found?.registration) ||
text(found?.name) ||
text(found?.icao24) ||
text(found?.mmsi) ||
text(found?.noradId) ||
fallback
);
}
/**
* @param {import('../render/contract/query').Hit|null} picked
* @param {object} [options]
* @param {object} [options.dataManager] Layer lifecycle (enabled state, modules).
* @returns {{layerId: string, id: string, label: string, kind: string, lat: number|null, lon: number|null, altitudeM?: number|null}|null}
*/
export function resolvePickedContext(picked, { dataManager = null } = {}) {
if (!picked || picked.surface) return null;
const record = contextCarrierRecord(picked, dataManager);
if (record) return fromRecord(record);
// An item drawn in parts names the id its parts pick as (`meta.pick`:
// a Street Level sequence), as the one primitive they were picked as.
const pickId =
(typeof picked.meta?.pick === 'string' && picked.meta.pick) ||
resolvePickId(picked);
if (!pickId) return null;
const layerId = findPickOwner(pickId);
if (!layerId || IGNORED_OWNERS.has(layerId)) return null;
if (dataManager?.isEnabled && !dataManager.isEnabled(layerId)) return null;
const layer = dataManager?.layers?.get?.(layerId);
let found = null;
try {
found = layer?.module?.findByQuery?.(pickId) || null;
} catch {
found = null;
}
return {
layerId,
id: pickId,
label: descriptorLabel(found, text(layer?.name) || pickId),
kind: pickedKindForLayer(layerId),
lat: finite(found?.latitude),
lon: finite(found?.longitude),
altitudeM: finite(found?.altitudeM),
};
}