@defra/interactive-map 0.0.36-alpha → 0.0.38-alpha

package/plugins/draw/src/adapters/maplibre/snap/prototypePatches.js

@@ -0,0 +1,148 @@
+import MapboxSnap from 'mapbox-gl-snap/dist/esm/MapboxSnap.js'
+import { polygon, lineString } from '@turf/helpers'
+import { TOLERANCES } from '../defaults.js'
+import { SNAP_HELPER_LAYER } from './constants.js'
+
+const MAX_SNAP_FEATURE_CACHE = 100
+
+// Skip setMapData/drawingSnapCheck when disabled; ensure layer visibility when enabled
+function patchDataMethods (proto, orig) {
+  proto.setMapData = function (data) {
+    if (!this.status) {
+      return undefined
+    }
+    const result = orig.setMapData.call(this, data)
+    if (data?.features?.length > 0 && this.map?.getLayer(SNAP_HELPER_LAYER)) {
+      this.map.setLayoutProperty(SNAP_HELPER_LAYER, 'visibility', 'visible')
+    }
+    return result
+  }
+
+  // Skip drawingSnapCheck when disabled
+  proto.drawingSnapCheck = function () {
+    if (!this.status) {
+      return undefined
+    }
+    return orig.drawingSnapCheck.call(this)
+  }
+}
+
+// Fix typo ('coodinates') and validate coordinates; query within a radius bbox
+function patchGeometryMethods (proto, orig) {
+  proto.getLines = function (feature, mouse, radiusArg) {
+    const geom = feature.geometry
+    if (!geom?.coordinates) {
+      return []
+    }
+    const coords = geom.coordinates
+    // Validate that we have actual coordinate arrays
+    if (!Array.isArray(coords) || coords.length === 0) {
+      return []
+    }
+    try {
+      if (geom.type === 'MultiPolygon') {
+        return coords.filter(c => Array.isArray(c) && c.length > 0).map(c => polygon(c))
+      }
+      if (geom.type === 'MultiLineString') {
+        return coords.filter(c => Array.isArray(c) && c.length > 0).map(c => lineString(c))
+      }
+      return orig.getLines.call(this, feature, mouse, radiusArg)
+    } catch {
+      // Invalid geometry - skip this feature
+      return []
+    }
+  }
+
+  // Query within radius bbox instead of just point, filter to existing layers
+  proto.getCloseFeatures = function (e, radiusInMeters) {
+    if (!this.status) {
+      return []
+    }
+    // Use active layers (per-call override) or fall back to default layers
+    const activeLayers = this._activeLayers || this._defaultLayers || []
+    this.options.layers = activeLayers.filter(l => this.map.getLayer(l))
+    const r = this.options.radius || TOLERANCES.snapRadius
+    const origPt = e.point
+    e.point = [[origPt.x - r, origPt.y - r], [origPt.x + r, origPt.y + r]]
+    const result = orig.getCloseFeatures.call(this, e, radiusInMeters)
+    e.point = origPt
+    return result
+  }
+}
+
+// Custom colors for snap indicators
+function patchColorMethods (proto, orig, colors) {
+  proto.searchInVertex = function (...args) {
+    const r = orig.searchInVertex.apply(this, args)
+    if (r) {
+      r.color = colors.vertex
+    }
+    return r
+  }
+  proto.searchInMidPoint = function (...args) {
+    const r = orig.searchInMidPoint.apply(this, args)
+    if (r) {
+      r.color = colors.midpoint
+    }
+    return r
+  }
+  proto.searchInEdge = function (...args) {
+    const r = orig.searchInEdge.apply(this, args)
+    if (r) {
+      r.color = colors.edge
+    }
+    return r
+  }
+}
+
+// Skip when disabled or zooming; clean up internal arrays to prevent memory accumulation
+function patchSnapMethod (proto, orig) {
+  proto.snapToClosestPoint = function (e) {
+    if (!this.status || this.map?._isZooming) {
+      return undefined
+    }
+    try {
+      const result = orig.snapToClosestPoint.call(this, e)
+      if (this.closeFeatures?.length > MAX_SNAP_FEATURE_CACHE) {
+        this.closeFeatures.length = 0
+      }
+      if (this.lines?.length > MAX_SNAP_FEATURE_CACHE) {
+        this.lines.length = 0
+      }
+      return result
+    } catch {
+      // Invalid geometry encountered - clear state and continue
+      this.snapStatus = false
+      this.snapCoords = null
+      return undefined
+    }
+  }
+}
+
+/** Apply patches to MapboxSnap prototype (once only) */
+export function applyMapboxSnapPatches (colors) {
+  if (MapboxSnap.prototype.__snapPatched) {
+    return
+  }
+  MapboxSnap.prototype.__snapPatched = true
+
+  const proto = MapboxSnap.prototype
+  const orig = {
+    setMapData: proto.setMapData,
+    drawingSnapCheck: proto.drawingSnapCheck,
+    getLines: proto.getLines,
+    getCloseFeatures: proto.getCloseFeatures,
+    searchInVertex: proto.searchInVertex,
+    searchInMidPoint: proto.searchInMidPoint,
+    searchInEdge: proto.searchInEdge,
+    snapToClosestPoint: proto.snapToClosestPoint
+  }
+
+  // Disable changeSnappedPoints - we handle snap ourselves in drag handlers
+  proto.changeSnappedPoints = () => {}
+
+  patchDataMethods(proto, orig)
+  patchGeometryMethods(proto, orig)
+  patchColorMethods(proto, orig, colors)
+  patchSnapMethod(proto, orig)
+}

