@defra/interactive-map 0.0.43-alpha → 0.0.44-alpha

package/plugins/draw/src/adapters/openlayers/draw/vertexPlacement.js

@@ -84,7 +84,14 @@ const tryClose = ({ drawInteraction, canFinish, geom, sketchCoords, coord, lastP
  *
  * @returns {{ placeVertex, updateRubberbanding, clearLastCoord }}
  */
-export const createVertexPlacement = ({ drawInteraction, mapProvider, snap, canFinish, canPlace, getInterfaceType }) => {
+// Both snappedCenter and updateRubberbanding are only ever reached via the crosshair path
+// (Enter, the add-vertex button, or the crosshair's own click) — never a real mouse click,
+// which goes through OL's own Draw interaction and its separate snap interaction instead.
+// So there's no interfaceType to gate on here: whenever these run, the target is by
+// definition the crosshair, and snap (when available) should always apply. Callers decide
+// *when* to call updateRubberbanding at all (see draw/drawInput.js's onCenterChange etc.),
+// not this file.
+export const createVertexPlacement = ({ drawInteraction, mapProvider, snap, canFinish, canPlace }) => {
   let sketchFeature = null
   let lastPlacedCoord = null
 
@@ -92,21 +99,20 @@ export const createVertexPlacement = ({ drawInteraction, mapProvider, snap, canF
     sketchFeature = feature
     lastPlacedCoord = null
   }
-  drawInteraction.on('drawstart', (e) => resetSketch(e.feature))
+  drawInteraction.on('drawstart', (event) => resetSketch(event.feature))
   drawInteraction.on('drawend', () => resetSketch())
   drawInteraction.on('drawabort', () => resetSketch())
 
   const snappedCenter = () => {
     const raw = mapProvider.getCenter()
-    return (getInterfaceType() !== 'mouse' && snap) ? snap.apply(raw) : raw
+    return snap ? snap.apply(raw) : raw
   }
 
   const updateRubberbanding = () => {
     if (!sketchFeature) {
-      // No sketch yet — update snap indicator at crosshair position so targets are
-      // visible before the first vertex is placed (touch/keyboard only; mouse uses
-      // the OL snap interaction's pointermove handler instead).
-      if (getInterfaceType() !== 'mouse' && snap) {
+      // No sketch yet — update the snap indicator at the crosshair so targets are visible
+      // before the first vertex is placed.
+      if (snap) {
         snap.apply(mapProvider.getCenter())
       }
       return

package/plugins/draw/src/adapters/openlayers/draw/vertexPlacement.test.js

@@ -6,7 +6,7 @@ import { createFakeMap, createEmitter, polygonFeature, lineFeature } from '../__
 
 const CENTER = [5, 5]
 
-const setup = ({ interfaceType = 'touch', snap = null, canFinish = () => true, canPlace } = {}) => {
+const setup = ({ snap = null, canFinish = () => true, canPlace } = {}) => {
   const map = createFakeMap()
   const bus = createEmitter()
   const drawInteraction = {
@@ -21,8 +21,7 @@ const setup = ({ interfaceType = 'touch', snap = null, canFinish = () => true, c
     mapProvider: { getCenter: () => CENTER },
     snap,
     canFinish,
-    canPlace,
-    getInterfaceType: () => interfaceType
+    canPlace
   })
   const startSketch = (feature) => { bus.emit('drawstart', { feature }); return feature }
   return { drawInteraction, placement, startSketch, bus }
@@ -59,13 +58,6 @@ describe('placing vertices', () => {
     expect(drawInteraction.finishDrawing).toHaveBeenCalledTimes(1)
   })
 
-  test('the mouse interface ignores snapping (the OL snap interaction covers it)', () => {
-    const snap = { apply: jest.fn(() => [9, 9]), hideIndicator: jest.fn() }
-    const { placement, drawInteraction } = setup({ interfaceType: 'mouse', snap })
-    placement.placeVertex()
-    expect(drawInteraction.appendCoordinates).toHaveBeenCalledWith([CENTER])
-  })
-
   test('a second tap at the same spot finishes the shape instead of duplicating — when finishable', () => {
     const { placement, drawInteraction, startSketch } = setup()
     startSketch(lineFeature([[0, 0], [50, 50]]))
@@ -152,16 +144,16 @@ describe('rubber-banding', () => {
     expect(feature.getGeometry().getCoordinates()[1]).toEqual(hole) // inner rings untouched
   })
 
-  test('without a sketch it only refreshes the snap indicator at the crosshair (non-mouse)', () => {
+  test('without a sketch it refreshes the snap indicator at the crosshair — the caller decides when it\'s worth calling this at all', () => {
     const snap = { apply: jest.fn((c) => c), hideIndicator: jest.fn() }
     const { placement } = setup({ snap })
     placement.updateRubberbanding()
     expect(snap.apply).toHaveBeenCalledWith(CENTER)
+  })
 
-    const mouse = setup({ interfaceType: 'mouse', snap })
-    snap.apply.mockClear()
-    mouse.placement.updateRubberbanding()
-    expect(snap.apply).not.toHaveBeenCalled()
+  test('without a sketch and no snap manager, updateRubberbanding is a harmless no-op', () => {
+    const { placement } = setup()
+    expect(() => placement.updateRubberbanding()).not.toThrow()
   })
 
   test('an empty sketch geometry is left alone', () => {

package/plugins/draw/src/adapters/openlayers/edit/EditMode.js

@@ -258,8 +258,8 @@ const wireMapSync = ({ map, manager, layers, selection, touchHandler, live }) =>
 }
 
 // The mode interface consumed by OLDrawManager
-const buildModeApi = ({ manager, store, olFeature, originalFeatureStyle, selection, actions, parts }) => {
-  const { state } = selection
+const buildModeApi = ({ manager, store, olFeature, originalFeatureStyle, selection, actions, parts, undoStack }) => {
+  const { state, setState, syncGeom, emitGeometryValidation } = selection
   const { touchHandler } = parts
 
   return {
@@ -291,10 +291,41 @@ const buildModeApi = ({ manager, store, olFeature, originalFeatureStyle, selecti
 
     undo: actions.doUndo,
     deleteVertex: actions.doDeleteVertex,
-    // MoveControls' D-pad, routed here via mapProvider.activeMoveTarget (see
+    // MapControls' D-pad, routed here via mapProvider.activeMoveTarget (see
     // events.js) once a vertex is selected.
     nudgeSelectedVertex: parts.keyboardHandler.nudgeByDelta,
 
+    // Read-only vertex/midpoint coordinates for the shared spatial listbox
+    // (plugins/draw/src/hooks/useSpatialList.js) — already kept live and correctly indexed
+    // by syncGeom()/updateLayersFromGeom() (selectionState.js), so nothing to recompute here.
+    getVertexItems: () => ({ vertices: state.vertices, midpoints: state.midpoints }),
+
+    // Moves the live cursor to a vertex or midpoint by flat index — preview only, no geometry
+    // change — for the spatial listbox's roving-tabindex move. Same shape as the local
+    // selectVertex closure in wireTouchHandler above, promoted here since buildModeApi needs
+    // its own entry point too.
+    selectVertex (index) {
+      setState({ selectedVertexIndex: index, selectedVertexType: index < state.vertices.length ? VERTEX_TYPE : 'midpoint' })
+      touchHandler.updateTargetPosition()
+    },
+
+    // Commits a new vertex exactly at midpoint `index` (no directional offset) — the
+    // destructive counterpart to selectVertex's preview-only move, for the spatial listbox's
+    // Enter/Space confirm on a midpoint item. Mirrors onTap's own midpoint-insert handling
+    // above exactly (insertAtMidpoint already inserts with no offset — that's how tap-to-insert
+    // already works, no keyboard-style directional nudge to strip).
+    insertVertexAtMidpoint (index) {
+      const result = insertAtMidpoint(olFeature, state.midpoints, index, state.vertices.length)
+      if (!result) {
+        return
+      }
+      undoStack.push({ type: 'insert_vertex', vertexIndex: result.insertedIndex })
+      syncGeom()
+      emitGeometryValidation(INSERT_VERTEX, result.insertedIndex)
+      setState({ selectedVertexIndex: result.insertedIndex, selectedVertexType: VERTEX_TYPE })
+      touchHandler.updateTargetPosition()
+    },
+
     destroy () {
       parts.live.destroy()
       olFeature.setStyle(originalFeatureStyle)
@@ -312,7 +343,7 @@ const buildModeApi = ({ manager, store, olFeature, originalFeatureStyle, selecti
 }
 
 /**
- * @returns {{ setInterfaceType, done, cancel, undo, deleteVertex, nudgeSelectedVertex, destroy } | null}
+ * @returns {{ setInterfaceType, done, cancel, undo, deleteVertex, nudgeSelectedVertex, getVertexItems, selectVertex, insertVertexAtMidpoint, destroy } | null}
  */
 export const createEditMode = ({ map, manager, options }) => {
   const { featureId, container, interfaceType, deleteVertexButtonId, snap } = options
@@ -380,6 +411,7 @@ export const createEditMode = ({ map, manager, options }) => {
     originalFeatureStyle,
     selection,
     actions,
+    undoStack,
     parts: { touchHandler, keyboardHandler, pointerHandlers, modify, mapSync, layers, live }
   })
 }

package/plugins/draw/src/adapters/openlayers/edit/EditMode.test.js

@@ -154,7 +154,7 @@ test('select via pointer, delete the vertex, then undo restores it', () => {
   mode.undo() // empty stack — no-op
 })
 
-test('nudgeSelectedVertex (MoveControls D-pad) moves the selected vertex and is undoable', () => {
+test('nudgeSelectedVertex (MapControls D-pad) moves the selected vertex and is undoable', () => {
   const { container, manager, mode, ring } = setup()
   container.dispatchEvent(domEvent('pointerdown', { pointerType: 'mouse', clientX: 100, clientY: 0 }))
   mode.nudgeSelectedVertex(1, 0, true)
@@ -165,6 +165,46 @@ test('nudgeSelectedVertex (MoveControls D-pad) moves the selected vertex and is
   expect(ring()[1]).toEqual([100, 0])
 })
 
+// getVertexItems/selectVertex/insertVertexAtMidpoint feed the shared spatial listbox
+// (plugins/draw/src/hooks/useSpatialList.js).
+describe('getVertexItems / selectVertex / insertVertexAtMidpoint (spatial listbox bridge)', () => {
+  test('getVertexItems reads the live vertices/midpoints kept in sync by selectionState', () => {
+    const { mode } = setup()
+    const { vertices, midpoints } = mode.getVertexItems()
+    expect(vertices).toEqual([[0, 0], [100, 0], [100, 100], [0, 100]])
+    expect(midpoints).toHaveLength(4)
+  })
+
+  test('selectVertex moves the cursor to a real vertex, without changing the geometry', () => {
+    const { manager, mode, ring } = setup()
+    mode.selectVertex(1)
+    expect(manager.emit).toHaveBeenCalledWith(ADAPTER_EVENTS.VERTEX_SELECTION, expect.objectContaining({ index: 1 }))
+    expect(ring()).toHaveLength(5) // unchanged
+  })
+
+  test('selectVertex moves the cursor to a midpoint (flat index past the real vertices) — reports index: -1', () => {
+    const { manager, mode } = setup()
+    mode.selectVertex(4) // first midpoint, between vertex 0 and 1
+    expect(manager.emit).toHaveBeenCalledWith(ADAPTER_EVENTS.VERTEX_SELECTION, expect.objectContaining({ index: -1 }))
+  })
+
+  test('insertVertexAtMidpoint commits a new vertex exactly at the midpoint, selects it, and is undoable', () => {
+    const { manager, mode, ring } = setup()
+    mode.insertVertexAtMidpoint(4) // first midpoint, between vertex 0 and 1
+    expect(ring()).toHaveLength(6)
+    expect(ring()[1]).toEqual([50, 0]) // exactly the midpoint — no directional offset
+    expect(manager.undoStack.pop()).toEqual({ type: 'insert_vertex', vertexIndex: 1 })
+    expect(manager.emit).toHaveBeenCalledWith(ADAPTER_EVENTS.VERTEX_SELECTION, expect.objectContaining({ index: 1 }))
+  })
+
+  test('insertVertexAtMidpoint is a no-op for an out-of-range index', () => {
+    const { manager, mode, ring } = setup()
+    mode.insertVertexAtMidpoint(999)
+    expect(ring()).toHaveLength(5)
+    expect(manager.undoStack.length).toBe(0)
+  })
+})
+
 test('undo re-validates with the inverse change phase (undo of a delete re-inserts)', () => {
   jest.useFakeTimers()
   const { container, manager, mode } = setup()

package/plugins/draw/src/adapters/openlayers/edit/keyboardHandler.js

@@ -1,5 +1,6 @@
 import { coordToPixel } from '../utils/olCoords.js'
-import { spatialNavigate } from '../../../utils/spatial.js'
+import { spatialNavigate } from '../../../../../../src/utils/spatialNavigate.js'
+import { stopIfGlobalAltKey } from '../../../../../../src/utils/globalAltShortcuts.js'
 import { wireNudge } from './nudge.js'
 
 const ARROW_KEYS = new Set(['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown'])
@@ -54,34 +55,34 @@ const isInteractiveElementFocused = (appViewport) => {
 }
 
 const buildKeydownHandler = ({ map, getState, setState, nudge, keyMove, onUndo, onKeyboardActive, isFocused }) => {
-  const handleArrowKey = (e) => {
-    if (e.altKey) {
-      e.preventDefault()
-      e.stopPropagation()
-      navigateTo(e.key, map, getState, setState)
+  const handleArrowKey = (event) => {
+    if (event.altKey) {
+      event.preventDefault()
+      event.stopPropagation()
+      navigateTo(event.key, map, getState, setState)
     } else if (getState().selectedVertexIndex >= 0) {
-      e.preventDefault()
-      e.stopPropagation()
-      nudge(e)
+      event.preventDefault()
+      event.stopPropagation()
+      nudge(event)
     } else {
       // No action: arrow with no selection and no alt modifier
     }
   }
 
-  const handleKey = (e) => {
+  const handleKey = (event) => {
     onKeyboardActive?.()
-    if (e.key === ' ') {
-      e.preventDefault()
+    if (event.key === ' ') {
+      event.preventDefault()
       if (getState().selectedVertexIndex < 0) {
         selectNearest(map, getState, setState)
       }
-    } else if (ARROW_KEYS.has(e.key)) {
-      handleArrowKey(e)
-    } else if (e.key === 'z' && (e.metaKey || e.ctrlKey)) {
+    } else if (ARROW_KEYS.has(event.key)) {
+      handleArrowKey(event)
+    } else if (event.key === 'z' && (event.metaKey || event.ctrlKey)) {
       const tag = document.activeElement?.tagName
       if (!INTERACTIVE_TAGS.has(tag)) {
-        e.preventDefault()
-        e.stopPropagation()
+        event.preventDefault()
+        event.stopPropagation()
         onUndo()
       }
     } else {
@@ -89,33 +90,42 @@ const buildKeydownHandler = ({ map, getState, setState, nudge, keyMove, onUndo,
     }
   }
 
-  return (e) => {
+  return (event) => {
     if (isFocused()) {
       return
     }
-    if (e.key === 'Escape' && getState().selectedVertexIndex >= 0) {
-      e.preventDefault()
+    if (event.key === 'Escape' && getState().selectedVertexIndex >= 0) {
+      event.preventDefault()
       keyMove.start = null
       keyMove.index = null
       setState({ selectedVertexIndex: -1, selectedVertexType: null })
     } else {
-      handleKey(e)
+      handleKey(event)
     }
   }
 }
 
-const buildKeyupHandler = ({ keyMove, onVertexMoved, onDeleted, isFocused }) => (e) => {
+const buildKeyupHandler = ({ getState, keyMove, onVertexMoved, onDeleted, isFocused }) => (event) => {
   if (isFocused()) {
     return
   }
-  if (ARROW_KEYS.has(e.key) && keyMove.start && keyMove.index != null) {
+  // Registered with capture:true below, so this runs first — shadows global Alt+<key>
+  // shortcuts (src/utils/globalAltShortcuts.js) only while something is actually selected —
+  // the same condition navigateTo/nudge already require locally. edit_point's state always
+  // reports selectedVertexIndex: 0 (a point is "always selected" — see pointSelectionState.js),
+  // so this naturally stays unconditional for that mode while genuinely gating on selection
+  // for edit_vertex, without needing to special-case either.
+  if (getState().selectedVertexIndex >= 0) {
+    stopIfGlobalAltKey(event)
+  }
+  if (ARROW_KEYS.has(event.key) && keyMove.start && keyMove.index != null) {
     // Not hiding the snap indicator here — nudge.js's own snap.apply() already left it showing
     // correctly, and it should stay that way after the key is released.
     onVertexMoved({ vertexIndex: keyMove.index, previousCoord: keyMove.start })
     keyMove.start = null
     keyMove.index = null
   }
-  if (e.key === 'Delete') {
+  if (event.key === 'Delete') {
     onDeleted()
   }
 }
@@ -146,7 +156,7 @@ export const createKeyboardHandler = (options) => {
   const isFocused = () => isInteractiveElementFocused(appViewport)
 
   const onKeydown = buildKeydownHandler({ map, getState, setState, nudge, keyMove, onUndo, onKeyboardActive, isFocused })
-  const onKeyup = buildKeyupHandler({ keyMove, onVertexMoved, onDeleted, isFocused })
+  const onKeyup = buildKeyupHandler({ getState, keyMove, onVertexMoved, onDeleted, isFocused })
 
   globalThis.addEventListener('keydown', onKeydown, { capture: true })
   globalThis.addEventListener('keyup', onKeyup, { capture: true })

package/plugins/draw/src/adapters/openlayers/edit/keyboardHandler.test.js

@@ -27,13 +27,13 @@ const setup = () => {
 
 const liveHandlers = []
 afterEach(() => {
-  liveHandlers.splice(0).forEach((h) => h.destroy())
+  liveHandlers.splice(0).forEach((handler) => handler.destroy())
   document.body.innerHTML = ''
 })
 
 const key = (type, props) => window.dispatchEvent(new KeyboardEvent(type, { cancelable: true, ...props }))
 
-test('nudgeByDelta (exposed for MoveControls) moves the selected vertex and reports it via onVertexMoved', () => {
+test('nudgeByDelta (exposed for MapControls) moves the selected vertex and reports it via onVertexMoved', () => {
   const { state, handler, onVertexMoved } = setup()
   Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
   handler.nudgeByDelta(1, 0, true)
@@ -178,6 +178,44 @@ test('Delete deletes, ctrl/cmd+z undoes — but not while typing in an input ins
   expect(onUndo).toHaveBeenCalledTimes(1)
 })
 
+test('Alt+Enter keyup stops propagation while a vertex is selected — never reaches the app-wide "highlight label at center" shortcut', () => {
+  const { state } = setup()
+  state.selectedVertexIndex = 1
+  const event = new KeyboardEvent('keyup', { key: 'Enter', altKey: true, cancelable: true, bubbles: true })
+  const stopSpy = jest.spyOn(event, 'stopPropagation')
+  window.dispatchEvent(event)
+  expect(stopSpy).toHaveBeenCalled()
+})
+
+test('Alt+Arrow keyup stops propagation too, while a vertex is selected — never reaches the app-wide "highlight next label" shortcut', () => {
+  const { state } = setup()
+  state.selectedVertexIndex = 1
+  const event = new KeyboardEvent('keyup', { key: 'ArrowRight', altKey: true, cancelable: true, bubbles: true })
+  const stopSpy = jest.spyOn(event, 'stopPropagation')
+  window.dispatchEvent(event)
+  expect(stopSpy).toHaveBeenCalled()
+})
+
+test('leaves Alt+Enter/Alt+Arrow alone with nothing selected — no local meaning to protect, so map-label selection still works', () => {
+  setup() // default state.selectedVertexIndex is -1 — nothing selected
+  const enterEvent = new KeyboardEvent('keyup', { key: 'Enter', altKey: true, cancelable: true, bubbles: true })
+  const arrowEvent = new KeyboardEvent('keyup', { key: 'ArrowRight', altKey: true, cancelable: true, bubbles: true })
+  const enterSpy = jest.spyOn(enterEvent, 'stopPropagation')
+  const arrowSpy = jest.spyOn(arrowEvent, 'stopPropagation')
+  window.dispatchEvent(enterEvent)
+  window.dispatchEvent(arrowEvent)
+  expect(enterSpy).not.toHaveBeenCalled()
+  expect(arrowSpy).not.toHaveBeenCalled()
+})
+
+test('a plain Enter keyup (no Alt) is left alone', () => {
+  setup()
+  const event = new KeyboardEvent('keyup', { key: 'Enter', altKey: false, cancelable: true, bubbles: true })
+  const stopSpy = jest.spyOn(event, 'stopPropagation')
+  window.dispatchEvent(event)
+  expect(stopSpy).not.toHaveBeenCalled()
+})
+
 test('keys are ignored while an interactive element outside the viewport has focus', () => {
   const { onDeleted, onKeyboardActive } = setup()
   const button = document.createElement('button')

package/plugins/draw/src/adapters/openlayers/edit/nudge.js

@@ -106,12 +106,12 @@ export const wireNudge = ({ map, snap, getState, setState, onInserted, onVertexM
     moveSelectedVertexBy(dx, dy)
   }
 
-  // Explicit-delta counterpart to nudge(e) — the entry point for MoveControls'
+  // Explicit-delta counterpart to nudge(e) — the entry point for MapControls'
   // D-pad (see mapProvider.activeMoveTarget in events.js). Unlike nudge(e)'s
   // held-key sequencing (undo pushed on keyup via keyMove, so repeated keydowns
   // while held batch into one undo step), each call here is one complete,
   // undoable action — a button click has no "held" state to batch. Midpoints
-  // aren't handled here: MoveControls only claims the D-pad once a real vertex is
+  // aren't handled here: MapControls only claims the D-pad once a real vertex is
   // selected (see buildVertexMoveTarget in events.js).
   const nudgeByDelta = (dx, dy, isLargeStep) => {
     const step = isLargeStep ? KEYBOARD.stepAmount : KEYBOARD.nudgeAmount

package/plugins/draw/src/adapters/openlayers/edit/nudge.test.js

@@ -53,7 +53,7 @@ describe('nudging a vertex', () => {
   })
 })
 
-describe('nudgeByDelta (MoveControls D-pad)', () => {
+describe('nudgeByDelta (MapControls D-pad)', () => {
   test('moves the selected vertex by an explicit direction, scaled by isLargeStep, and reports the move for undo', () => {
     const { state, nudgeByDelta, olFeature, onVertexMoved } = setup()
     Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
@@ -79,7 +79,7 @@ describe('nudgeByDelta (MoveControls D-pad)', () => {
     const { state, nudgeByDelta, onVertexMoved } = setup()
     nudgeByDelta(1, 0, true) // nothing selected
     Object.assign(state, { selectedVertexIndex: 4, selectedVertexType: 'midpoint' })
-    nudgeByDelta(1, 0, true) // midpoint selected — MoveControls only claims a real vertex
+    nudgeByDelta(1, 0, true) // midpoint selected — MapControls only claims a real vertex
     state.olFeature = null
     Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
     nudgeByDelta(1, 0, true)

package/plugins/draw/src/adapters/openlayers/point/drawPointMode.js

@@ -7,10 +7,8 @@ import { TOLERANCES } from '../defaults.js'
 
 const MODE = 'draw_point'
 
-// A point has no ring/rubber-band to build a candidate from — just the coordinate about to
-// be placed. Mirrors validateGeometry.js's attemptPlacement, but that helper hardcodes
-// Polygon/LineString via MODE_BY_GEOMETRY, so a Point candidate is built and validated
-// directly (same approach as the MapLibre adapter's drawPointMode.js).
+// A point has no ring/rubber-band to build a candidate from, so it's built and validated
+// directly rather than via validateGeometry.js's Polygon/LineString-only attemptPlacement.
 const canPlaceVertex = (manager) => (coordinate) => {
   const candidate = { type: 'Feature', geometry: { type: 'Point', coordinates: coordinate }, properties: {} }
   const { valid, reason } = validatePlacement(
@@ -24,14 +22,9 @@ const canPlaceVertex = (manager) => (coordinate) => {
   return valid
 }
 
-// Commit a finished point to the store under the requested id and emit CREATE — mirrors
-// draw/DrawMode.js's finalizeDrawnFeature (identical shape, kept separate rather than
-// imported since draw/DrawMode.js isn't otherwise a shared dependency of this mode).
-// Symbol resolution runs after the feature is in the store (not before), matching the
-// MapLibre adapter's own ordering. The resolver itself is injected by OLDrawManager via
-// changeMode's options (mirrors the ML adapter's state.resolvePointSymbol convention — see
-// MaplibreDrawAdapter.js's changeMode) so this mode has no direct dependency on
-// symbolRegistry/mapProvider/pointSymbolImages.js.
+// Commit a finished point to the store under the requested id and emit CREATE. Symbol
+// resolution runs after the feature is in the store, and the resolver itself is injected by
+// OLDrawManager (mirrors the MapLibre adapter's own ordering and resolvePointSymbol convention).
 const finalizeDrawnFeature = (manager, resolvePointSymbol, olFeature, featureId, properties) => {
   olFeature.setId(String(featureId))
   olFeature.setProperties(properties)
@@ -41,45 +34,41 @@ const finalizeDrawnFeature = (manager, resolvePointSymbol, olFeature, featureId,
 }
 
 /**
- * Touch/keyboard/"Add point" input for draw_point — the same concerns as
- * draw/drawInput.js (crosshair, interface-type tracking, add-vertex-button/Enter), reused
- * directly, but with a much smaller placement step: a point has no rubber band to update
- * while positioning (the crosshair itself already shows where it'll land) and nothing to
- * undo before a single-click commit, so those callbacks are no-ops here.
+ * Touch/keyboard/"Add point" input for draw_point — reuses draw/drawInput.js's crosshair and
+ * interface-type wiring, but with no rubber band or undo since a point commits on one click.
  */
 const buildPointInput = ({ drawInteraction, options, canPlace }) => {
   const { container, addVertexButtonId, mapProvider, snap, crossHair } = options
   let interfaceType = options.interfaceType ?? 'mouse'
   const getInterfaceType = () => interfaceType
 
-  // appendCoordinates() only builds up LineString/Polygon rings — for a Point-type Draw
-  // interaction it does nothing beyond starting the sketch (confirmed by reading OL's own
-  // source), so finishDrawing() has to be called explicitly right after to actually commit.
+  // appendCoordinates() only starts the sketch for a Point-type Draw interaction, so
+  // finishDrawing() must be called explicitly to commit. Only ever reached via the crosshair
+  // path (Enter, the add-vertex button, or the crosshair's own click), never a real mouse
+  // click, so snap always applies here when available.
   const placePoint = () => {
     const raw = mapProvider.getCenter()
-    const coord = (getInterfaceType() !== 'mouse' && snap) ? snap.apply(raw) : raw
+    const coord = snap ? snap.apply(raw) : raw
     snap?.hideIndicator()
     if (!canPlace(coord)) { return }
     drawInteraction.appendCoordinates([coord])
     drawInteraction.finishDrawing()
   }
 
-  // Keeps the snap indicator visible at the crosshair while positioning via touch/keyboard
-  // (mouse hover is handled by the separate OL snap interaction already attached by
-  // OLDrawManager) — the closest point-shaped equivalent of updateRubberbanding.
+  // Keeps the snap indicator visible at the crosshair — the point-shaped equivalent of
+  // updateRubberbanding. Callers decide when this is worth calling (see applyInterfaceType
+  // below and draw/drawInput.js's onCenterChange).
   const updateSnapIndicator = () => {
-    if (getInterfaceType() !== 'mouse' && snap) { snap.apply(mapProvider.getCenter()) }
+    if (snap) { snap.apply(mapProvider.getCenter()) }
   }
 
-  // Mirrors draw/drawInput.js's createDrawInput: an interface-type switch to touch/keyboard
-  // must refresh the snap indicator immediately at the crosshair, not wait for the next
-  // pointermove/change:center — otherwise it stays hidden until the user first pans or drags
-  // after entering the mode (the same gap the MapLibre adapter's onInterfaceTypeChange already
-  // guards against by calling onMove(state) right after _setInterface).
+  // Mirrors draw/drawInput.js's createDrawInput: a switch to touch/keyboard refreshes the
+  // snap indicator immediately rather than waiting for the next pan. Switching back to mouse
+  // has no crosshair target to refresh.
   const applyInterfaceType = (type) => {
     interfaceType = type
     applyCrossHairVisibility(crossHair, type)
-    updateSnapIndicator()
+    if (type !== 'mouse') { updateSnapIndicator() }
   }
 
   const events = wireInputEvents({
@@ -96,10 +85,8 @@ const buildPointInput = ({ drawInteraction, options, canPlace }) => {
 
   applyCrossHairVisibility(crossHair, interfaceType)
 
-  // Single shared "commit here" entry point for the crosshair button's own onClick
-  // (CrossHair.jsx) — the same action Enter/the touch add-vertex button already trigger via
-  // placeVertex, so a click (real, touch, or Voice Control's "Click Target") does exactly
-  // what those already do.
+  // Shared "commit here" entry point for the crosshair button's own onClick — same action as
+  // Enter/the touch add-vertex button.
   if (crossHair) {
     crossHair.activate = placePoint
   }
@@ -115,21 +102,12 @@ const buildPointInput = ({ drawInteraction, options, canPlace }) => {
 }
 
 /**
- * Draw mode for placing a single point: mouse click, or crosshair + Enter/"Add point"
- * button for touch/keyboard. Commits immediately on the first placement — unlike
- * draw_line/draw_polygon, there is no rubber band, no multi-vertex undo, and no "Done"
- * step (mirrors the MapLibre adapter's drawPointMode.js decision).
- *
- * OL's own Draw({type:'Point'}) interaction already finishes a real mouse click
- * immediately (confirmed by reading its handleUpEvent — mode 'Point' always attempts
- * finishDrawing() on pointer-up, no second click needed), so the mouse path needs no
- * extra wiring beyond the placement-veto condition every mode already has. Deliberately
- * NOT built via draw/DrawMode.js's createDrawMode()/createVertexPlacement() — those are
- * parametrised around a ring of placed vertices + a trailing rubber-band coordinate,
- * which a single-click commit doesn't have (mirrors the same decision already made for
- * the MapLibre adapter, and the OL EditMode/DrawMode split noted in
- * feedback_adapter_parity.md: don't force point through machinery shaped for lines/polygons
- * just because they happen to share a file).
+ * Draw mode for placing a single point: mouse click, or crosshair + Enter/"Add point" button
+ * for touch/keyboard. Commits immediately, with no rubber band, undo, or "Done" step. OL's own
+ * Draw({type:'Point'}) interaction already finishes a real mouse click on pointer-up, so the
+ * mouse path needs no extra wiring. Deliberately not built via draw/DrawMode.js's
+ * createDrawMode()/createVertexPlacement() — those assume a ring of vertices plus a trailing
+ * rubber-band coordinate, which a single-click commit doesn't have.
  */
 export const createDrawPointMode = ({ map, manager, options }) => {
   const { featureId, properties = {} } = options
@@ -137,18 +115,15 @@ export const createDrawPointMode = ({ map, manager, options }) => {
 
   const drawInteraction = new Draw({
     type: 'Point',
-    // Without an explicit style, OL renders its own default sketch style (a blue circle)
-    // following the cursor before commit — core/styles.js's createSketchStyle() already
-    // suppresses this same default for the "ghost" Point sketch OL renders alongside a
-    // Polygon/LineString sketch (see its own comment); a real Point sketch needs the same
-    // treatment, since it commits on the very first click with nothing meaningful to preview.
+    // Suppresses OL's default sketch style (a blue circle following the cursor) — nothing
+    // meaningful to preview since this commits on the first click.
     style: () => [],
     snapTolerance: TOLERANCES.snapRadius,
-    condition: (e) => noModifierKeys(e) && canPlace(e.coordinate)
+    condition: (event) => noModifierKeys(event) && canPlace(event.coordinate)
   })
   map.addInteraction(drawInteraction)
 
-  drawInteraction.on('drawend', (e) => finalizeDrawnFeature(manager, options.resolvePointSymbol, e.feature, featureId, properties))
+  drawInteraction.on('drawend', (event) => finalizeDrawnFeature(manager, options.resolvePointSymbol, event.feature, featureId, properties))
   drawInteraction.on('drawabort', () => { manager.emit(ADAPTER_EVENTS.CANCEL) })
 
   const input = buildPointInput({ drawInteraction, options, canPlace })