@defra/interactive-map 0.0.40-alpha → 0.0.42-alpha

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)
+    }
+  }
+}

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

@@ -0,0 +1,246 @@
+import { createDrawPointMode } from './drawPointMode.js'
+import { wireInputEvents, applyCrossHairVisibility } from '../draw/drawInput.js'
+import { createFeatureStore } from '../core/featureStore.js'
+import { ADAPTER_EVENTS } from '../../../adapterEvents.js'
+import { createFakeMap, createFakeManager, pointFeature } from '../__helpers__/harness.js'
+
+jest.mock('../draw/drawInput.js', () => ({
+  wireInputEvents: jest.fn(() => ({ destroy: jest.fn() })),
+  applyCrossHairVisibility: jest.fn()
+}))
+
+// Matches DrawMode.test.js's own convention: real OL interactions are used, but drawstart/
+// drawend/drawabort are dispatched as plain event objects directly (rather than exercised
+// through the real appendCoordinates/startDrawing_/finishDrawing internals, which need a
+// fully-featured OL map — getMap().getView().getProjection() — well beyond what the
+// lightweight fake map here provides or needs to).
+const setup = (options = {}) => {
+  const map = createFakeMap()
+  const manager = createFakeManager()
+  manager.store = createFeatureStore()
+  const emitted = () => manager.emit.mock.calls.map(([type, payload]) => ({ type, payload }))
+  const mode = createDrawPointMode({
+    map,
+    manager,
+    options: {
+      featureId: 'point-1',
+      properties: { symbol: 'pin' },
+      container: null,
+      crossHair: null,
+      snap: null,
+      mapProvider: { getCenter: () => [5, 5] },
+      ...options
+    }
+  })
+  const interaction = map.interactions[0]
+  const wireArgs = wireInputEvents.mock.calls.at(-1)[0]
+  return { map, manager, emitted, mode, interaction, wireArgs }
+}
+
+afterEach(() => jest.clearAllMocks())
+
+describe('createDrawPointMode', () => {
+  test('adds a Point-type Draw interaction to the map', () => {
+    const { interaction } = setup()
+    expect(interaction).toBeDefined()
+  })
+
+  test('suppresses OL\'s default sketch style — no blue cursor-following circle', () => {
+    const { interaction } = setup()
+    // OL stores the resolved style on the sketch overlay layer, not on the interaction
+    // itself — this is what OL actually calls per frame to render the sketch/hover point.
+    expect(interaction.overlay_.getStyle()()).toEqual([])
+  })
+
+  test('drawend commits the sketch under the requested id and fires CREATE', () => {
+    const { interaction, manager, emitted } = setup()
+    interaction.dispatchEvent({ type: 'drawend', feature: pointFeature([1, 2], 'ol-generated-id') })
+
+    const created = emitted().filter((e) => e.type === ADAPTER_EVENTS.CREATE)
+    expect(created).toHaveLength(1)
+    expect(created[0].payload.id).toBe('point-1') // re-id'd, not the OL-generated one
+    expect(created[0].payload.geometry.coordinates).toEqual([1, 2])
+    expect(created[0].payload.properties).toEqual({ symbol: 'pin' })
+    expect(manager.store.get('point-1')).toBeTruthy()
+  })
+
+  test('calls the adapter-injected resolvePointSymbol hook with the committed OL feature, after re-id', () => {
+    const resolvePointSymbol = jest.fn()
+    const { interaction } = setup({ resolvePointSymbol })
+    interaction.dispatchEvent({ type: 'drawend', feature: pointFeature([1, 2], 'ol-generated-id') })
+
+    expect(resolvePointSymbol).toHaveBeenCalledTimes(1)
+    const [olFeature] = resolvePointSymbol.mock.calls[0]
+    expect(olFeature.getId()).toBe('point-1')
+  })
+
+  test('does not throw when no resolvePointSymbol hook was supplied', () => {
+    const { interaction } = setup()
+    expect(() => interaction.dispatchEvent({ type: 'drawend', feature: pointFeature([1, 2], 'ol-generated-id') })).not.toThrow()
+  })
+
+  test('defaults properties to {} when none are supplied', () => {
+    const { interaction, manager, emitted } = setup({ properties: undefined })
+    interaction.dispatchEvent({ type: 'drawend', feature: pointFeature([1, 2], 'ol-generated-id') })
+    const created = emitted().filter((e) => e.type === ADAPTER_EVENTS.CREATE)
+    // OL's GeoJSON writer reports no properties as null (not {}) — the meaningful
+    // assertion is what setProperties() was actually called with, on the stored feature.
+    expect(created[0].payload.properties).toBeNull()
+    const { geometry, ...nonGeometryProps } = manager.store.getOL('point-1').getProperties()
+    expect(nonGeometryProps).toEqual({})
+  })
+
+  test('condition vetoes placement via onGeometryChange', () => {
+    const { interaction, manager, emitted } = setup()
+    manager._geometryValidator = () => ({ valid: false, reason: 'not allowed here' })
+    const condition = interaction.condition_
+    const allowed = condition({ coordinate: [1, 2], originalEvent: {} })
+    expect(allowed).toBe(false)
+    const blocked = emitted().filter((e) => e.type === ADAPTER_EVENTS.PLACEMENT_BLOCKED)
+    expect(blocked).toHaveLength(1)
+    expect(blocked[0].payload).toMatchObject({ reason: 'not allowed here', phase: 'place', mode: 'draw_point' })
+  })
+
+  test('condition allows an unvetoed placement', () => {
+    const { interaction } = setup()
+    const condition = interaction.condition_
+    expect(condition({ coordinate: [1, 2], originalEvent: {} })).toBe(true)
+  })
+
+  test('condition blocks modifier-key clicks', () => {
+    const { interaction } = setup()
+    const condition = interaction.condition_
+    expect(condition({ coordinate: [1, 2], originalEvent: { shiftKey: true } })).toBe(false)
+  })
+
+  test('drawabort emits CANCEL', () => {
+    const { interaction, emitted } = setup()
+    interaction.dispatchEvent({ type: 'drawabort' })
+    expect(emitted().some((e) => e.type === ADAPTER_EVENTS.CANCEL)).toBe(true)
+  })
+
+  describe('touch/keyboard placement (via the wired placeVertex callback)', () => {
+    // appendCoordinates()/finishDrawing() are OL-internal machinery already exercised by
+    // OL's own test suite — what this mode owns is calling them with the right (possibly
+    // snapped) coordinate, gated by the same placement veto the mouse path uses.
+    const spyOnCommit = (interaction) => ({
+      append: jest.spyOn(interaction, 'appendCoordinates').mockImplementation(() => {}),
+      finish: jest.spyOn(interaction, 'finishDrawing').mockImplementation(() => {})
+    })
+
+    test('places at the (possibly snapped) map centre and hides the indicator', () => {
+      const snap = { apply: jest.fn((c) => [c[0] + 1, c[1] + 1]), hideIndicator: jest.fn() }
+      const mapProvider = { getCenter: () => [5, 5] }
+      const { wireArgs, interaction } = setup({ snap, mapProvider, interfaceType: 'touch' })
+      const { append, finish } = spyOnCommit(interaction)
+
+      wireArgs.placeVertex()
+
+      expect(snap.apply).toHaveBeenCalledWith([5, 5])
+      expect(snap.hideIndicator).toHaveBeenCalled()
+      expect(append).toHaveBeenCalledWith([[6, 6]])
+      expect(finish).toHaveBeenCalled()
+    })
+
+    test('does not snap on mouse interface', () => {
+      const snap = { apply: jest.fn(), hideIndicator: jest.fn() }
+      const { wireArgs, interaction } = setup({ snap, interfaceType: 'mouse' })
+      const { append } = spyOnCommit(interaction)
+      wireArgs.placeVertex()
+      expect(snap.apply).not.toHaveBeenCalled()
+      expect(append).toHaveBeenCalledWith([[5, 5]])
+    })
+
+    test('a vetoed crosshair placement never commits', () => {
+      const { wireArgs, manager, emitted, interaction } = setup()
+      const { append, finish } = spyOnCommit(interaction)
+      manager._geometryValidator = () => false
+      wireArgs.placeVertex()
+      expect(append).not.toHaveBeenCalled()
+      expect(finish).not.toHaveBeenCalled()
+      expect(emitted().filter((e) => e.type === ADAPTER_EVENTS.PLACEMENT_BLOCKED)).toHaveLength(1)
+    })
+
+    test('updateRubberbanding shows the snap indicator at the crosshair for touch/keyboard, not mouse', () => {
+      const snap = { apply: jest.fn(), hideIndicator: jest.fn() }
+      const mapProvider = { getCenter: () => [7, 7] }
+      const { wireArgs } = setup({ snap, mapProvider, interfaceType: 'keyboard' })
+      wireArgs.updateRubberbanding()
+      expect(snap.apply).toHaveBeenCalledWith([7, 7])
+    })
+
+    test('updateRubberbanding does nothing on mouse interface', () => {
+      const snap = { apply: jest.fn(), hideIndicator: jest.fn() }
+      const { wireArgs } = setup({ snap, interfaceType: 'mouse' })
+      wireArgs.updateRubberbanding()
+      expect(snap.apply).not.toHaveBeenCalled()
+    })
+
+    // Regression: without this, switching to touch/keyboard left the indicator hidden until
+    // the next pointermove/change:center — mirrors draw/drawInput.js's createDrawInput and
+    // the MapLibre adapter's onInterfaceTypeChange (which calls onMove(state) for the same
+    // reason).
+    test('switching interface type via the wired setInterfaceType immediately refreshes the snap indicator at the crosshair', () => {
+      const snap = { apply: jest.fn(), hideIndicator: jest.fn() }
+      const mapProvider = { getCenter: () => [9, 9] }
+      const { wireArgs } = setup({ snap, mapProvider, interfaceType: 'mouse' })
+      wireArgs.setInterfaceType('touch')
+      expect(snap.apply).toHaveBeenCalledWith([9, 9])
+    })
+
+    test('switching interface type via the wired setInterfaceType does not query snap for mouse', () => {
+      const snap = { apply: jest.fn(), hideIndicator: jest.fn() }
+      const { wireArgs } = setup({ snap, interfaceType: 'touch' })
+      wireArgs.setInterfaceType('mouse')
+      expect(snap.apply).not.toHaveBeenCalled()
+    })
+
+    test('clearLastCoord is a harmless no-op (points have no lastPlacedCoord bookkeeping)', () => {
+      const { wireArgs } = setup()
+      expect(() => wireArgs.clearLastCoord()).not.toThrow()
+    })
+  })
+
+  test('applies crosshair visibility for the initial interface type on setup', () => {
+    setup({ interfaceType: 'touch' })
+    expect(applyCrossHairVisibility).toHaveBeenCalledWith(null, 'touch')
+  })
+
+  describe('mode API', () => {
+    test('done/undo are no-ops — a single click has nothing pending or to undo', () => {
+      const { mode } = setup()
+      expect(() => mode.done()).not.toThrow()
+      expect(() => mode.undo()).not.toThrow()
+    })
+
+    test('cancel aborts the in-progress sketch', () => {
+      const { mode, interaction } = setup()
+      const abortSpy = jest.spyOn(interaction, 'abortDrawing').mockImplementation(() => {})
+      mode.cancel()
+      expect(abortSpy).toHaveBeenCalled()
+    })
+
+    test('setInterfaceType delegates to applyCrossHairVisibility', () => {
+      const { mode } = setup()
+      applyCrossHairVisibility.mockClear()
+      mode.setInterfaceType('touch')
+      expect(applyCrossHairVisibility).toHaveBeenCalledWith(null, 'touch')
+    })
+
+    test('setInterfaceType also refreshes the snap indicator at the crosshair for touch/keyboard', () => {
+      const snap = { apply: jest.fn(), hideIndicator: jest.fn() }
+      const mapProvider = { getCenter: () => [3, 4] }
+      const { mode } = setup({ snap, mapProvider })
+      mode.setInterfaceType('keyboard')
+      expect(snap.apply).toHaveBeenCalledWith([3, 4])
+    })
+
+    test('destroy emits the final interface type, tears down input and removes the interaction', () => {
+      const { mode, map, interaction, emitted } = setup()
+      const removeSpy = jest.spyOn(map, 'removeInteraction')
+      mode.destroy()
+      expect(emitted().some((e) => e.type === ADAPTER_EVENTS.INTERFACE_TYPE_CHANGE)).toBe(true)
+      expect(removeSpy).toHaveBeenCalledWith(interaction)
+    })
+  })
+})