From 94ea9cd01d2488de7bacfa4c83db2d2e9bb354ce Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 14 Nov 2026 01:24:24 -0800 Subject: [PATCH] fix(submarine-cables): a double-click follows a landing point or reference and zooms to a cable again The cables, landing points and references were entities, which the default renderer's double-click followed (a point, or a reference at its tip) or zoomed to (a cable or area) until the sources were replaced or hidden. As draw-port items they took no part in it. --- .../telegeographySubmarineCables.test.mjs | 45 +++++++++++++++++++ src/layers/submarineCables/interaction.js | 10 +++++ src/layers/submarineCables/lifecycle.js | 2 + src/layers/submarineCables/rendering.js | 32 +++++++++++++ src/layers/submarineCables/state.js | 3 ++ 5 files changed, 92 insertions(+) diff --git a/src/data/telegeographySubmarineCables.test.mjs b/src/data/telegeographySubmarineCables.test.mjs index 6715db879..05684170e 100644 --- a/src/data/telegeographySubmarineCables.test.mjs +++ b/src/data/telegeographySubmarineCables.test.mjs @@ -564,6 +564,8 @@ function createCableHarness({ // event-dirty behavior with no wall-clock coupling. let clockMs = 0; let clickHandler = null; + let doubleHandler = null; + let picked = null; const layer = createTeleGeographySubmarineCableLayer({ overlayHost: { setVisible: (...args) => hostCalls.push(['visible', ...args]), @@ -577,6 +579,14 @@ function createCableHarness({ if (clickHandler === fn) clickHandler = null; }; }, + onPointer: (type, fn) => { + if (type !== 'dblclick') return () => {}; + doubleHandler = fn; + return () => { + if (doubleHandler === fn) doubleHandler = null; + }; + }, + stockEnabled: (name) => name === 'dblclickFollow', }), source, mapStackEventTarget, @@ -607,8 +617,13 @@ function createCableHarness({ camera.port.cancelFlight = () => flights.push('cancel'); camera.port.flyTo = (destination, options) => flights.push({ destination, options }); + camera.port.followed = null; + camera.port.follow = (target) => (camera.port.followed = target ?? null); + const zooms = []; + camera.port.flyToBounds = (sphere) => zooms.push(sphere); const { draw } = bindFakeDraw(viewer, { camera: camera.port, + query: { pick: () => picked }, frame: fakeSceneFrame(viewer), }); layer.init(viewer); @@ -637,6 +652,13 @@ function createCableHarness({ click(drawHit) { clickHandler?.({ drawHit, pick: null }); }, + /** A double-click over a drawn item; what the camera then does. */ + dblclick(hit) { + picked = hit; + doubleHandler?.({ position: { x: 1, y: 1 } }); + }, + followed: () => camera.port.followed, + zooms, async load() { layer.enable(viewer); source.releaseAll?.(); @@ -1340,3 +1362,26 @@ test('every bundled cable segment is drawn with its source feature', async () => assert.equal(env.set('references').items.size, features.length); env.layer.destroy(); }); + +test('a double-click follows a landing point or reference and zooms to a cable, as their entities did', async () => { + const env = await loadedHarness(); + const [lineId] = env.set('lines').items.keys(); + const [pinId] = env.set('pins').items.keys(); + const [cableRef] = env.set('references').items.keys(); + const surface = { surface: false }; + env.dblclick({ set: env.set('pins').spec.id, id: pinId, ...surface }); + assert.ok(env.followed(), 'a landing point is followed'); + env.dblclick({ set: env.set('stems').spec.id, id: cableRef, ...surface }); + assert.equal( + env.followed().key, + `${env.set('references').spec.id}:${cableRef}`, + 'a stem follows its reference, one entity before', + ); + env.dblclick({ set: env.set('lines').spec.id, id: lineId, ...surface }); + assert.equal(env.followed(), null, 'a cable is zoomed to'); + assert.ok(env.zooms.at(-1)?.radius > 0); + env.dblclick({ set: env.set('pins').spec.id, id: pinId, ...surface }); + env.layer.disable(); + assert.equal(env.followed(), null, 'hidden, its entities went: no follow'); + env.layer.destroy(); +}); diff --git a/src/layers/submarineCables/interaction.js b/src/layers/submarineCables/interaction.js index de7470da2..2f1e27eb5 100644 --- a/src/layers/submarineCables/interaction.js +++ b/src/layers/submarineCables/interaction.js @@ -1,5 +1,6 @@ import { toRadians } from '../../geo/vector.js'; import { cameraOf } from '../../render/rendererOf.js'; +import { followOnDoubleClick } from '../../data/stockFollow.js'; export function createInteraction({ state, parts, inputFor }) { function beginInteraction(viewer) { @@ -10,6 +11,15 @@ export function createInteraction({ state, parts, inputFor }) { if (!record?.reference) return; flyToReference(viewer, record.reference); }); + // A double-click follows a landing point or reference and zooms to a + // cable, as the default renderer did for their entities. + state._stockFollow = followOnDoubleClick({ + viewer, + inputFor, + name: 'submarine-cables', + enabled: () => state._enabled, + targetFor: (hit) => parts.rendering.followTargetFor(hit), + }); } /** diff --git a/src/layers/submarineCables/lifecycle.js b/src/layers/submarineCables/lifecycle.js index cb69607a6..e2348cd9c 100644 --- a/src/layers/submarineCables/lifecycle.js +++ b/src/layers/submarineCables/lifecycle.js @@ -109,6 +109,8 @@ export function createLifecycle({ state, parts, source, mapStackEventTarget }) { state._overlayPublisher.hide(); state._clickSubscription?.(); state._clickSubscription = null; + state._stockFollow?.destroy(); + state._stockFollow = null; if (state._preRenderRemover) { state._preRenderRemover(); state._preRenderRemover = null; diff --git a/src/layers/submarineCables/rendering.js b/src/layers/submarineCables/rendering.js index 0462d5026..efbe314dc 100644 --- a/src/layers/submarineCables/rendering.js +++ b/src/layers/submarineCables/rendering.js @@ -4,6 +4,7 @@ import { densifyRhumb } from '../../geo/rhumb.js'; import { distance, toRadians } from '../../geo/vector.js'; import { cssColor } from '../../render/color.js'; import { cameraOf, canvasOf, drawOf } from '../../render/rendererOf.js'; +import { drawnItemTarget } from '../../data/stockFollow.js'; import { clampLabel, createCableOverlayEntry, @@ -180,6 +181,9 @@ export function createRendering({ state }) { state._publishScratch.length = 0; state._loaded = false; state._referenceSweepGate.reset(); + // The sources' entities went with them, and so did a follow of one. + state._stockFollow?.stop(); + state._drawnItems = new Map(); if (!state._sets) return; if (clearSets) for (const set of Object.values(state._sets)) set.clear(); for (const picks of state._picks.values()) picks.clear(); @@ -395,6 +399,18 @@ export function createRendering({ state }) { map.clear(); for (const [id, info] of picks) map.set(id, info); } + // Drawn anew, as new sources' entities were: a follow of one ends. + state._stockFollow?.stop(); + state._drawnItems = new Map([ + [sets.lines.id, new Map(out.lines.map((item) => [item.id, item]))], + [sets.fills.id, new Map(out.fills.map((item) => [item.id, item]))], + [sets.pins.id, new Map(out.pins.map((item) => [item.id, item]))], + // A reference's stem and point were one entity, placed at the tip. + ...[sets.stems.id, sets.references.id].map((id) => [ + id, + new Map(out.references.map((record) => [record.id, record.point])), + ]), + ]); sets.lines.set(out.lines); sets.fills.set(out.fills); sets.pins.set(out.pins); @@ -402,6 +418,21 @@ export function createRendering({ state }) { sets.references.set(out.references.map((record) => record.point)); } + /** + * What a double-click on a hit follows or zooms to, as the default + * renderer did for the entity it was: a landing point or a reference is + * followed, a cable or area zoomed to. + */ + function followTargetFor(hit) { + if (!hit || hit.surface || !state._setIds.has(hit.set)) return null; + const item = state._drawnItems?.get(hit.set)?.get(hit.id); + if (!item) return null; + // A reference's stem and point follow as one. + const set = + hit.set === state._sets?.stems.id ? state._sets.references.id : hit.set; + return drawnItemTarget(set, item); + } + /** What a pick on one of the layer's sets names, or null. */ function pickInfo(hit) { if (!hit || !state._setIds.has(hit.set)) return null; @@ -502,6 +533,7 @@ export function createRendering({ state }) { applyCableClassification, drawFeatures, pickInfo, + followTargetFor, updateReferenceVisibility, }; } diff --git a/src/layers/submarineCables/state.js b/src/layers/submarineCables/state.js index 65bcac27d..4cd8804f8 100644 --- a/src/layers/submarineCables/state.js +++ b/src/layers/submarineCables/state.js @@ -62,6 +62,9 @@ export function createState({ sweepClock, overlayHost }) { state._referenceRecords = []; state._clickSubscription = null; + /** The follow a double-click started, and each set's drawn items by id. */ + state._stockFollow = null; + state._drawnItems = new Map(); state._preRenderRemover = null;