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

package/plugins/draw/src/adapters/maplibre/utils/snapHelpers.test.js

@@ -0,0 +1,253 @@
+import {
+  getSnapInstance,
+  isSnapActive,
+  getSnapLngLat,
+  getSnapCoords,
+  triggerSnapAtPoint,
+  triggerSnapAtCenter,
+  clearSnapIndicator,
+  clearSnapState,
+  getSnapRadius,
+  isSnapEnabled,
+  createSnappedEvent,
+  createSnappedClickEvent
+} from './snapHelpers.js'
+import { TOLERANCES } from '../../../defaults.js'
+
+const activeSnap = (overrides = {}) => ({
+  status: true,
+  snapStatus: true,
+  snapCoords: [1, 2],
+  ...overrides
+})
+
+describe('getSnapInstance', () => {
+  test('returns the snap instance when present', () => {
+    const snap = {}
+    expect(getSnapInstance({ _snapInstance: snap })).toBe(snap)
+  })
+
+  test('returns null when the map has no instance', () => {
+    expect(getSnapInstance({})).toBeNull()
+  })
+
+  test('returns null when the map is nullish', () => {
+    expect(getSnapInstance(null)).toBeNull()
+  })
+})
+
+describe('isSnapActive', () => {
+  test('returns true when status, snapStatus and >=2 coords are present', () => {
+    expect(isSnapActive(activeSnap())).toBe(true)
+  })
+
+  test('returns false when snap is nullish', () => {
+    expect(isSnapActive(null)).toBe(false)
+  })
+
+  test('returns false when status is falsy', () => {
+    expect(isSnapActive(activeSnap({ status: false }))).toBe(false)
+  })
+
+  test('returns false when snapStatus is falsy', () => {
+    expect(isSnapActive(activeSnap({ snapStatus: false }))).toBe(false)
+  })
+
+  test('returns false when coords have fewer than 2 entries', () => {
+    expect(isSnapActive(activeSnap({ snapCoords: [1] }))).toBe(false)
+  })
+})
+
+describe('getSnapLngLat', () => {
+  test('returns lng/lat object when snap is active', () => {
+    expect(getSnapLngLat(activeSnap())).toEqual({ lng: 1, lat: 2 })
+  })
+
+  test('returns null when snap is inactive', () => {
+    expect(getSnapLngLat(null)).toBeNull()
+  })
+})
+
+describe('getSnapCoords', () => {
+  test('returns [lng, lat] array when snap is active', () => {
+    expect(getSnapCoords(activeSnap())).toEqual([1, 2])
+  })
+
+  test('returns null when snap is inactive', () => {
+    expect(getSnapCoords(null)).toBeNull()
+  })
+})
+
+describe('triggerSnapAtPoint', () => {
+  test('unprojects the point and triggers snap detection', () => {
+    const snap = { status: true, snapToClosestPoint: jest.fn() }
+    const lngLat = { lng: 5, lat: 6 }
+    const map = { unproject: jest.fn(() => lngLat) }
+    const point = { x: 10, y: 20 }
+
+    expect(triggerSnapAtPoint(snap, map, point)).toBe(true)
+    expect(map.unproject).toHaveBeenCalledWith(point)
+    expect(snap.snapToClosestPoint).toHaveBeenCalledWith({ point, lngLat })
+  })
+
+  test('returns false when snap is missing', () => {
+    expect(triggerSnapAtPoint(null, {}, {})).toBe(false)
+  })
+
+  test('returns false when map is missing', () => {
+    expect(triggerSnapAtPoint({ status: true }, null, {})).toBe(false)
+  })
+
+  test('returns false when snap is disabled', () => {
+    expect(triggerSnapAtPoint({ status: false }, {}, {})).toBe(false)
+  })
+})
+
+describe('triggerSnapAtCenter', () => {
+  test('projects the map centre and triggers snap detection', () => {
+    const snap = { status: true, snapToClosestPoint: jest.fn() }
+    const center = { lng: 1, lat: 2 }
+    const point = { x: 3, y: 4 }
+    const map = { getCenter: jest.fn(() => center), project: jest.fn(() => point) }
+
+    expect(triggerSnapAtCenter(snap, map)).toBe(true)
+    expect(map.project).toHaveBeenCalledWith(center)
+    expect(snap.snapToClosestPoint).toHaveBeenCalledWith({ point, lngLat: center })
+  })
+
+  test('returns false when snap is missing', () => {
+    expect(triggerSnapAtCenter(null, {})).toBe(false)
+  })
+
+  test('returns false when map is missing', () => {
+    expect(triggerSnapAtCenter({ status: true }, null)).toBe(false)
+  })
+
+  test('returns false when snap is disabled', () => {
+    expect(triggerSnapAtCenter({ status: false }, {})).toBe(false)
+  })
+})
+
+describe('clearSnapIndicator', () => {
+  test('resets snap state, empties the feature arrays and hides the layer', () => {
+    const snap = {
+      snapStatus: true,
+      snapCoords: [1, 2],
+      snappedFeatures: [{}, {}],
+      closeFeatures: [{}],
+      lines: [{}]
+    }
+    const map = {
+      getLayer: jest.fn(() => ({})),
+      setLayoutProperty: jest.fn()
+    }
+
+    clearSnapIndicator(snap, map)
+
+    expect(snap.snapStatus).toBe(false)
+    expect(snap.snapCoords).toBeNull()
+    expect(snap.snappedFeatures).toHaveLength(0)
+    expect(snap.closeFeatures).toHaveLength(0)
+    expect(snap.lines).toHaveLength(0)
+    expect(map.setLayoutProperty).toHaveBeenCalledWith('snap-helper-circle', 'visibility', 'none')
+  })
+
+  test('handles a snap with empty/absent arrays and no map', () => {
+    const snap = { snapStatus: true, snapCoords: [1, 2] }
+    expect(() => clearSnapIndicator(snap)).not.toThrow()
+    expect(snap.snapStatus).toBe(false)
+    expect(snap.snapCoords).toBeNull()
+  })
+
+  test('does not touch the layer when it is absent', () => {
+    const map = { getLayer: jest.fn(() => null), setLayoutProperty: jest.fn() }
+    clearSnapIndicator(null, map)
+    expect(map.setLayoutProperty).not.toHaveBeenCalled()
+  })
+})
+
+describe('clearSnapState', () => {
+  test('returns early when snap is nullish', () => {
+    expect(() => clearSnapState(null)).not.toThrow()
+  })
+
+  test('resets snap state and empties the feature arrays', () => {
+    const snap = {
+      snapStatus: true,
+      snapCoords: [1, 2],
+      snappedFeatures: [{}, {}],
+      closeFeatures: [{}],
+      lines: [{}]
+    }
+
+    clearSnapState(snap)
+
+    expect(snap.snapStatus).toBe(false)
+    expect(snap.snapCoords).toBeNull()
+    expect(snap.snappedFeatures).toHaveLength(0)
+    expect(snap.closeFeatures).toHaveLength(0)
+    expect(snap.lines).toHaveLength(0)
+  })
+
+  test('handles a snap with empty/absent arrays', () => {
+    const snap = { snapStatus: true, snapCoords: [1, 2] }
+    expect(() => clearSnapState(snap)).not.toThrow()
+    expect(snap.snapCoords).toBeNull()
+  })
+})
+
+describe('getSnapRadius', () => {
+  test('returns the configured radius', () => {
+    expect(getSnapRadius({ options: { radius: 25 } })).toBe(25)
+  })
+
+  test('falls back to the configured snap radius when unset', () => {
+    expect(getSnapRadius(null)).toBe(TOLERANCES.snapRadius)
+  })
+})
+
+describe('isSnapEnabled', () => {
+  test('returns true when getSnapEnabled returns true', () => {
+    expect(isSnapEnabled({ getSnapEnabled: () => true })).toBe(true)
+  })
+
+  test('returns false when getSnapEnabled returns a non-true value', () => {
+    expect(isSnapEnabled({ getSnapEnabled: () => false })).toBe(false)
+  })
+
+  test('returns false when getSnapEnabled is not a function', () => {
+    expect(isSnapEnabled({})).toBe(false)
+  })
+})
+
+describe('createSnappedEvent', () => {
+  test('merges the snapped lngLat into the event when snapping', () => {
+    const e = { type: 'click', lngLat: { lng: 0, lat: 0 } }
+    const result = createSnappedEvent(e, activeSnap())
+    expect(result).toEqual({ type: 'click', lngLat: { lng: 1, lat: 2 } })
+  })
+
+  test('returns the original event when there is no snap', () => {
+    const e = { type: 'click' }
+    expect(createSnappedEvent(e, null)).toBe(e)
+  })
+})
+
+describe('createSnappedClickEvent', () => {
+  test('builds a synthetic click event at the snapped point', () => {
+    const point = { x: 12, y: 34 }
+    const map = { project: jest.fn(() => point) }
+
+    const result = createSnappedClickEvent(map, activeSnap())
+
+    expect(map.project).toHaveBeenCalledWith([1, 2])
+    expect(result.lngLat).toEqual({ lng: 1, lat: 2 })
+    expect(result.point).toBe(point)
+    expect(result.originalEvent).toBeInstanceOf(MouseEvent)
+    expect(result.originalEvent.type).toBe('click')
+  })
+
+  test('returns null when there is no snap', () => {
+    expect(createSnappedClickEvent({}, null)).toBeNull()
+  })
+})

