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

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

@@ -56,6 +56,41 @@ test('arrow keys switch to the keyboard interface without placing', () => {
   expect(placement.placeVertex).not.toHaveBeenCalled()
 })
 
+describe('global Alt+<key> shortcut shadowing', () => {
+  test('Alt+Enter keyup stops propagation while drawing — never reaches the app-wide "highlight label at center" shortcut', () => {
+    setup()
+    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 — never reaches the app-wide "highlight next label" shortcut', () => {
+    setup()
+    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('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('the shadow listener is removed on destroy — Alt+Enter bubbles normally again', () => {
+    const { input } = setup()
+    input.destroy()
+    const event = new KeyboardEvent('keyup', { key: 'Enter', altKey: true, cancelable: true, bubbles: true })
+    const stopSpy = jest.spyOn(event, 'stopPropagation')
+    window.dispatchEvent(event)
+    expect(stopSpy).not.toHaveBeenCalled()
+  })
+})
+
 test('ctrl/cmd+z triggers undo', () => {
   const { container, onUndo } = setup()
   container.focus()
@@ -111,7 +146,26 @@ test('pointer moves and map pans update the rubber band except for the mouse int
   expect(mouse.placement.updateRubberbanding).not.toHaveBeenCalled()
 })
 
-test('setInterfaceType updates the interface and refreshes the rubber band immediately for non-mouse types, e.g. switching to touch and panning via MoveControls mid-session', () => {
+// Voice Control's simulated clicks report pointerType 'mouse' (interfaceType never leaves
+// 'mouse') and produce no real pointermove, so panning via MapControls needs its own
+// fallback: getAnimating() is true for MapControls' own panBy/zoomIn/zoomOut (both animate
+// the view) but not for a live mouse drag (which sets the center directly), so it's a safe
+// signal to also track even while interfaceType is 'mouse'.
+test('a programmatic move (e.g. MapControls panBy) still updates the rubber band while interfaceType is mouse', () => {
+  const { view, placement } = setup('mouse')
+  view.getAnimating.mockReturnValue(true)
+  view.emit('change:center')
+  expect(placement.updateRubberbanding).toHaveBeenCalledTimes(1)
+})
+
+test('postrender tracks an animated move for the mouse interface too, same as keyboard', () => {
+  const { map, view, placement } = setup('mouse')
+  view.getAnimating.mockReturnValue(true)
+  map.emit('postrender')
+  expect(placement.updateRubberbanding).toHaveBeenCalledTimes(1)
+})
+
+test('setInterfaceType updates the interface and refreshes the rubber band immediately for non-mouse types, e.g. switching to touch and panning via MapControls mid-session', () => {
   const { input, placement } = setup('mouse')
   input.setInterfaceType('touch')
   expect(input.getInterfaceType()).toBe('touch')

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)