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

package/plugins/draw/src/adapters/maplibre/modes/editVertexMode.test.js

@@ -16,8 +16,9 @@ describe('onSetup / onStop lifecycle', () => {
     expect(state.midpoints).toHaveLength(4)
     expect(map._lastEditFeatureId).toBe('feat-1')
     expect(map._drawEditContainer).toBe(state.container)
+    // draw.update is edit_vertex's own extra listener on top of the shared set (covered by
+    // editModeEvents.test.js).
     expect(ctx.map.on).toHaveBeenCalledWith('draw.update', expect.any(Function))
-    expect(ctx.map.on).toHaveBeenCalledWith('draw.nudgevertex', expect.any(Function))
   })
 
   test('does not clear the undo stack when re-entering the same feature', () => {
@@ -28,13 +29,14 @@ describe('onSetup / onStop lifecycle', () => {
     expect(map._undoStack.length).toBe(1)
   })
 
-  test('onStop removes listeners and clears editing container; DirectSelect touch stubs are inert', () => {
+  // Shared listener teardown is covered by editModeEvents.test.js; draw.update is edit_vertex's
+  // own extra listener.
+  test('onStop removes the draw.update listener and clears editing container; DirectSelect touch stubs are inert', () => {
     const { ctx, state, map } = createHarness()
     expect(() => { ctx.onTouchStart(); ctx.onTouchMove(); ctx.onTouchEnd() }).not.toThrow()
     ctx.onStop(state)
     expect(map._drawEditContainer).toBeNull()
     expect(map.off).toHaveBeenCalledWith('draw.update', expect.any(Function))
-    expect(map.off).toHaveBeenCalledWith('draw.nudgevertex', expect.any(Function))
   })
 
   test('onSetup edge cases: clears an active snap indicator, positions or skips the touch target, clears an explicit -1 selection', () => {
@@ -110,6 +112,11 @@ describe('selection, scale and update events', () => {
     expect({ top: state.touchVertexTarget.style.top, left: state.touchVertexTarget.style.left }).not.toEqual(targetBefore)
   })
 
+  test('draw.nudgevertex with no vertex selected moves nothing and skips repositioning the touch target', () => {
+    const { map } = createHarness(POLYGON(), { interfaceType: 'touch', selectedVertexIndex: -1 })
+    expect(() => map.fire('draw.nudgevertex', { dx: 1, dy: 0, isLargeStep: false })).not.toThrow()
+  })
+
   test('onUpdate re-selects a changed vertex only when the vertex count is ambiguous', () => {
     const { ctx, state } = createHarness()
     ctx.onUpdate(state) // unique coords → no change

package/plugins/draw/src/adapters/maplibre/pointSymbolImages.js

@@ -0,0 +1,158 @@
+import { symbolRegistry } from '../../../../../src/services/symbolRegistry.js'
+import { getSymbolAnchor, getSymbolViewBox } from '../../../../../src/utils/symbolUtils.js'
+import { anchorToMaplibre, anchorToMaplibreOffset } from '../../../../../providers/maplibre/src/utils/symbolImages.js'
+
+/**
+ * Resolves and registers a drawn point's symbol-config icon (same schema as addMarker/dataset
+ * points — see src/config/symbolConfig.js), writing the resolved image id/anchor back onto
+ * the feature so styles.js's pointSymbol() layer can render it. icon-offset is handled
+ * separately below since it can't safely be a per-feature property.
+ */
+
+export const hasSymbolStyle = (properties) => !!(properties?.symbol || properties?.symbolSvgContent)
+
+const POINT_SYMBOL_LAYER_ID = 'point-symbol'
+
+// icon-offset can't be a raw per-feature `get` on an array property — MapLibre's GeoJSON
+// sources silently JSON.stringify arrays, so it reads back a string at render time. Instead
+// each symbolImageId's offset is folded into a `match` expression keyed on that (safe, string) property.
+const buildIconOffsetExpression = (offsetsByImageId) => {
+  const expression = ['match', ['get', 'user_symbolImageId']]
+  for (const [imageId, offset] of Object.entries(offsetsByImageId)) {
+    expression.push(imageId, ['literal', offset])
+  }
+  expression.push(['literal', [0, 0]]) // fallback for any id not yet registered
+  return expression
+}
+
+const registerSymbolIconOffset = (map, symbolImageId, offset) => {
+  map._symbolIconOffsetMap ??= {}
+  if (map._symbolIconOffsetMap[symbolImageId]) {
+    return // offset is deterministic per id — already registered, nothing changed
+  }
+  map._symbolIconOffsetMap[symbolImageId] = offset
+  const expression = buildIconOffsetExpression(map._symbolIconOffsetMap)
+  ;['hot', 'cold'].forEach((suffix) => {
+    const layerId = `${POINT_SYMBOL_LAYER_ID}.${suffix}`
+    if (map.getLayer(layerId)) {
+      map.setLayoutProperty(layerId, 'icon-offset', expression)
+    }
+  })
+}
+
+// map.getPixelRatio() is only set once at map construction, so it won't reflect a later
+// map-size change on its own. Callers reacting to MAP_SET_PIXEL_RATIO should pass the fresh
+// value through as pixelRatioOverride instead.
+export const getPixelRatio = (map) => map.getPixelRatio?.() || 1
+
+// Does the async work for one point without touching the store — draw.add() is left to the
+// caller so refreshAllPointSymbols can batch every point into one call (see its comment why).
+// Returns null if there's nothing to write back (no symbol config, feature gone, or unresolvable id).
+const resolvePointSymbolFeature = async ({ draw, mapProvider, map, featureId, properties, pixelRatioOverride }) => {
+  if (!hasSymbolStyle(properties)) {
+    return null
+  }
+
+  const mapStyle = map._drawCurrentMapStyle
+  const pixelRatio = pixelRatioOverride ?? getPixelRatio(map)
+
+  await mapProvider.addSymbolsToMap([properties], mapStyle, symbolRegistry)
+
+  const feature = draw.get(featureId)
+  if (!feature) {
+    return null
+  }
+
+  const symbolImageId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, pixelRatio)
+  if (!symbolImageId) {
+    return null
+  }
+  // addSymbolsToMap() (just awaited above) already mapped this id's active/selected variants
+  // into map._activeSymbolImageMap/_selectedSymbolImageMap — read them back so the highlight
+  // ring (highlightFeatures.js) can reference each point's own precomputed variant directly.
+  const symbolActiveImageId = map._activeSymbolImageMap?.[symbolImageId] ?? null
+  const symbolSelectedImageId = map._selectedSymbolImageMap?.[symbolImageId] ?? null
+  const symbolDef = symbolRegistry.getSymbolDef(properties)
+  const rawAnchor = getSymbolAnchor(properties, symbolDef)
+  const anchor = anchorToMaplibre(rawAnchor)
+  // icon-anchor only has 9 discrete positions, so an off-grid anchor (e.g. pin's [0.5, 0.9])
+  // loses precision snapping to the nearest one — icon-offset corrects that gap.
+  const offset = anchorToMaplibreOffset(rawAnchor, getSymbolViewBox(properties, symbolDef))
+  registerSymbolIconOffset(map, symbolImageId, offset)
+
+  return {
+    ...feature,
+    properties: {
+      ...properties,
+      symbolImageId,
+      symbolIconAnchor: anchor,
+      symbolActiveImageId,
+      symbolSelectedImageId
+    }
+  }
+}
+
+/**
+ * Resolve one point feature's symbol image and write it back onto the feature.
+ * A no-op for points with no symbol config (nothing to render as an icon).
+ *
+ * @param {Object} params
+ * @param {Object} params.draw - the raw MapboxDraw instance (needs get/add)
+ * @param {Object} params.mapProvider - MapLibreProvider (needs addSymbolsToMap)
+ * @param {Object} params.map - MapLibre map instance (needs _drawCurrentMapStyle, getPixelRatio)
+ * @param {string} params.featureId
+ * @param {Object} params.properties - the point feature's current properties
+ * @param {number} [params.pixelRatioOverride] - use this instead of map.getPixelRatio(), for
+ *   callers (map-size refresh) that already know the freshly computed value
+ * @returns {Promise<void>}
+ */
+export const resolvePointSymbol = async (params) => {
+  try {
+    const feature = await resolvePointSymbolFeature(params)
+    if (!feature) {
+      return
+    }
+    // draw.setFeatureProperty() only marks the feature dirty for mapbox-gl-draw's own mode-
+    // dispatch loop, which won't run again until the next interaction. draw.add() on an
+    // existing id updates its properties and renders unconditionally, so it's used instead.
+    params.draw.add(feature)
+  } catch (err) {
+    // A silent failure here means a point simply never gets/keeps an icon, with nothing in
+    // the UI to explain why — surface it instead of letting the rejection vanish.
+    console.error('[draw] failed to resolve point symbol', params.featureId, err) // NOSONAR
+  }
+}
+
+/**
+ * Re-resolve every existing drawn point's symbol — called on map style/pixel-ratio change,
+ * since the rasterised image (colours, and pixel-ratio-scaled dimensions) depends on both.
+ *
+ * @param {Object} params
+ * @param {Object} params.draw - the raw MapboxDraw instance (needs getAll)
+ * @param {Object} params.mapProvider
+ * @param {Object} params.map
+ * @param {number} [params.pixelRatioOverride] - see resolvePointSymbol
+ * @returns {Promise<void>}
+ */
+export const refreshAllPointSymbols = async ({ draw, mapProvider, map, pixelRatioOverride }) => {
+  const points = draw.getAll().features.filter(
+    (f) => f.geometry.type === 'Point' && hasSymbolStyle(f.properties)
+  )
+  const results = await Promise.allSettled(points.map((f) =>
+    resolvePointSymbolFeature({ draw, mapProvider, map, featureId: f.id, properties: f.properties, pixelRatioOverride })
+  ))
+
+  results.filter((r) => r.status === 'rejected').forEach((r) => {
+    console.error('[draw] failed to resolve point symbol', r.reason) // NOSONAR
+  })
+
+  // One combined draw.add() call triggers a single render. Adding one point at a time here
+  // would let mapbox-gl-draw's debounced render fire mid-batch, painting a not-yet-resolved
+  // point with its stale, now-unregistered image id ("Image X could not be loaded").
+  const features = results
+    .filter((r) => r.status === 'fulfilled' && r.value)
+    .map((r) => r.value)
+  if (features.length) {
+    draw.add({ type: 'FeatureCollection', features })
+  }
+}

package/plugins/draw/src/adapters/maplibre/pointSymbolImages.test.js

@@ -0,0 +1,314 @@
+import { hasSymbolStyle, getPixelRatio, resolvePointSymbol, refreshAllPointSymbols } from './pointSymbolImages.js'
+import { symbolRegistry } from '../../../../../src/services/symbolRegistry.js'
+
+const mapStyle = { id: 'outdoor', mapColorScheme: 'light' }
+
+const createMap = ({ pixelRatio = 2 } = {}) => ({
+  _drawCurrentMapStyle: mapStyle,
+  getPixelRatio: () => pixelRatio,
+  // point-symbol.hot/.cold — registerSymbolIconOffset() looks these up to reapply the
+  // icon-offset match expression whenever a new symbolImageId's offset is registered.
+  getLayer: jest.fn(() => true),
+  setLayoutProperty: jest.fn()
+})
+
+const createMapProvider = () => ({
+  addSymbolsToMap: jest.fn(() => Promise.resolve())
+})
+
+const createDraw = (features = []) => ({
+  get: jest.fn((id) => features.find((f) => f.id === id) ?? null),
+  add: jest.fn(),
+  getAll: jest.fn(() => ({ features }))
+})
+
+const point = (id, properties, coordinates = [1, 2]) =>
+  ({ id, type: 'Feature', geometry: { type: 'Point', coordinates }, properties })
+
+describe('hasSymbolStyle', () => {
+  it('is true when symbol is set', () => {
+    expect(hasSymbolStyle({ symbol: 'pin' })).toBe(true)
+  })
+
+  it('is true when symbolSvgContent is set', () => {
+    expect(hasSymbolStyle({ symbolSvgContent: '<path/>' })).toBe(true)
+  })
+
+  it('is false with neither, or no properties at all', () => {
+    expect(hasSymbolStyle({})).toBe(false)
+    expect(hasSymbolStyle(undefined)).toBe(false)
+  })
+})
+
+describe('getPixelRatio', () => {
+  it('reads map.getPixelRatio()', () => {
+    expect(getPixelRatio(createMap({ pixelRatio: 3 }))).toBe(3)
+  })
+
+  it('falls back to 1 when getPixelRatio is unavailable or falsy', () => {
+    expect(getPixelRatio({})).toBe(1)
+    expect(getPixelRatio({ getPixelRatio: () => 0 })).toBe(1)
+  })
+})
+
+describe('resolvePointSymbol', () => {
+  it('does nothing for a feature with no symbol config', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const draw = createDraw()
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties: {} })
+    expect(mapProvider.addSymbolsToMap).not.toHaveBeenCalled()
+    expect(draw.add).not.toHaveBeenCalled()
+  })
+
+  it('registers the symbol image and re-adds the feature with symbolImageId/symbolIconAnchor, forcing a render', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'pin', label: 'a point' }
+    const draw = createDraw([point('p1', properties)])
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    expect(mapProvider.addSymbolsToMap).toHaveBeenCalledWith([properties], mapStyle, symbolRegistry)
+    const expectedImageId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, 2)
+    expect(draw.add).toHaveBeenCalledWith({
+      id: 'p1',
+      type: 'Feature',
+      geometry: { type: 'Point', coordinates: [1, 2] },
+      properties: {
+        ...properties,
+        symbolImageId: expectedImageId,
+        symbolIconAnchor: 'bottom', // pin's default anchor [0.5, 0.9] snaps to icon-anchor 'bottom'
+        // Nothing registered in map._activeSymbolImageMap/_selectedSymbolImageMap here since
+        // addSymbolsToMap is mocked out (a no-op) in this test — see the dedicated test below
+        // for the case where it actually populates them.
+        symbolActiveImageId: null,
+        symbolSelectedImageId: null
+      }
+    })
+    // icon-offset corrects the precision lost snapping 0.9 to 1.0 against pin's 44px viewBox —
+    // registered into the point-symbol layers' icon-offset match expression instead of onto
+    // the feature (see registerSymbolIconOffset's comment for why).
+    expect(map._symbolIconOffsetMap[expectedImageId]).toEqual([0, 4.4])
+    expect(map.setLayoutProperty).toHaveBeenCalledWith('point-symbol.hot', 'icon-offset', [
+      'match', ['get', 'user_symbolImageId'], expectedImageId, ['literal', [0, 4.4]], ['literal', [0, 0]]
+    ])
+    expect(map.setLayoutProperty).toHaveBeenCalledWith('point-symbol.cold', 'icon-offset', [
+      'match', ['get', 'user_symbolImageId'], expectedImageId, ['literal', [0, 4.4]], ['literal', [0, 0]]
+    ])
+  })
+
+  it('only applies the icon-offset expression to point-symbol layers that actually exist on the map', async () => {
+    const map = createMap()
+    map.getLayer.mockImplementation((layerId) => layerId === 'point-symbol.cold') // hot copy absent
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'pin' }
+    const draw = createDraw([point('p1', properties)])
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    expect(map.setLayoutProperty).toHaveBeenCalledWith('point-symbol.cold', 'icon-offset', expect.anything())
+    expect(map.setLayoutProperty).not.toHaveBeenCalledWith('point-symbol.hot', 'icon-offset', expect.anything())
+  })
+
+  it('does not re-register or re-apply icon-offset for a symbolImageId already known (offset is deterministic per id)', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'pin' }
+    const draw = createDraw([point('p1', properties), point('p2', properties)])
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+    map.setLayoutProperty.mockClear()
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p2', properties })
+
+    expect(map.setLayoutProperty).not.toHaveBeenCalled()
+  })
+
+  it('reads the active/selected variant ids back from map._activeSymbolImageMap/_selectedSymbolImageMap once addSymbolsToMap has registered them', async () => {
+    const map = createMap()
+    const properties = { symbol: 'pin' }
+    const draw = createDraw([point('p1', properties)])
+    const expectedImageId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, 2)
+    // Simulates what the real addSymbolsToMap (providers/maplibre/src/utils/symbolImages.js)
+    // does as a side effect: populate these maps, keyed by the normal variant's own id.
+    const mapProvider = {
+      addSymbolsToMap: jest.fn(() => {
+        map._activeSymbolImageMap = { [expectedImageId]: 'symbol-act-xyz' }
+        map._selectedSymbolImageMap = { [expectedImageId]: 'symbol-sel-xyz' }
+        return Promise.resolve()
+      })
+    }
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    expect(draw.add).toHaveBeenCalledWith(expect.objectContaining({
+      properties: expect.objectContaining({
+        symbolActiveImageId: 'symbol-act-xyz',
+        symbolSelectedImageId: 'symbol-sel-xyz'
+      })
+    }))
+  })
+
+  it('does nothing when getSymbolImageId resolves null (e.g. an unresolvable symbol id)', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'not-a-real-symbol' }
+    const draw = createDraw([point('p1', properties)])
+    const spy = jest.spyOn(symbolRegistry, 'getSymbolImageId').mockReturnValueOnce(null)
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    expect(draw.add).not.toHaveBeenCalled()
+    spy.mockRestore()
+  })
+
+  it('does not re-add the feature if it was deleted while registration was in flight', async () => {
+    const map = createMap()
+    const properties = { symbol: 'pin' }
+    let resolveRegistration
+    const mapProvider = { addSymbolsToMap: jest.fn(() => new Promise((resolve) => { resolveRegistration = resolve })) }
+    const draw = createDraw() // empty — feature already gone
+
+    const pending = resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+    resolveRegistration()
+    await pending
+
+    expect(draw.add).not.toHaveBeenCalled()
+  })
+
+  it('uses a custom symbolAnchor when the style provides one, with no offset needed for an on-grid anchor', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'circle', symbolAnchor: [0, 0] }
+    const draw = createDraw([point('p1', properties)])
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    expect(draw.add).toHaveBeenCalledWith(expect.objectContaining({
+      properties: expect.objectContaining({ symbolIconAnchor: 'top-left' })
+    }))
+    const expectedImageId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, 2)
+    expect(map._symbolIconOffsetMap[expectedImageId]).toEqual([0, 0])
+  })
+
+  it('computes a non-zero icon-offset for an off-grid custom symbolAnchor', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'circle', symbolAnchor: [0.5, 0.8] }
+    const draw = createDraw([point('p1', properties)])
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    // circle's viewBox is 44×44 — anchor 0.8 snaps to icon-anchor 'bottom' (1.0), offset corrects the gap
+    expect(draw.add).toHaveBeenCalledWith(expect.objectContaining({
+      properties: expect.objectContaining({ symbolIconAnchor: 'bottom' })
+    }))
+    const expectedImageId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, 2)
+    expect(map._symbolIconOffsetMap[expectedImageId]).toEqual([0, 8.8])
+  })
+
+  it('respects a custom symbolViewBox when computing the offset', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const properties = { symbol: 'pin', symbolViewBox: '0 0 100 100' }
+    const draw = createDraw([point('p1', properties)])
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    // pin's anchor [0.5, 0.9] against a 100×100 viewBox instead of the built-in 44×44
+    const expectedImageId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, 2)
+    expect(map._symbolIconOffsetMap[expectedImageId]).toEqual([0, 10])
+  })
+
+  it('surfaces (rather than swallows) a registration failure', async () => {
+    const map = createMap()
+    const properties = { symbol: 'pin' }
+    const mapProvider = { addSymbolsToMap: jest.fn(() => Promise.reject(new Error('rasterise failed'))) }
+    const draw = createDraw([point('p1', properties)])
+    const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await resolvePointSymbol({ draw, mapProvider, map, featureId: 'p1', properties })
+
+    expect(draw.add).not.toHaveBeenCalled()
+    expect(consoleError).toHaveBeenCalledWith('[draw] failed to resolve point symbol', 'p1', expect.any(Error))
+    consoleError.mockRestore()
+  })
+})
+
+describe('refreshAllPointSymbols', () => {
+  it('re-resolves every point feature with a symbol config, ignoring non-point and unstyled features', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const pointWithSymbol = { id: 'p1', geometry: { type: 'Point' }, properties: { symbol: 'pin' } }
+    const pointWithoutSymbol = { id: 'p2', geometry: { type: 'Point' }, properties: {} }
+    const polygon = { id: 'poly1', geometry: { type: 'Polygon' }, properties: { symbol: 'pin' } }
+    const draw = createDraw([pointWithSymbol, pointWithoutSymbol, polygon])
+
+    await refreshAllPointSymbols({ draw, mapProvider, map })
+
+    expect(mapProvider.addSymbolsToMap).toHaveBeenCalledTimes(1)
+    expect(mapProvider.addSymbolsToMap).toHaveBeenCalledWith([pointWithSymbol.properties], mapStyle, symbolRegistry)
+  })
+
+  it('does nothing when there are no drawn points', async () => {
+    const map = createMap()
+    const mapProvider = createMapProvider()
+    const draw = createDraw([])
+    await refreshAllPointSymbols({ draw, mapProvider, map })
+    expect(mapProvider.addSymbolsToMap).not.toHaveBeenCalled()
+  })
+
+  // A style change re-resolves every point concurrently; each one's addSymbolsToMap()
+  // settles on its own schedule. A single combined draw.add() (rather than one call per
+  // point) is what keeps mapbox-gl-draw's debounced render from ever painting one point's
+  // fresh data alongside another's still-stale, now-unregistered image id — see
+  // refreshAllPointSymbols's own comment.
+  it('batches every resolved point into a single draw.add() call, not one per point', async () => {
+    const map = createMap()
+    const p1 = point('p1', { symbol: 'pin' })
+    const p2 = point('p2', { symbol: 'square' }, [3, 4])
+    const draw = createDraw([p1, p2])
+    // Stagger completion — p2 resolves after p1 to simulate genuinely concurrent, unevenly
+    // timed rasterisation.
+    let resolveP1, resolveP2
+    const mapProvider = {
+      addSymbolsToMap: jest.fn((configs) => new Promise((resolve) => {
+        const target = configs[0].symbol === 'pin' ? (v) => { resolveP1 = v } : (v) => { resolveP2 = v }
+        target(resolve)
+      }))
+    }
+
+    const pending = refreshAllPointSymbols({ draw, mapProvider, map })
+    resolveP2()
+    await Promise.resolve()
+    resolveP1()
+    await pending
+
+    expect(draw.add).toHaveBeenCalledTimes(1)
+    const [{ type, features }] = draw.add.mock.calls[0]
+    expect(type).toBe('FeatureCollection')
+    expect(features.map((f) => f.id).sort()).toEqual(['p1', 'p2'])
+  })
+
+  it('logs and still applies the points that did resolve when one point fails', async () => {
+    const map = createMap()
+    const p1 = point('p1', { symbol: 'pin' })
+    const p2 = point('p2', { symbol: 'not-a-real-symbol' })
+    const draw = createDraw([p1, p2])
+    const mapProvider = {
+      addSymbolsToMap: jest.fn((configs) =>
+        configs[0].symbol === 'not-a-real-symbol' ? Promise.reject(new Error('rasterise failed')) : Promise.resolve()
+      )
+    }
+    const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await refreshAllPointSymbols({ draw, mapProvider, map })
+
+    expect(consoleError).toHaveBeenCalledWith('[draw] failed to resolve point symbol', expect.any(Error))
+    expect(draw.add).toHaveBeenCalledTimes(1)
+    const [{ features }] = draw.add.mock.calls[0]
+    expect(features.map((f) => f.id)).toEqual(['p1'])
+    consoleError.mockRestore()
+  })
+})

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