package/plugins/draw/src/adapters/maplibre/utils/touchClickWorkaround.js

@@ -0,0 +1,57 @@
+const MAX_TAP_DURATION_MS = 300
+const MAX_TAP_MOVEMENT_PX = 10
+
+/**
+ * Workaround: mapbox-gl-draw calls preventDefault() on touchend even in disabled
+ * mode, which stops the browser synthesizing a click event. Detect quick taps
+ * while in disabled mode and manually dispatch a click on the canvas so app-level
+ * click handlers (e.g. feature selection) still fire.
+ *
+ * @param {Object} map - MapLibre map instance
+ * @param {Object} draw - MapboxDraw instance (used to check the current mode)
+ * @returns {{ remove: Function }}
+ */
+export const setupTouchClickWorkaround = (map, draw) => {
+  const canvas = map.getCanvas()
+  let touchStart = null
+
+  const handleTouchStart = (e) => {
+    if (e.touches.length === 1) {
+      touchStart = { x: e.touches[0].clientX, y: e.touches[0].clientY, time: Date.now() }
+    }
+  }
+
+  const handleTouchEnd = (e) => {
+    if (draw.getMode() !== 'disabled' || !touchStart) {
+      touchStart = null
+      return
+    }
+
+    const touch = e.changedTouches[0]
+    const dx = touch.clientX - touchStart.x
+    const dy = touch.clientY - touchStart.y
+    const duration = Date.now() - touchStart.time
+
+    // Only synthesize click for quick taps with minimal movement
+    if (duration < MAX_TAP_DURATION_MS && Math.abs(dx) < MAX_TAP_MOVEMENT_PX && Math.abs(dy) < MAX_TAP_MOVEMENT_PX) {
+      canvas.dispatchEvent(new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+        clientX: touch.clientX,
+        clientY: touch.clientY
+      }))
+    }
+
+    touchStart = null
+  }
+
+  canvas.addEventListener('touchstart', handleTouchStart, { passive: true })
+  canvas.addEventListener('touchend', handleTouchEnd, { passive: true })
+
+  return {
+    remove () {
+      canvas.removeEventListener('touchstart', handleTouchStart)
+      canvas.removeEventListener('touchend', handleTouchEnd)
+    }
+  }
+}