package/plugins/draw/src/adapters/maplibre/snap/prototypePatches.test.js

@@ -0,0 +1,238 @@
+import MapboxSnap from 'mapbox-gl-snap/dist/esm/MapboxSnap.js'
+import { polygon, lineString } from '@turf/helpers'
+import { applyMapboxSnapPatches } from './prototypePatches.js'
+
+const SNAP_LAYER = 'snap-helper-circle'
+const COLORS = { vertex: 'colour-v', midpoint: 'colour-m', edge: 'colour-e' }
+
+jest.mock('mapbox-gl-snap/dist/esm/MapboxSnap.js', () => {
+  const orig = {
+    setMapData: jest.fn(function () { return 'orig-setMapData' }),
+    drawingSnapCheck: jest.fn(function () { return 'orig-drawingSnapCheck' }),
+    getLines: jest.fn(function () { return 'orig-getLines' }),
+    getCloseFeatures: jest.fn(function () { return 'orig-getCloseFeatures' }),
+    searchInVertex: jest.fn(function () { return { id: 'v' } }),
+    searchInMidPoint: jest.fn(function () { return { id: 'm' } }),
+    searchInEdge: jest.fn(function () { return { id: 'e' } }),
+    snapToClosestPoint: jest.fn(function () { return 'orig-snap' })
+  }
+  const MockSnap = jest.fn()
+  Object.assign(MockSnap.prototype, orig)
+  MockSnap.__orig = orig
+  return { __esModule: true, default: MockSnap }
+})
+
+jest.mock('@turf/helpers', () => ({
+  polygon: jest.fn((c) => ({ poly: c })),
+  lineString: jest.fn((c) => ({ line: c }))
+}))
+
+jest.mock('../defaults.js', () => ({ TOLERANCES: { snapRadius: 12 } }))
+
+beforeAll(() => {
+  applyMapboxSnapPatches(COLORS)
+})
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('applyMapboxSnapPatches', () => {
+  test('patches the prototype only once', () => {
+    const patched = MapboxSnap.prototype.setMapData
+    applyMapboxSnapPatches(COLORS)
+    expect(MapboxSnap.prototype.setMapData).toBe(patched)
+  })
+
+  test('replaces changeSnappedPoints with a no-op', () => {
+    expect(MapboxSnap.prototype.changeSnappedPoints()).toBeUndefined()
+  })
+})
+
+describe('setMapData', () => {
+  test('returns undefined and skips the original when disabled', () => {
+    expect(MapboxSnap.prototype.setMapData.call({ status: false }, {})).toBeUndefined()
+    expect(MapboxSnap.__orig.setMapData).not.toHaveBeenCalled()
+  })
+
+  test('delegates and shows the layer when features exist and the layer is present', () => {
+    const map = { getLayer: jest.fn(() => ({})), setLayoutProperty: jest.fn() }
+    const data = { features: [{}] }
+
+    const result = MapboxSnap.prototype.setMapData.call({ status: true, map }, data)
+
+    expect(MapboxSnap.__orig.setMapData).toHaveBeenCalledWith(data)
+    expect(result).toBe('orig-setMapData')
+    expect(map.setLayoutProperty).toHaveBeenCalledWith(SNAP_LAYER, 'visibility', 'visible')
+  })
+
+  test('does not show the layer when there are no features', () => {
+    const map = { getLayer: jest.fn(() => ({})), setLayoutProperty: jest.fn() }
+    MapboxSnap.prototype.setMapData.call({ status: true, map }, { features: [] })
+    expect(map.setLayoutProperty).not.toHaveBeenCalled()
+  })
+
+  test('does not show the layer when it is absent', () => {
+    const map = { getLayer: jest.fn(() => null), setLayoutProperty: jest.fn() }
+    MapboxSnap.prototype.setMapData.call({ status: true, map }, { features: [{}] })
+    expect(map.setLayoutProperty).not.toHaveBeenCalled()
+  })
+
+  test('tolerates a missing map and missing data', () => {
+    expect(MapboxSnap.prototype.setMapData.call({ status: true }, { features: [{}] })).toBe('orig-setMapData')
+    expect(MapboxSnap.prototype.setMapData.call({ status: true }, undefined)).toBe('orig-setMapData')
+  })
+})
+
+describe('drawingSnapCheck', () => {
+  test('returns undefined when disabled', () => {
+    expect(MapboxSnap.prototype.drawingSnapCheck.call({ status: false })).toBeUndefined()
+  })
+
+  test('delegates to the original when enabled', () => {
+    expect(MapboxSnap.prototype.drawingSnapCheck.call({ status: true })).toBe('orig-drawingSnapCheck')
+    expect(MapboxSnap.__orig.drawingSnapCheck).toHaveBeenCalled()
+  })
+})
+
+describe('getLines', () => {
+  const call = (self, feature) => MapboxSnap.prototype.getLines.call(self, feature, 'mouse', 5)
+
+  test('returns [] when geometry or coordinates are missing', () => {
+    expect(call({}, { geometry: null })).toEqual([])
+    expect(call({}, { geometry: {} })).toEqual([])
+  })
+
+  test('returns [] when coordinates are not a non-empty array', () => {
+    expect(call({}, { geometry: { coordinates: 'x' } })).toEqual([])
+    expect(call({}, { geometry: { coordinates: [] } })).toEqual([])
+  })
+
+  test('maps MultiPolygon coordinates via turf polygon, filtering empties', () => {
+    const feature = { geometry: { type: 'MultiPolygon', coordinates: [[[[0, 0]]], []] } }
+    expect(call({}, feature)).toEqual([{ poly: [[[0, 0]]] }])
+    expect(polygon).toHaveBeenCalledWith([[[0, 0]]])
+  })
+
+  test('maps MultiLineString coordinates via turf lineString', () => {
+    const feature = { geometry: { type: 'MultiLineString', coordinates: [[[0, 0], [1, 1]]] } }
+    expect(call({}, feature)).toEqual([{ line: [[0, 0], [1, 1]] }])
+    expect(lineString).toHaveBeenCalledWith([[0, 0], [1, 1]])
+  })
+
+  test('delegates other geometry types to the original', () => {
+    const feature = { geometry: { type: 'Polygon', coordinates: [[0, 0]] } }
+    expect(call({}, feature)).toBe('orig-getLines')
+    expect(MapboxSnap.__orig.getLines).toHaveBeenCalledWith(feature, 'mouse', 5)
+  })
+
+  test('returns [] when turf throws on invalid geometry', () => {
+    polygon.mockImplementationOnce(() => { throw new Error('bad') })
+    const feature = { geometry: { type: 'MultiPolygon', coordinates: [[[[0, 0]]]] } }
+    expect(call({}, feature)).toEqual([])
+  })
+})
+
+describe('getCloseFeatures', () => {
+  test('returns [] when disabled', () => {
+    expect(MapboxSnap.prototype.getCloseFeatures.call({ status: false }, {}, 1)).toEqual([])
+  })
+
+  test('expands the query to a radius bbox and restores the point', () => {
+    const map = { getLayer: jest.fn((l) => l === 'layerA') }
+    const self = { status: true, map, _activeLayers: ['layerA', 'missing'], options: { radius: 10 } }
+    const e = { point: { x: 100, y: 200 } }
+
+    MapboxSnap.__orig.getCloseFeatures.mockImplementationOnce(function (ev) {
+      expect(ev.point).toEqual([[90, 190], [110, 210]])
+      return 'orig-getCloseFeatures'
+    })
+
+    const result = MapboxSnap.prototype.getCloseFeatures.call(self, e, 3)
+
+    expect(self.options.layers).toEqual(['layerA'])
+    expect(e.point).toEqual({ x: 100, y: 200 })
+    expect(result).toBe('orig-getCloseFeatures')
+  })
+
+  test('falls back to default layers and the configured radius', () => {
+    const map = { getLayer: jest.fn(() => true) }
+    const self = { status: true, map, _activeLayers: null, _defaultLayers: ['b'], options: {} }
+    const e = { point: { x: 0, y: 0 } }
+
+    MapboxSnap.__orig.getCloseFeatures.mockImplementationOnce(function (ev) {
+      expect(ev.point).toEqual([[-12, -12], [12, 12]])
+      return []
+    })
+
+    MapboxSnap.prototype.getCloseFeatures.call(self, e, 1)
+    expect(self.options.layers).toEqual(['b'])
+  })
+
+  test('handles a completely missing layer configuration', () => {
+    const map = { getLayer: jest.fn(() => true) }
+    const self = { status: true, map, options: {} }
+    const e = { point: { x: 0, y: 0 } }
+
+    MapboxSnap.prototype.getCloseFeatures.call(self, e, 1)
+    expect(self.options.layers).toEqual([])
+  })
+})
+
+describe('colour methods', () => {
+  test('searchInVertex tints the result and passes through falsy results', () => {
+    expect(MapboxSnap.prototype.searchInVertex.call({}).color).toBe(COLORS.vertex)
+    MapboxSnap.__orig.searchInVertex.mockReturnValueOnce(null)
+    expect(MapboxSnap.prototype.searchInVertex.call({})).toBeNull()
+  })
+
+  test('searchInMidPoint tints the result and passes through falsy results', () => {
+    expect(MapboxSnap.prototype.searchInMidPoint.call({}).color).toBe(COLORS.midpoint)
+    MapboxSnap.__orig.searchInMidPoint.mockReturnValueOnce(null)
+    expect(MapboxSnap.prototype.searchInMidPoint.call({})).toBeNull()
+  })
+
+  test('searchInEdge tints the result and passes through falsy results', () => {
+    expect(MapboxSnap.prototype.searchInEdge.call({}).color).toBe(COLORS.edge)
+    MapboxSnap.__orig.searchInEdge.mockReturnValueOnce(null)
+    expect(MapboxSnap.prototype.searchInEdge.call({})).toBeNull()
+  })
+})
+
+describe('snapToClosestPoint', () => {
+  test('skips and returns undefined when disabled', () => {
+    expect(MapboxSnap.prototype.snapToClosestPoint.call({ status: false })).toBeUndefined()
+    expect(MapboxSnap.__orig.snapToClosestPoint).not.toHaveBeenCalled()
+  })
+
+  test('skips while the map is zooming', () => {
+    expect(MapboxSnap.prototype.snapToClosestPoint.call({ status: true, map: { _isZooming: true } }, {})).toBeUndefined()
+  })
+
+  test('delegates and trims oversized caches', () => {
+    const self = { status: true, map: {}, closeFeatures: new Array(101), lines: new Array(101) }
+    expect(MapboxSnap.prototype.snapToClosestPoint.call(self, {})).toBe('orig-snap')
+    expect(self.closeFeatures).toHaveLength(0)
+    expect(self.lines).toHaveLength(0)
+  })
+
+  test('leaves small caches intact', () => {
+    const self = { status: true, map: {}, closeFeatures: [1], lines: [2] }
+    MapboxSnap.prototype.snapToClosestPoint.call(self, {})
+    expect(self.closeFeatures).toHaveLength(1)
+    expect(self.lines).toHaveLength(1)
+  })
+
+  test('tolerates absent caches and a missing map', () => {
+    expect(MapboxSnap.prototype.snapToClosestPoint.call({ status: true }, {})).toBe('orig-snap')
+  })
+
+  test('clears snap state when the original throws', () => {
+    MapboxSnap.__orig.snapToClosestPoint.mockImplementationOnce(() => { throw new Error('x') })
+    const self = { status: true, map: {}, snapStatus: true, snapCoords: [1, 2] }
+
+    expect(MapboxSnap.prototype.snapToClosestPoint.call(self, {})).toBeUndefined()
+    expect(self.snapStatus).toBe(false)
+    expect(self.snapCoords).toBeNull()
+  })
+})