@@ -95,12 +95,17 @@ function patchColorMethods (proto, orig, colors) {
   }
 }
 
-// Skip when disabled or zooming; clean up internal arrays to prevent memory accumulation
+// Skip when disabled, zooming, or (for unmarked calls only, while suspended — see
+// snapHelpers.js's setAutoSnapSuspended) mid-drag; clean up internal arrays to prevent memory
+// accumulation
 function patchSnapMethod (proto, orig) {
   proto.snapToClosestPoint = function (e) {
     if (!this.status || this.map?._isZooming) {
       return undefined
     }
+    if (this._autoSnapSuspended && !e._explicit) {
+      return undefined
+    }
     try {
       const result = orig.snapToClosestPoint.call(this, e)
       if (this.closeFeatures?.length > MAX_SNAP_FEATURE_CACHE) {

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

@@ -235,4 +235,25 @@ describe('snapToClosestPoint', () => {
     expect(self.snapStatus).toBe(false)
     expect(self.snapCoords).toBeNull()
   })
+
+  // While an edit mode's own offset-aware drag has suspended it (setAutoSnapSuspended, see its
+  // own comment), the snap library's own uncontrolled mousemove-driven auto-query must be
+  // skipped — otherwise it re-queries at the raw cursor and fights the mode's own query, which
+  // is why the two used to visibly fall out of sync (the indicator tracking the cursor while
+  // the dragged feature snapped to a different, offset-corrected result).
+  test('skips an unmarked call while auto-snap is suspended', () => {
+    const self = { status: true, map: {}, _autoSnapSuspended: true }
+    expect(MapboxSnap.prototype.snapToClosestPoint.call(self, {})).toBeUndefined()
+    expect(MapboxSnap.__orig.snapToClosestPoint).not.toHaveBeenCalled()
+  })
+
+  test('still runs an explicit call while auto-snap is suspended', () => {
+    const self = { status: true, map: {}, _autoSnapSuspended: true }
+    expect(MapboxSnap.prototype.snapToClosestPoint.call(self, { _explicit: true })).toBe('orig-snap')
+  })
+
+  test('runs unmarked calls normally once auto-snap is no longer suspended', () => {
+    const self = { status: true, map: {}, _autoSnapSuspended: false }
+    expect(MapboxSnap.prototype.snapToClosestPoint.call(self, {})).toBe('orig-snap')
+  })
 })

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

@@ -13,8 +13,12 @@ function cleanupOldSnap (map) {
 }
 
 // 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'])
+// drawing or editing — outside these modes there is nothing to snap to. This list is
+// independent of (and must be kept in sync with) MaplibreDrawAdapter's own DRAW_MODES set,
+// which only controls when the snap *indicator* gets cleared on mode exit — this one gates
+// snap.status itself, which both the visual indicator AND actual snap-to-coordinate
+// (isSnapActive() in snapHelpers.js) depend on.
+const SNAP_ACTIVE_MODES = new Set(['draw_polygon', 'draw_line', 'draw_point', 'edit_vertex', 'edit_point'])
 
 /**
  * Externally-controlled status: ignore library writes so status is only changed

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

@@ -89,6 +89,18 @@ describe('createSnapInstance', () => {
     expect(snap.status).toBe(true)
   })
 
+  test('status is true for every draw/edit mode, including point placement/edit', () => {
+    const map = makeMap()
+    const draw = { getMode: jest.fn(() => 'draw_polygon') }
+    const snap = createSnapInstance(map, draw, {}, { ...config, status: false })
+    snap.setSnapStatus(true)
+
+    for (const mode of ['draw_polygon', 'draw_line', 'draw_point', 'edit_vertex', 'edit_point']) {
+      draw.getMode.mockReturnValue(mode)
+      expect(snap.status).toBe(true)
+    }
+  })
+
   test('setSnapLayers overrides, resets and ignores invalid input', () => {
     const map = makeMap()
     const snap = createSnapInstance(map, {}, {}, { ...config, layers: ['a'] })