package/plugins/draw/src/adapters/maplibre/utils/touchClickWorkaround.test.js

@@ -0,0 +1,106 @@
+import { setupTouchClickWorkaround } from './touchClickWorkaround.js'
+
+const createCanvas = () => {
+  const listeners = {}
+  return {
+    addEventListener: jest.fn((type, handler) => { listeners[type] = handler }),
+    removeEventListener: jest.fn(),
+    dispatchEvent: jest.fn(),
+    fire (type, event) { listeners[type]?.(event) }
+  }
+}
+
+const touchStartEvent = (touches) => ({ touches })
+const touchEndEvent = (changedTouches) => ({ changedTouches })
+
+describe('setupTouchClickWorkaround', () => {
+  let canvas
+  let map
+  let draw
+
+  beforeEach(() => {
+    canvas = createCanvas()
+    map = { getCanvas: () => canvas }
+    draw = { getMode: jest.fn(() => 'disabled') }
+    jest.spyOn(Date, 'now')
+  })
+
+  afterEach(() => {
+    Date.now.mockRestore()
+  })
+
+  test('registers passive touchstart/touchend listeners on the canvas', () => {
+    setupTouchClickWorkaround(map, draw)
+    expect(canvas.addEventListener).toHaveBeenCalledWith('touchstart', expect.any(Function), { passive: true })
+    expect(canvas.addEventListener).toHaveBeenCalledWith('touchend', expect.any(Function), { passive: true })
+  })
+
+  test('synthesizes a click for a quick, stationary tap in disabled mode', () => {
+    Date.now.mockReturnValueOnce(1000).mockReturnValueOnce(1100)
+    setupTouchClickWorkaround(map, draw)
+
+    canvas.fire('touchstart', touchStartEvent([{ clientX: 50, clientY: 60 }]))
+    canvas.fire('touchend', touchEndEvent([{ clientX: 52, clientY: 61 }]))
+
+    expect(canvas.dispatchEvent).toHaveBeenCalledTimes(1)
+    const dispatched = canvas.dispatchEvent.mock.calls[0][0]
+    expect(dispatched).toBeInstanceOf(MouseEvent)
+    expect(dispatched.type).toBe('click')
+    expect(dispatched.clientX).toBe(52)
+    expect(dispatched.clientY).toBe(61)
+  })
+
+  test('does not synthesize a click when the tap is too slow', () => {
+    Date.now.mockReturnValueOnce(1000).mockReturnValueOnce(1400)
+    setupTouchClickWorkaround(map, draw)
+
+    canvas.fire('touchstart', touchStartEvent([{ clientX: 50, clientY: 60 }]))
+    canvas.fire('touchend', touchEndEvent([{ clientX: 50, clientY: 60 }]))
+
+    expect(canvas.dispatchEvent).not.toHaveBeenCalled()
+  })
+
+  test('does not synthesize a click when the finger moves too far', () => {
+    Date.now.mockReturnValueOnce(1000).mockReturnValueOnce(1100)
+    setupTouchClickWorkaround(map, draw)
+
+    canvas.fire('touchstart', touchStartEvent([{ clientX: 50, clientY: 60 }]))
+    canvas.fire('touchend', touchEndEvent([{ clientX: 100, clientY: 60 }]))
+
+    expect(canvas.dispatchEvent).not.toHaveBeenCalled()
+  })
+
+  test('ignores multi-touch gestures on touchstart', () => {
+    setupTouchClickWorkaround(map, draw)
+
+    canvas.fire('touchstart', touchStartEvent([{ clientX: 1, clientY: 1 }, { clientX: 2, clientY: 2 }]))
+    canvas.fire('touchend', touchEndEvent([{ clientX: 1, clientY: 1 }]))
+
+    expect(canvas.dispatchEvent).not.toHaveBeenCalled()
+  })
+
+  test('does nothing when the current mode is not disabled', () => {
+    draw.getMode.mockReturnValue('draw_polygon')
+    setupTouchClickWorkaround(map, draw)
+
+    canvas.fire('touchstart', touchStartEvent([{ clientX: 50, clientY: 60 }]))
+    canvas.fire('touchend', touchEndEvent([{ clientX: 50, clientY: 60 }]))
+
+    expect(canvas.dispatchEvent).not.toHaveBeenCalled()
+  })
+
+  test('does nothing on touchend without a preceding single-finger touchstart', () => {
+    setupTouchClickWorkaround(map, draw)
+
+    canvas.fire('touchend', touchEndEvent([{ clientX: 50, clientY: 60 }]))
+
+    expect(canvas.dispatchEvent).not.toHaveBeenCalled()
+  })
+
+  test('remove() detaches both listeners', () => {
+    const { remove } = setupTouchClickWorkaround(map, draw)
+    remove()
+    expect(canvas.removeEventListener).toHaveBeenCalledWith('touchstart', expect.any(Function))
+    expect(canvas.removeEventListener).toHaveBeenCalledWith('touchend', expect.any(Function))
+  })
+})

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