package/plugins/draw/src/adapters/maplibre/snap/snapInstance.js

@@ -0,0 +1,115 @@
+import MapboxSnap from 'mapbox-gl-snap/dist/esm/MapboxSnap.js'
+import { patchSourceData } from './sourceData.js'
+import { SNAP_HELPER_LAYER } from './constants.js'
+
+/** Remove any stale snap helper source/layer before creating a new instance */
+function cleanupOldSnap (map) {
+  if (map.getLayer(SNAP_HELPER_LAYER)) {
+    map.removeLayer(SNAP_HELPER_LAYER)
+  }
+  if (map.getSource(SNAP_HELPER_LAYER)) {
+    map.removeSource(SNAP_HELPER_LAYER)
+  }
+}
+
+// Snap indicators (and all snap processing) are only meaningful while actively
+// drawing or editing vertices — outside these modes there is nothing to snap to.
+const SNAP_ACTIVE_MODES = new Set(['draw_polygon', 'draw_line', 'edit_vertex'])
+
+/**
+ * Externally-controlled status: ignore library writes so status is only changed
+ * via setSnapStatus(). The library otherwise sets status=true on mode/selection change.
+ *
+ * Also gated on the current draw mode: the library's own mousemove listener
+ * (added once in its constructor) calls snapToClosestPoint on every mouse move
+ * regardless of draw mode, repainting the snap-helper-circle layer whenever
+ * status is true. Without this gate, the marker reappears on the very next
+ * mouse move after leaving draw/edit mode, since mapbox-gl-draw's public
+ * changeMode API is silent by default and rarely gives us a mode-change event
+ * to react to.
+ */
+function defineControlledStatus (snap, initialStatus, draw) {
+  let controlledStatus = initialStatus
+
+  Object.defineProperty(snap, 'status', {
+    get () { // nosonar
+      return controlledStatus && SNAP_ACTIVE_MODES.has(draw.getMode())
+    },
+    set () { // nosonar
+      // intentionally empty: library writes are ignored
+    },
+    configurable: true
+  })
+
+  snap.setSnapStatus = (value) => {
+    controlledStatus = value
+  }
+}
+
+/** Store default snap layers and expose a per-call override setter (null resets) */
+function configureSnapLayers (snap, layers) {
+  snap._defaultLayers = layers
+  snap._activeLayers = null
+
+  snap.setSnapLayers = (overrideLayers) => {
+    if (overrideLayers === null || overrideLayers === undefined) {
+      snap._activeLayers = null // Use defaults
+    } else if (Array.isArray(overrideLayers)) {
+      snap._activeLayers = overrideLayers // Override defaults
+    } else {
+      // No action
+    }
+  }
+}
+
+/** Create the snap instance once the draw source is available */
+export function createSnapInstance (map, draw, source, config) {
+  // Prevent duplicate creation (race between initial poll and style.load)
+  if (map._snapInstance || map._snapCreating) {
+    return map._snapInstance
+  }
+
+  map._snapCreating = true
+  cleanupOldSnap(map)
+  patchSourceData(source)
+
+  /** @type {any} */
+  const snap = new MapboxSnap({
+    map,
+    drawing: draw,
+    options: { layers: config.layers, radius: config.radius, rules: config.rules },
+    status: config.status,
+    onSnapped: config.onSnapped
+  })
+
+  defineControlledStatus(snap, config.status, draw)
+  configureSnapLayers(snap, config.layers)
+
+  // Apply any pending snap layers that were set before the instance was ready
+  if (map._pendingSnapLayers !== undefined) {
+    snap.setSnapLayers(map._pendingSnapLayers)
+    delete map._pendingSnapLayers
+  }
+
+  map._snapInstance = snap
+  return snap
+}
+
+/** Ensure the snap helper source and layer exist after a style change */
+export function ensureSnapLayer (map) {
+  if (!map.getSource(SNAP_HELPER_LAYER)) {
+    map.addSource(SNAP_HELPER_LAYER, {
+      type: 'geojson',
+      data: { type: 'FeatureCollection', features: [] }
+    })
+  }
+  if (!map.getLayer(SNAP_HELPER_LAYER)) {
+    map.addLayer({
+      id: SNAP_HELPER_LAYER,
+      type: 'fill',
+      source: SNAP_HELPER_LAYER,
+      paint: { 'fill-color': ['get', 'color'] },
+      layout: { visibility: map._snapInstance?.status ? 'visible' : 'none' }
+    })
+  }
+}

