@defra/interactive-map 0.0.39-alpha → 0.0.41-alpha

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

@@ -77,4 +77,15 @@ describe('createModifyInteraction', () => {
     modify.destroy()
     expect(map.removeInteraction).toHaveBeenCalledWith(interaction)
   })
+
+  // point/editPointMode.js injects its own condition (built around map.forEachFeatureAtPixel)
+  // in place of buildModifyCondition's fixed-radius hit-test, since a symbol icon can render
+  // far bigger than PIXEL_TOLERANCE covers.
+  test('an injected condition overrides buildModifyCondition\'s own default', () => {
+    const map = createFakeMap()
+    const state = { interfaceType: 'mouse', vertices: [[0, 0]], midpoints: [] }
+    const customCondition = jest.fn(() => true)
+    createModifyInteraction({ map, olFeature: polygonFeature(RING), getState: () => state, onModifyEnd: jest.fn(), condition: customCondition })
+    expect(map.interactions[0].condition_).toBe(customCondition)
+  })
 })

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

@@ -30,9 +30,12 @@ export const resolveSnappedCoord = (snap, map, current, nudgedCoord, snappedCoor
  * `keyMove` tracks the coordinate at the start of a nudge sequence so a single
  * move_vertex undo op can be pushed on keyup (see keyboardHandler).
  *
+ * @param {(olFeature, index: number, coord: number[]) => void} [options.moveCoord] - coordinate
+ *   writer, defaulting to moveVertex; point/editPointMode.js injects point/pointOps.js's
+ *   movePoint instead, since a Point has no ring index to address.
  * @returns {{ nudge: (e: KeyboardEvent) => void, keyMove: { start, index }, nudgeByDelta: (dx: number, dy: number, isLargeStep: boolean) => void }}
  */
-export const wireNudge = ({ map, snap, getState, setState, onInserted, onVertexMoved }) => {
+export const wireNudge = ({ map, snap, getState, setState, onInserted, onVertexMoved, moveCoord = moveVertex }) => {
   const keyMove = { start: null, index: null }
 
   // Shared core: moves the selected vertex by an already pixel-scaled delta,
@@ -46,9 +49,13 @@ export const wireNudge = ({ map, snap, getState, setState, onInserted, onVertexM
     const current = vertices[selectedVertexIndex]
     const nudgedCoord = nudgeCoord(map, current, dx, dy)
     const snappedCoord = snap ? snap.apply(nudgedCoord) : nudgedCoord
-    snap?.hideIndicator()
     const newCoord = resolveSnappedCoord(snap, map, current, nudgedCoord, snappedCoord, dx, dy)
-    moveVertex(olFeature, selectedVertexIndex, newCoord)
+    // resolveSnappedCoord can override snappedCoord with an escape jump clear of the snap
+    // radius — when it does, the indicator snap.apply() just showed is now stale, so correct it.
+    if (snap && newCoord !== snappedCoord) {
+      snap.hideIndicator()
+    }
+    moveCoord(olFeature, selectedVertexIndex, newCoord)
     setState({ vertices: vertices.map((c, i) => i === selectedVertexIndex ? newCoord : c) })
     return { previousCoord: current, vertexIndex: selectedVertexIndex }
   }
@@ -99,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 MoveControl's
+  // Explicit-delta counterpart to nudge(e) — the entry point for MoveControls'
   // 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: MoveControl only claims the D-pad once a real vertex is
+  // aren't handled here: MoveControls 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 (MoveControl D-pad)', () => {
+describe('nudgeByDelta (MoveControls 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 (MoveControl 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 — MoveControl only claims a real vertex
+    nudgeByDelta(1, 0, true) // midpoint selected — MoveControls only claims a real vertex
     state.olFeature = null
     Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
     nudgeByDelta(1, 0, true)
@@ -134,7 +134,17 @@ describe('snapping while nudging', () => {
     Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
     nudge({ key: 'ArrowRight' })
     expect(ring(olFeature)[1]).toEqual([16, 0])
-    expect(snap.hideIndicator).toHaveBeenCalled()
+  })
+
+  // Regression: a stray hideIndicator() right after snap.apply() undid its own show on every
+  // single nudge, so the indicator could never actually be seen. keyboardHandler.js's own keyup
+  // no longer hides it either — see its own comment — so once shown here, it stays shown.
+  test('does not hide the indicator mid-sequence — snap.apply() already shows/hides it', () => {
+    const snap = snapReturning((c) => [c[0] + 1, c[1]])
+    const { state, nudge } = setup({ snap })
+    Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
+    nudge({ key: 'ArrowRight' })
+    expect(snap.hideIndicator).not.toHaveBeenCalled()
   })
 
   test('escapes the snap radius when snapping blocks the nudge', () => {
@@ -144,6 +154,19 @@ describe('snapping while nudging', () => {
     nudge({ key: 'ArrowRight' })
     expect(ring(olFeature)[1]).toEqual([23, 0]) // snapRadius + 1 past the original position
   })
+
+  // Regression: nudging away from a target you're sitting on escapes the snap radius (above),
+  // but snap.apply() had already shown the indicator at the target it's about to flee — left
+  // uncorrected, the indicator stayed pinned there for one extra press even though the vertex
+  // had already jumped clear, only catching up on the next press once querying from the
+  // escaped position genuinely found nothing.
+  test('hides the indicator when a nudge escapes the snap radius', () => {
+    const snap = snapReturning(() => [10, 0]) // snap holds the vertex in place
+    const { state, nudge } = setup({ snap })
+    Object.assign(state, { selectedVertexIndex: 1, selectedVertexType: 'vertex' })
+    nudge({ key: 'ArrowRight' })
+    expect(snap.hideIndicator).toHaveBeenCalled()
+  })
 })
 
 describe('resolveSnappedCoord', () => {

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

@@ -30,21 +30,22 @@ const handleTouchStart = (e, { map, targetEl, cssToOl, getState, drag }) => {
   e.preventDefault()
 }
 
-const handleTouchMove = (e, { map, targetEl, olToCSS, getState, setState, snap, drag }) => {
+const handleTouchMove = (e, { map, targetEl, olToCSS, getState, setState, snap, drag, moveCoord }) => {
   if (!isOnTouchTarget(e.target) || drag.dragStartIndex == null) {
     return
   }
   e.preventDefault()
   const tOl = map.getEventPixel({ clientX: e.touches[0].clientX, clientY: e.touches[0].clientY })
   const rawCoord = pixelToCoord(map, { x: tOl[0] - drag.vertexTouchDelta.x, y: tOl[1] - drag.vertexTouchDelta.y })
+  // snap.apply() already shows/hides the indicator based on whether a candidate was found.
   const newCoord = snap ? snap.apply(rawCoord) : rawCoord
-  snap?.hideIndicator()
   const { olFeature, vertices } = getState()
   if (!olFeature) {
     return
   }
-  moveVertex(olFeature, drag.dragStartIndex, newCoord)
+  moveCoord(olFeature, drag.dragStartIndex, newCoord)
   setState({ vertices: vertices.map((c, i) => i === drag.dragStartIndex ? newCoord : c) })
+  // Tracks the raw touch point, not newCoord — the vertex is what jumps to the snap candidate.
   showTouchTarget(targetEl, olToCSS({ x: tOl[0] - drag.targetTouchDelta.x, y: tOl[1] - drag.targetTouchDelta.y }))
 }
 
@@ -63,7 +64,7 @@ const handleTap = (e, { map, getState, onTap, drag }) => {
 }
 
 const handleTouchEnd = (e, ctx) => {
-  const { getState, onVertexMoved, snap, drag } = ctx
+  const { getState, onVertexMoved, drag, updateTargetPosition } = ctx
   if (drag.dragStartIndex == null) {
     handleTap(e, ctx)
     drag.tapStart = null
@@ -74,8 +75,9 @@ const handleTouchEnd = (e, ctx) => {
   if (vertices[drag.dragStartIndex] && drag.dragStartCoord) {
     onVertexMoved({ vertexIndex: drag.dragStartIndex, previousCoord: drag.dragStartCoord })
   }
-  snap?.hideIndicator()
+  // Not hiding the indicator here — it should stay showing after the drag ends.
   drag.dragStartCoord = null; drag.dragStartIndex = null; drag.vertexTouchDelta = null; drag.targetTouchDelta = null
+  updateTargetPosition() // re-sync the target to the vertex's final position
   e.preventDefault()
 }
 
@@ -97,6 +99,8 @@ const wireTouchEvents = (deps) => {
   container.addEventListener('touchstart', onTouchstart, { passive: false })
   container.addEventListener('touchmove', onTouchmove, { passive: false })
   container.addEventListener('touchend', onTouchend, { passive: false })
+  // touchcancel fires instead of touchend when the browser itself interrupts the gesture.
+  container.addEventListener('touchcancel', onTouchend, { passive: false })
 
   return {
     isDragging: () => drag.dragStartIndex != null,
@@ -104,6 +108,7 @@ const wireTouchEvents = (deps) => {
       container.removeEventListener('touchstart', onTouchstart)
       container.removeEventListener('touchmove', onTouchmove)
       container.removeEventListener('touchend', onTouchend)
+      container.removeEventListener('touchcancel', onTouchend)
     }
   }
 }
@@ -114,15 +119,16 @@ const wireTouchEvents = (deps) => {
  * without finger occlusion. Tap on a vertex or midpoint selects it via onTap.
  *
  * @param {{ map, container, getState, setState, onVertexMoved, onTap, colors }} options
+ * @param {(olFeature, index: number, coord: number[]) => void} [options.moveCoord] - coordinate
+ *   writer, defaulting to moveVertex; point/editPointMode.js injects point/pointOps.js's
+ *   movePoint instead, since a Point has no ring index to address.
  * @returns {{ updateTargetPosition, updateColors, hide, destroy }}
  */
-export const createTouchHandler = ({ map, container, getState, setState, onVertexMoved, onTap, colors, snap }) => {
+export const createTouchHandler = ({ map, container, getState, setState, onVertexMoved, onTap, colors, snap, moveCoord = moveVertex }) => {
   const targetEl = createTouchTarget(container)
   applyTouchTargetColors(targetEl, colors)
 
-  // OL pixel space is relative to ol-viewport at its pre-scale CSS size.
-  // Container CSS space is larger when a CSS transform scales up ol-viewport
-  // (e.g. scale(1.5) at medium map size makes OL pixels 1.5× smaller than CSS pixels).
+  // Converts between OL pixel space and CSS space, which differ when a CSS transform scales up ol-viewport.
   const cssTx = { scale: 1, ox: 0, oy: 0 }
   const olToCSS = (p) => ({ x: p.x * cssTx.scale + cssTx.ox, y: p.y * cssTx.scale + cssTx.oy })
   const cssToOl = (p) => ({ x: (p.x - cssTx.ox) / cssTx.scale, y: (p.y - cssTx.oy) / cssTx.scale })
@@ -140,8 +146,6 @@ export const createTouchHandler = ({ map, container, getState, setState, onVerte
     })
   }
 
-  const touchEvents = wireTouchEvents({ container, map, targetEl, olToCSS, cssToOl, getState, setState, onVertexMoved, onTap, snap })
-
   const updateTargetPosition = () => {
     const { selectedVertexIndex, vertices, interfaceType } = getState()
     if (selectedVertexIndex < 0 || !vertices[selectedVertexIndex] || interfaceType !== 'touch') {
@@ -156,8 +160,9 @@ export const createTouchHandler = ({ map, container, getState, setState, onVerte
     showTouchTarget(targetEl, olToCSS(px))
   }
 
-  // Reposition on every render — keeps target anchored during pinch-zoom and pan.
-  // Skipped during drag since touchmove handles position directly.
+  const touchEvents = wireTouchEvents({ container, map, targetEl, olToCSS, cssToOl, getState, setState, onVertexMoved, onTap, snap, moveCoord, updateTargetPosition })
+
+  // Reposition on every render (skipped mid-drag, which handles position directly) to stay anchored during pinch-zoom and pan.
   const onPostrender = () => {
     const { selectedVertexIndex, interfaceType } = getState()
     if (selectedVertexIndex >= 0 && !touchEvents.isDragging() && interfaceType === 'touch') {

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

@@ -70,6 +70,42 @@ test('the offset target hides when its vertex cannot be projected', () => {
   handler.destroy()
 })
 
+// The offset target is the drag handle under your finger and must track it exactly, even
+// while snap pulls the vertex itself elsewhere (mirrors the ML adapter) — the vertex is what
+// visibly "jumps" to the snap candidate, not the target. Once the drag actually ends, the
+// target re-syncs to the vertex's own final (possibly snapped) position, collapsing the gap.
+test('the offset target tracks the raw touch point while dragging, then snaps to the vertex on release', () => {
+  const snap = { apply: jest.fn((c) => [c[0] + 5, c[1]]), hideIndicator: jest.fn() }
+  const { container, handler, touch } = setup({}, { snap })
+  handler.updateTargetPosition()
+  touch('touchstart', 100, 0)
+  touch('touchmove', 120, 10) // raw touch → [120,10]; vertex snaps to [125,10]
+  const target = container.querySelector('[data-im-draw-touch-target]')
+  expect(target.style.left).toBe('120px') // tracks the finger…
+  expect(target.style.left).not.toBe('125px') // …not the snapped vertex, while still dragging
+
+  touch('touchend', 120, 10)
+  expect(target.style.left).toBe('125px') // re-synced to the vertex's actual final position
+  handler.destroy()
+})
+
+// touchcancel (the browser interrupting a gesture itself — a scroll takeover, app switch,
+// etc.) must resync the target exactly like touchend does — without this listener a
+// cancelled drag left the target stuck wherever the last touchmove put it.
+test('touchcancel resyncs the target the same way touchend does', () => {
+  const snap = { apply: jest.fn((c) => [c[0] + 5, c[1]]), hideIndicator: jest.fn() }
+  const { container, handler, touch, grip } = setup({}, { snap })
+  handler.updateTargetPosition()
+  touch('touchstart', 100, 0)
+  touch('touchmove', 120, 10) // raw touch → [120,10]; vertex snaps to [125,10]
+  const target = container.querySelector('[data-im-draw-touch-target]')
+  expect(target.style.left).toBe('120px') // tracking the finger mid-drag
+
+  grip.dispatchEvent(domEvent('touchcancel', { touches: [{ clientX: 120, clientY: 10 }], changedTouches: [{ clientX: 120, clientY: 10 }] }))
+  expect(target.style.left).toBe('125px') // re-synced to the vertex's actual final position
+  handler.destroy()
+})
+
 test('a drag applies snapping to the moved coordinate when a snap manager is active', () => {
   const snap = { apply: jest.fn((c) => [c[0] + 5, c[1]]), hideIndicator: jest.fn() }
   const { state, handler, touch } = setup({}, { snap })
@@ -77,8 +113,17 @@ test('a drag applies snapping to the moved coordinate when a snap manager is act
   touch('touchstart', 100, 0)
   touch('touchmove', 120, 10)
   expect(snap.apply).toHaveBeenCalled()
-  expect(snap.hideIndicator).toHaveBeenCalled()
   expect(state.vertices[1]).toEqual([125, 10]) // dragged to [120,10] then snapped +5 on x
+
+  // Regression: a stray hideIndicator() right after snap.apply() on every touchmove undid its
+  // own show, so the indicator could never actually be seen mid-drag — it's only meant to
+  // clear for real once the drag actually finishes.
+  expect(snap.hideIndicator).not.toHaveBeenCalled()
+  // And it must stay showing after the drag ends too — snap.apply()'s own last call already
+  // left it correctly reflecting the snapped position (mirrors the ML adapter, which never
+  // hides its own indicator on release either).
+  touch('touchend', 120, 10)
+  expect(snap.hideIndicator).not.toHaveBeenCalled()
   handler.destroy()
 })
 

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

@@ -1,11 +1,9 @@
 import { OLDrawManager } from './core/OLDrawManager.js'
 import { MAP_SIZE_SCALES } from './defaults.js'
+import { refreshAllPointSymbols } from './point/pointSymbolImages.js'
 
 /**
- * Creates the OLDrawManager, attaches it to mapProvider, and wires
- * app-level events (MAP_SET_SIZE for scale-aware touch targets,
- * MAP_SET_STYLE for dynamic color updates).
- *
+ * Creates the OLDrawManager, attaches it to mapProvider, and wires app-level size/style events.
  * @returns {{ manager: OLDrawManager, remove: () => void }}
  */
 export const createOLDraw = ({ mapProvider, events, eventBus, pluginConfig = {}, mapStyle = null }) => {
@@ -18,13 +16,22 @@ export const createOLDraw = ({ mapProvider, events, eventBus, pluginConfig = {},
 
   mapProvider.draw = manager
 
+  // Seed drawScale from the provider's own starting size — MAP_SET_SIZE only fires on a later runtime change, not the initial one.
+  mapProvider.drawScale = MAP_SIZE_SCALES[mapProvider.mapSize] ?? 1
+
+  // Nudges useHighlightSync to re-apply the highlight overlay — OL's own MAP_DATA_CHANGE is driven purely by basemap 'tileloadend', unrelated to the draw source.
+  const notifyPointSymbolsRefreshed = () => eventBus.emit(events.MAP_DATA_CHANGE)
+
   const handleSetMapSize = (size) => {
     mapProvider.drawScale = MAP_SIZE_SCALES[size] ?? 1
+    refreshAllPointSymbols({ manager, mapProvider }).then(notifyPointSymbolsRefreshed)
   }
   eventBus.on(events.MAP_SET_SIZE, handleSetMapSize)
 
   const handleSetMapStyle = (newMapStyle) => {
     manager.setMapStyle(newMapStyle)
+    // Rasterised point symbol images are style-scoped (colours resolve per map style).
+    refreshAllPointSymbols({ manager, mapProvider }).then(notifyPointSymbolsRefreshed)
   }
   eventBus.on(events.MAP_SET_STYLE, handleSetMapStyle)
 

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

@@ -1,5 +1,6 @@
 import { createOLDraw } from './olDraw.js'
 import { OLDrawManager } from './core/OLDrawManager.js'
+import { refreshAllPointSymbols } from './point/pointSymbolImages.js'
 import { MAP_SIZE_SCALES } from './defaults.js'
 
 jest.mock('./core/OLDrawManager.js', () => ({
@@ -8,15 +9,16 @@ jest.mock('./core/OLDrawManager.js', () => ({
     this.remove = jest.fn()
   })
 }))
+jest.mock('./point/pointSymbolImages.js', () => ({ refreshAllPointSymbols: jest.fn(() => Promise.resolve()) }))
 
-const events = { MAP_SET_SIZE: 'app:size', MAP_SET_STYLE: 'app:style' }
+const events = { MAP_SET_SIZE: 'app:size', MAP_SET_STYLE: 'app:style', MAP_DATA_CHANGE: 'app:datachange' }
 
 const setup = (mapStyle = null) => {
   const listeners = {}
   const eventBus = {
     on: jest.fn((type, handler) => { listeners[type] = handler }),
     off: jest.fn(),
-    emit: (type, payload) => listeners[type]?.(payload)
+    emit: jest.fn((type, payload) => listeners[type]?.(payload))
   }
   const mapProvider = { map: { id: 'ol-map' } }
   const olDraw = createOLDraw({ mapProvider, events, eventBus, pluginConfig: { snapRadius: 5 }, mapStyle })
@@ -35,14 +37,46 @@ test('creates the manager for the map, exposes it as mapProvider.draw and applie
   expect(setup().manager.setMapStyle).not.toHaveBeenCalled() // no initial style
 })
 
-test('map size changes update the draw UI scale, defaulting to 1 for unknown sizes', () => {
-  const { eventBus, mapProvider } = setup()
+// Regression: MAP_SET_SIZE only ever fires from the map-size UI control being clicked at
+// runtime, so a map that loads directly at medium/large left drawScale unset (defaulting to 1,
+// i.e. small) until the user happened to change size — rasterising the first symbol placed at
+// the wrong resolution. mapProvider.mapSize already holds the size the map actually loaded at.
+test('seeds drawScale from the provider\'s own starting map size, before any size-change event', () => {
+  const eventBus = { on: jest.fn(), off: jest.fn() }
+  const mapProvider = { map: { id: 'ol-map' }, mapSize: 'large' }
+  createOLDraw({ mapProvider, events, eventBus })
+  expect(mapProvider.drawScale).toBe(MAP_SIZE_SCALES.large)
+})
+
+test('defaults the seeded drawScale to 1 when the provider has no starting map size', () => {
+  const eventBus = { on: jest.fn(), off: jest.fn() }
+  const mapProvider = { map: { id: 'ol-map' } }
+  createOLDraw({ mapProvider, events, eventBus })
+  expect(mapProvider.drawScale).toBe(1)
+})
+
+test('map size changes update the draw UI scale, defaulting to 1 for unknown sizes, and re-resolve point symbols', async () => {
+  const { eventBus, mapProvider, manager } = setup()
   eventBus.emit(events.MAP_SET_SIZE, 'large')
   expect(mapProvider.drawScale).toBe(MAP_SIZE_SCALES.large)
+  expect(refreshAllPointSymbols).toHaveBeenCalledWith({ manager, mapProvider })
   eventBus.emit(events.MAP_SET_SIZE, 'enormous')
   expect(mapProvider.drawScale).toBe(1)
 })
 
+// A selected point's highlight overlay only re-applies on MAP_DATA_CHANGE, and (unlike
+// MapLibre) OL's own MAP_DATA_CHANGE is driven purely by basemap 'tileloadend' — nothing
+// ties it to the draw VectorSource, so without this explicit nudge a resize/style change
+// with no tiles loading would never re-trigger the highlight refresh at all, leaving an
+// already-selected point's ring stuck on its old (now wrong-resolution) icon.
+test('emits MAP_DATA_CHANGE once point symbols have actually finished re-resolving after a size change', async () => {
+  const { eventBus, manager, mapProvider } = setup()
+  eventBus.emit(events.MAP_SET_SIZE, 'large')
+  await Promise.resolve() // flush the refreshAllPointSymbols().then(...) microtask
+  expect(refreshAllPointSymbols).toHaveBeenCalledWith({ manager, mapProvider })
+  expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_DATA_CHANGE)
+})
+
 test('pluginConfig and mapStyle are optional, defaulting to {} and no initial style', () => {
   const eventBus = { on: jest.fn(), off: jest.fn() }
   const mapProvider = { map: { id: 'ol-map' } }
@@ -54,10 +88,18 @@ test('pluginConfig and mapStyle are optional, defaulting to {} and no initial st
   olDraw.remove()
 })
 
-test('map style changes are forwarded to the manager', () => {
-  const { eventBus, manager } = setup()
+test('map style changes are forwarded to the manager and re-resolve point symbols', () => {
+  const { eventBus, manager, mapProvider } = setup()
   eventBus.emit(events.MAP_SET_STYLE, { id: 'dark' })
   expect(manager.setMapStyle).toHaveBeenCalledWith({ id: 'dark' })
+  expect(refreshAllPointSymbols).toHaveBeenCalledWith({ manager, mapProvider })
+})
+
+test('emits MAP_DATA_CHANGE once point symbols have actually finished re-resolving after a style change', async () => {
+  const { eventBus } = setup()
+  eventBus.emit(events.MAP_SET_STYLE, { id: 'dark' })
+  await Promise.resolve()
+  expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_DATA_CHANGE)
 })
 
 test('remove unsubscribes, destroys the manager and clears mapProvider.draw', () => {

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

@@ -0,0 +1,156 @@
+import Draw from 'ol/interaction/Draw.js'
+import { noModifierKeys } from 'ol/events/condition.js'
+import { wireInputEvents, applyCrossHairVisibility } from '../draw/drawInput.js'
+import { ADAPTER_EVENTS } from '../../../adapterEvents.js'
+import { validatePlacement } from '../../../validation/validateGeometry.js'
+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).
+const canPlaceVertex = (manager) => (coordinate) => {
+  const candidate = { type: 'Feature', geometry: { type: 'Point', coordinates: coordinate }, properties: {} }
+  const { valid, reason } = validatePlacement(
+    candidate,
+    { mode: MODE, vertexIndex: 0 },
+    { onGeometryChange: manager._geometryValidator }
+  )
+  if (!valid) {
+    manager.emit(ADAPTER_EVENTS.PLACEMENT_BLOCKED, { feature: candidate, reason: reason ?? null, phase: 'place', mode: MODE, vertexIndex: 0 })
+  }
+  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.
+const finalizeDrawnFeature = (manager, resolvePointSymbol, olFeature, featureId, properties) => {
+  olFeature.setId(String(featureId))
+  olFeature.setProperties(properties)
+  manager.store.source.addFeature(olFeature)
+  manager.emit(ADAPTER_EVENTS.CREATE, manager.store.toGeoJSON(olFeature))
+  resolvePointSymbol?.(olFeature)
+}
+
+/**
+ * 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.
+ */
+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.
+  const placePoint = () => {
+    const raw = mapProvider.getCenter()
+    const coord = (getInterfaceType() !== 'mouse' && 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.
+  const updateSnapIndicator = () => {
+    if (getInterfaceType() !== 'mouse' && 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).
+  const applyInterfaceType = (type) => {
+    interfaceType = type
+    applyCrossHairVisibility(crossHair, type)
+    updateSnapIndicator()
+  }
+
+  const events = wireInputEvents({
+    container,
+    addVertexButtonId,
+    olView: drawInteraction.getMap()?.getView(),
+    onUndo: null,
+    getInterfaceType,
+    setInterfaceType: applyInterfaceType,
+    clearLastCoord: () => {},
+    updateRubberbanding: updateSnapIndicator,
+    placeVertex: placePoint
+  })
+
+  applyCrossHairVisibility(crossHair, interfaceType)
+
+  return {
+    getInterfaceType,
+    setInterfaceType: applyInterfaceType,
+    destroy () { events.destroy() }
+  }
+}
+
+/**
+ * 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).
+ */
+export const createDrawPointMode = ({ map, manager, options }) => {
+  const { featureId, properties = {} } = options
+  const canPlace = canPlaceVertex(manager)
+
+  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.
+    style: () => [],
+    snapTolerance: TOLERANCES.snapRadius,
+    condition: (e) => noModifierKeys(e) && canPlace(e.coordinate)
+  })
+  map.addInteraction(drawInteraction)
+
+  drawInteraction.on('drawend', (e) => finalizeDrawnFeature(manager, options.resolvePointSymbol, e.feature, featureId, properties))
+  drawInteraction.on('drawabort', () => { manager.emit(ADAPTER_EVENTS.CANCEL) })
+
+  const input = buildPointInput({ drawInteraction, options, canPlace })
+
+  return {
+    done () {}, // no-op: commit is immediate, there's no pending sketch to finish
+    cancel () { drawInteraction.abortDrawing() },
+    undo () {}, // no-op: nothing placed yet to undo before commit
+    setInterfaceType (type) { input.setInterfaceType(type) },
+    destroy () {
+      manager.emit(ADAPTER_EVENTS.INTERFACE_TYPE_CHANGE, { interfaceType: input.getInterfaceType() })
+      input.destroy()
+      map.removeInteraction(drawInteraction)
+    }
+  }
+}