@@ -0,0 +1,117 @@
+import { createOLDraw } from './olDraw.js'
+
+// split.js passes this literal — MapLibre's own always-present "already-drawn
+// shapes" style layer id — as a snapLayers entry so the split line snaps to the
+// polygon it's splitting. On MapLibre it needs no help: mapbox-gl-snap resolves
+// it by querying the map's rendered style layers directly. OL's snap engine has
+// no such string-based lookup for plain vector layers (only direct instances or
+// vector-tile layer names), so this adapter recognises the same literal here and
+// resolves it to the draw plugin's own VectorLayer instance instead.
+const DRAW_OUTLINE_STYLE_LAYER = 'stroke-inactive.cold'
+
+/**
+ * Draw adapter for OpenLayers.
+ *
+ * Wraps OLDrawManager (via createOLDraw) and exposes the shared adapter interface
+ * consumed by events.js, DrawInit, and the api entry points.
+ *
+ * OLDrawManager already exposes on/off/emit, changeMode, done/cancel/undo/deleteVertex,
+ * get/add/delete/deleteAll, and setInterfaceType. This adapter adds the snap methods
+ * and undo-stack clearing (OL manages its own undo stack on the manager).
+ *
+ * Adapter interface (also implemented by MaplibreDrawAdapter):
+ *   changeMode(name, options)
+ *   getMode()
+ *   setInterfaceType(type)
+ *   done() / cancel() / undo() / deleteVertex()
+ *   nudgeSelectedVertex(dx, dy, isLargeStep)
+ *   get(id) / add(feature) / delete(id) / deleteAll()
+ *   setSnapEnabled(bool) / setSnapLayers(layers) / isSnapEnabled()
+ *   setFeatureProperty(id, property, value) / setDrawingPreviewProperty(property, value)
+ *   on(event, handler) / off(event, handler)
+ *   remove()
+ */
+export class OLDrawAdapter {
+  _snapEnabled = false
+
+  constructor (mapProvider, options) {
+    const { manager, remove } = createOLDraw({
+      mapProvider,
+      events: options.events,
+      eventBus: options.eventBus,
+      // The full pluginConfig, not just snapLayers — OLDrawManager also reads
+      // colour/size overrides (shapeStroke, editStroke, strokeWidth, snapRadius,
+      // etc.) off this object via resolveColors().
+      pluginConfig: options.pluginConfig ?? { snapLayers: options.snapLayers },
+      mapStyle: options.mapStyle
+    })
+    this._cleanupOLDraw = remove
+    this._manager = manager
+    this._mapProvider = mapProvider
+  }
+
+  changeMode (name, options = {}) {
+    // Inject OL-specific options that the unified api doesn't supply
+    const opts = { ...options, mapProvider: this._mapProvider }
+    if (name === 'draw_polygon') { opts.geometryType = 'Polygon' }
+    if (name === 'draw_line') { opts.geometryType = 'LineString' }
+    return this._manager.changeMode(name, opts)
+  }
+
+  getMode () { return this._manager.getMode() }
+
+  setInterfaceType (type) { this._manager.setInterfaceType(type) }
+
+  done () {
+    this._manager.undoStack.clear()
+    this._manager.done()
+  }
+
+  cancel () {
+    this._manager.undoStack.clear()
+    this._manager.cancel()
+  }
+
+  undo () { this._manager.undo() }
+  deleteVertex () { this._manager.deleteVertex() }
+  nudgeSelectedVertex (dx, dy, isLargeStep) { this._manager.nudgeSelectedVertex(dx, dy, isLargeStep) }
+
+  // Record the current geometry validity so the draw mode can block finish gestures
+  // (double-click / click-to-close) while the in-progress shape is invalid.
+  setGeometryValid (valid) { this._manager._geometryValid = valid }
+
+  // The api entry points assign the active user validator to the adapter; store it
+  // on the manager so the draw mode can veto placements synchronously.
+  set _geometryValidator (fn) { this._manager._geometryValidator = fn }
+  get _geometryValidator () { return this._manager._geometryValidator }
+
+  // Show/hide the dashed invalid stroke on the active sketch or edit feature.
+  setInvalid (invalid) { this._manager.setInvalid(invalid) }
+
+  get (id) { return this._manager.get(id) }
+  add (feature) { return this._manager.add(feature) }
+  delete (id) { return this._manager.delete(id) }
+  deleteAll () { return this._manager.deleteAll() }
+
+  setSnapEnabled (bool) {
+    this._snapEnabled = bool
+    this._manager.snap?.setActive(bool)
+  }
+
+  setSnapLayers (layers) {
+    const translated = layers?.map((l) => (l === DRAW_OUTLINE_STYLE_LAYER ? this._manager._layer : l))
+    this._manager.snap?.setSnapLayers(translated)
+  }
+
+  isSnapEnabled () { return this._snapEnabled }
+
+  setFeatureProperty () { /* not implemented for OL */ }
+  setDrawingPreviewProperty (property, value) { this._manager.setDrawingPreviewProperty(property, value) }
+
+  on (type, handler) { this._manager.on(type, handler) }
+  off (type, handler) { this._manager.off(type, handler) }
+
+  remove () {
+    this._cleanupOLDraw()
+  }
+}

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