package/plugins/draw/src/adapters/maplibre/snap/snapInstance.test.js

@@ -0,0 +1,151 @@
+import MapboxSnap from 'mapbox-gl-snap/dist/esm/MapboxSnap.js'
+import { patchSourceData } from './sourceData.js'
+import { createSnapInstance, ensureSnapLayer } from './snapInstance.js'
+
+const SNAP_LAYER = 'snap-helper-circle'
+
+jest.mock('mapbox-gl-snap/dist/esm/MapboxSnap.js', () => ({
+  __esModule: true,
+  default: jest.fn(function (opts) { Object.assign(this, opts) })
+}))
+
+jest.mock('./sourceData.js', () => ({ patchSourceData: jest.fn() }))
+
+const config = { layers: ['a'], radius: 12, rules: ['vertex'], status: false, onSnapped: () => {} }
+
+const makeMap = (overrides = {}) => ({
+  getLayer: jest.fn(() => null),
+  removeLayer: jest.fn(),
+  getSource: jest.fn(() => null),
+  removeSource: jest.fn(),
+  addSource: jest.fn(),
+  addLayer: jest.fn(),
+  ...overrides
+})
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('createSnapInstance', () => {
+  test('constructs the snap instance, patches the source and stores it on the map', () => {
+    const map = makeMap()
+    const draw = { id: 'draw' }
+    const source = { id: 'src' }
+
+    const snap = createSnapInstance(map, draw, source, config)
+
+    expect(patchSourceData).toHaveBeenCalledWith(source)
+    expect(MapboxSnap).toHaveBeenCalledWith({
+      map,
+      drawing: draw,
+      options: { layers: ['a'], radius: 12, rules: ['vertex'] },
+      status: false,
+      onSnapped: config.onSnapped
+    })
+    expect(map._snapInstance).toBe(snap)
+  })
+
+  test('returns the existing instance without recreating', () => {
+    const map = makeMap({ _snapInstance: { id: 'existing' } })
+    expect(createSnapInstance(map, {}, {}, config)).toEqual({ id: 'existing' })
+    expect(MapboxSnap).not.toHaveBeenCalled()
+  })
+
+  test('bails out while another creation is in progress', () => {
+    const map = makeMap({ _snapCreating: true })
+    createSnapInstance(map, {}, {}, config)
+    expect(MapboxSnap).not.toHaveBeenCalled()
+  })
+
+  test('removes a stale snap layer and source before creating', () => {
+    const map = makeMap({ getLayer: jest.fn(() => ({})), getSource: jest.fn(() => ({})) })
+    createSnapInstance(map, {}, {}, config)
+    expect(map.removeLayer).toHaveBeenCalledWith(SNAP_LAYER)
+    expect(map.removeSource).toHaveBeenCalledWith(SNAP_LAYER)
+  })
+
+  test('exposes an externally-controlled status via setSnapStatus', () => {
+    const map = makeMap()
+    const draw = { getMode: jest.fn(() => 'draw_polygon') }
+    const snap = createSnapInstance(map, draw, {}, { ...config, status: false })
+
+    expect(snap.status).toBe(false)
+    snap.status = true // library write ignored
+    expect(snap.status).toBe(false)
+    snap.setSnapStatus(true)
+    expect(snap.status).toBe(true)
+  })
+
+  test('status is false outside draw/edit modes even when the toggle is on', () => {
+    const map = makeMap()
+    const draw = { getMode: jest.fn(() => 'simple_select') }
+    const snap = createSnapInstance(map, draw, {}, { ...config, status: false })
+
+    snap.setSnapStatus(true)
+    expect(snap.status).toBe(false)
+
+    draw.getMode.mockReturnValue('edit_vertex')
+    expect(snap.status).toBe(true)
+  })
+
+  test('setSnapLayers overrides, resets and ignores invalid input', () => {
+    const map = makeMap()
+    const snap = createSnapInstance(map, {}, {}, { ...config, layers: ['a'] })
+
+    expect(snap._defaultLayers).toEqual(['a'])
+    expect(snap._activeLayers).toBeNull()
+
+    snap.setSnapLayers(['b', 'c'])
+    expect(snap._activeLayers).toEqual(['b', 'c'])
+
+    snap.setSnapLayers(null)
+    expect(snap._activeLayers).toBeNull()
+
+    snap.setSnapLayers(['d'])
+    snap.setSnapLayers(undefined)
+    expect(snap._activeLayers).toBeNull()
+
+    snap.setSnapLayers(['x'])
+    snap.setSnapLayers('not-an-array') // no action
+    expect(snap._activeLayers).toEqual(['x'])
+  })
+
+  test('applies pending snap layers set before the instance was ready', () => {
+    const map = makeMap({ _pendingSnapLayers: ['pending'] })
+    const snap = createSnapInstance(map, {}, {}, { ...config, layers: ['default'] })
+
+    expect(snap._activeLayers).toEqual(['pending'])
+    expect(map._pendingSnapLayers).toBeUndefined()
+  })
+})
+
+describe('ensureSnapLayer', () => {
+  test('adds the missing source and layer (hidden when snapping is disabled)', () => {
+    const map = makeMap()
+    ensureSnapLayer(map)
+
+    expect(map.addSource).toHaveBeenCalledWith(SNAP_LAYER, expect.objectContaining({ type: 'geojson' }))
+    expect(map.addLayer).toHaveBeenCalledWith(expect.objectContaining({
+      id: SNAP_LAYER,
+      layout: { visibility: 'none' }
+    }))
+  })
+
+  test('shows the layer when snapping is active', () => {
+    const map = makeMap({ _snapInstance: { status: true } })
+    ensureSnapLayer(map)
+
+    expect(map.addLayer).toHaveBeenCalledWith(expect.objectContaining({
+      layout: { visibility: 'visible' }
+    }))
+  })
+
+  test('does not re-add an existing source or layer', () => {
+    const map = makeMap({ getSource: jest.fn(() => ({})), getLayer: jest.fn(() => ({})) })
+    ensureSnapLayer(map)
+
+    expect(map.addSource).not.toHaveBeenCalled()
+    expect(map.addLayer).not.toHaveBeenCalled()
+  })
+})

package/plugins/draw/src/adapters/maplibre/snap/sourceData.js

@@ -0,0 +1,34 @@
+/**
+ * Poll until checkFn returns truthy, then call onSuccess with the result.
+ * A `null` result signals to stop polling; any other falsy value keeps polling.
+ */
+export function pollUntil (checkFn, onSuccess) {
+  (function poll () {
+    const result = checkFn()
+    if (result === null) {
+      return
+    }
+    result ? onSuccess(result) : requestAnimationFrame(poll)
+  })()
+}
+
+/**
+ * Patch a GeoJSON source to expose _data for MapboxSnap compatibility.
+ * MapboxSnap expects source._data.features but MapLibre doesn't expose this.
+ */
+export function patchSourceData (source) {
+  if (!source || (source._data && Array.isArray(source._data?.features))) {
+    return
+  }
+
+  let dataCache = { type: 'FeatureCollection', features: [] }
+  Object.defineProperty(source, '_data', {
+    get: () => dataCache,
+    set: (val) => {
+      dataCache = (val && typeof val === 'object' && Array.isArray(val.features))
+        ? val
+        : { type: 'FeatureCollection', features: [] }
+    },
+    configurable: true
+  })
+}