@@ -0,0 +1,159 @@
+import { OLDrawAdapter } from './OLDrawAdapter.js'
+import { createOLDraw } from './olDraw.js'
+
+// The literal split.js passes — see OLDrawAdapter.js's DRAW_OUTLINE_STYLE_LAYER comment.
+const DRAW_OUTLINE_STYLE_LAYER = 'stroke-inactive.cold'
+
+const fakeVectorLayer = { id: 'draw-layer' }
+
+const fakeManager = () => ({
+  _layer: fakeVectorLayer,
+  changeMode: jest.fn(),
+  getMode: jest.fn(() => 'disabled'),
+  setInterfaceType: jest.fn(),
+  done: jest.fn(),
+  cancel: jest.fn(),
+  undo: jest.fn(),
+  deleteVertex: jest.fn(),
+  nudgeSelectedVertex: jest.fn(),
+  setInvalid: jest.fn(),
+  setDrawingPreviewProperty: jest.fn(),
+  get: jest.fn(() => 'feature'),
+  add: jest.fn(),
+  delete: jest.fn(),
+  deleteAll: jest.fn(),
+  on: jest.fn(),
+  off: jest.fn(),
+  undoStack: { clear: jest.fn() },
+  snap: { setActive: jest.fn(), setSnapLayers: jest.fn() }
+})
+
+jest.mock('./olDraw.js', () => ({
+  createOLDraw: jest.fn(({ mapProvider }) => ({ manager: mapProvider._testManager, remove: jest.fn() }))
+}))
+
+const setup = () => {
+  const manager = fakeManager()
+  const mapProvider = { _testManager: manager }
+  const adapter = new OLDrawAdapter(mapProvider, {
+    events: { MAP_SET_STYLE: 's' },
+    eventBus: {},
+    snapLayers: ['boundaries'],
+    mapStyle: { id: 'default' }
+  })
+  return { manager, mapProvider, adapter }
+}
+
+afterEach(() => jest.clearAllMocks())
+
+test('wires olDraw with the plugin options and uses the returned manager', () => {
+  const { manager, adapter } = setup()
+  expect(createOLDraw).toHaveBeenCalledWith(expect.objectContaining({
+    pluginConfig: { snapLayers: ['boundaries'] },
+    mapStyle: { id: 'default' }
+  }))
+  expect(adapter.getMode()).toBe('disabled')
+  expect(manager.getMode).toHaveBeenCalled()
+})
+
+test('forwards the full pluginConfig (colour/size overrides too), not just snapLayers', () => {
+  const manager = fakeManager()
+  const mapProvider = { _testManager: manager }
+  const pluginConfig = { snapLayers: ['boundaries'], shapeStroke: '#custom', strokeWidth: 5 }
+  // eslint-disable-next-line no-new
+  new OLDrawAdapter(mapProvider, {
+    events: { MAP_SET_STYLE: 's' },
+    eventBus: {},
+    pluginConfig,
+    mapStyle: { id: 'default' }
+  })
+  expect(createOLDraw).toHaveBeenCalledWith(expect.objectContaining({ pluginConfig }))
+})
+
+test('changeMode injects the mapProvider and the OL geometry type per draw mode', () => {
+  const { manager, mapProvider, adapter } = setup()
+  adapter.changeMode('draw_polygon', { featureId: 'f1' })
+  expect(manager.changeMode).toHaveBeenCalledWith('draw_polygon', { featureId: 'f1', mapProvider, geometryType: 'Polygon' })
+  adapter.changeMode('draw_line')
+  expect(manager.changeMode).toHaveBeenCalledWith('draw_line', { mapProvider, geometryType: 'LineString' })
+  adapter.changeMode('edit_vertex', { featureId: 'f1' })
+  expect(manager.changeMode).toHaveBeenCalledWith('edit_vertex', { featureId: 'f1', mapProvider })
+})
+
+test('done and cancel clear the undo stack before delegating', () => {
+  const { manager, adapter } = setup()
+  adapter.done()
+  adapter.cancel()
+  expect(manager.undoStack.clear).toHaveBeenCalledTimes(2)
+  expect(manager.done).toHaveBeenCalled()
+  expect(manager.cancel).toHaveBeenCalled()
+})
+
+test('snap state is tracked locally and forwarded, tolerating a missing snap manager', () => {
+  const { manager, adapter } = setup()
+  expect(adapter.isSnapEnabled()).toBe(false)
+  adapter.setSnapEnabled(true)
+  expect(adapter.isSnapEnabled()).toBe(true)
+  expect(manager.snap.setActive).toHaveBeenCalledWith(true)
+  adapter.setSnapLayers(['x'])
+  expect(manager.snap.setSnapLayers).toHaveBeenCalledWith(['x'])
+
+  // The shared sentinel translates onto the draw plugin's own VectorLayer instance.
+  adapter.setSnapLayers([DRAW_OUTLINE_STYLE_LAYER, 'x'])
+  expect(manager.snap.setSnapLayers).toHaveBeenCalledWith([fakeVectorLayer, 'x'])
+
+  manager.snap = null
+  adapter.setSnapEnabled(false)
+  adapter.setSnapLayers(['y']) // no throw
+  expect(adapter.isSnapEnabled()).toBe(false)
+})
+
+test('remaining calls delegate straight through; setFeatureProperty is a deliberate no-op', () => {
+  const { manager, adapter } = setup()
+  adapter.setInterfaceType('touch')
+  expect(adapter.get('f1')).toBe('feature')
+  adapter.add({ id: 'f2' })
+  adapter.delete('f1')
+  adapter.deleteAll()
+  adapter.undo()
+  adapter.deleteVertex()
+  adapter.nudgeSelectedVertex(1, 0, true)
+  const handler = () => {}
+  adapter.on('create', handler)
+  adapter.off('create', handler)
+  expect(adapter.setFeatureProperty('f1', 'stroke', '#000')).toBeUndefined()
+  adapter.setDrawingPreviewProperty('splitter', 'valid')
+  expect(manager.setDrawingPreviewProperty).toHaveBeenCalledWith('splitter', 'valid')
+  expect(manager.setInterfaceType).toHaveBeenCalledWith('touch')
+  expect(manager.on).toHaveBeenCalledWith('create', handler)
+  expect(manager.off).toHaveBeenCalledWith('create', handler)
+  expect(manager.undo).toHaveBeenCalled()
+  expect(manager.deleteVertex).toHaveBeenCalled()
+  expect(manager.nudgeSelectedVertex).toHaveBeenCalledWith(1, 0, true)
+})
+
+test('setGeometryValid records validity on the manager for finish gating', () => {
+  const { adapter, manager } = setup()
+  adapter.setGeometryValid(false)
+  expect(manager._geometryValid).toBe(false)
+})
+
+test('_geometryValidator accessor stores and retrieves the user callback on the manager', () => {
+  const { adapter, manager } = setup()
+  const validator = jest.fn(() => ({ valid: true }))
+  adapter._geometryValidator = validator
+  expect(manager._geometryValidator).toBe(validator)
+  expect(adapter._geometryValidator).toBe(validator)
+})
+
+test('setInvalid delegates to the manager to toggle the dashed stroke', () => {
+  const { adapter, manager } = setup()
+  adapter.setInvalid(true)
+  expect(manager.setInvalid).toHaveBeenCalledWith(true)
+})
+
+test('remove runs the olDraw cleanup', () => {
+  const { adapter } = setup()
+  adapter.remove()
+  expect(createOLDraw.mock.results.at(-1).value.remove).toHaveBeenCalled()
+})