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

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

@@ -0,0 +1,83 @@
+import { symbolRegistry } from '../../../../../../src/services/symbolRegistry.js'
+import { getOrCreateSymbolImage } from '../../../../../../providers/beta/openlayers/src/utils/symbolImages.js'
+
+/**
+ * Resolves a drawn point's symbol-config icon and writes the resolved image id back onto the
+ * OL feature, so core/styles.js's createFeatureStyle() can render it via an ol/style/Icon.
+ * Also resolves and caches the 'active'/'selected' variants as symbolActiveImageId/
+ * symbolSelectedImageId, read directly by highlightFeatures.js's selection overlay.
+ */
+
+const VARIANTS = ['normal', 'active', 'selected']
+const PROPERTY_FOR_VARIANT = { normal: 'symbolImageId', active: 'symbolActiveImageId', selected: 'symbolSelectedImageId' }
+
+export const hasSymbolStyle = (properties) => !!(properties?.symbol || properties?.symbolSvgContent)
+
+// Combines the browser's native devicePixelRatio with this app's own map-size scale factor
+// (mapProvider.drawScale), matching MapController.jsx's construction-time formula.
+export const getPixelRatio = (mapProvider) => (globalThis.devicePixelRatio || 1) * (mapProvider?.drawScale ?? 1)
+
+/**
+ * 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.manager - OLDrawManager (needs store.source, mapStyle)
+ * @param {Object} params.mapProvider
+ * @param {import('ol/Feature.js').default} params.olFeature
+ * @returns {Promise<void>}
+ */
+export const resolvePointSymbol = async ({ manager, mapProvider, olFeature }) => {
+  const properties = olFeature.getProperties()
+  if (!hasSymbolStyle(properties)) {
+    return
+  }
+
+  const pixelRatio = getPixelRatio(mapProvider)
+
+  try {
+    const results = await Promise.all(
+      VARIANTS.map((variant) => symbolRegistry.rasteriseSymbolImage(properties, manager.mapStyle, variant, pixelRatio))
+    )
+    // All three variants resolve from the same symbol config, so either all succeed or (an
+    // unresolvable symbol id) all fail together — gating on 'normal' alone is enough.
+    if (!results[0]) {
+      return
+    }
+
+    // The feature may have been deleted/cancelled while rasterising was in flight.
+    if (!manager.store.source.hasFeature(olFeature)) {
+      return
+    }
+    VARIANTS.forEach((variant, i) => {
+      const result = results[i]
+      if (!result) { return }
+      getOrCreateSymbolImage(result.imageId, result.imageData)
+      olFeature.set(PROPERTY_FOR_VARIANT[variant], result.imageId)
+    })
+    // ol/style/Icon draws its source canvas at native pixel size — core/styles.js reads this
+    // back to apply `scale: 1 / symbolPixelRatio`, correcting for the canvas being rasterised
+    // at pixelRatio device pixels for crispness.
+    olFeature.set('symbolPixelRatio', pixelRatio)
+  } 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', olFeature.getId(), err) // NOSONAR
+  }
+}
+
+/**
+ * Re-resolve every existing drawn point's symbol — called on map style/size change, since
+ * the rasterised image (colours, and pixel-ratio-scaled dimensions) depends on both.
+ *
+ * @param {Object} params
+ * @param {Object} params.manager
+ * @param {Object} params.mapProvider
+ * @returns {Promise<void>}
+ */
+export const refreshAllPointSymbols = ({ manager, mapProvider }) => {
+  const points = manager.store.source.getFeatures().filter(
+    (f) => f.getGeometry()?.getType() === 'Point' && hasSymbolStyle(f.getProperties())
+  )
+  return Promise.all(points.map((olFeature) => resolvePointSymbol({ manager, mapProvider, olFeature })))
+}

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

@@ -0,0 +1,214 @@
+import { hasSymbolStyle, getPixelRatio, resolvePointSymbol, refreshAllPointSymbols } from './pointSymbolImages.js'
+import { symbolRegistry } from '../../../../../../src/services/symbolRegistry.js'
+import { getCachedSymbolImage, clearSymbolImageCache } from '../../../../../../providers/beta/openlayers/src/utils/symbolImages.js'
+
+const mapStyle = { id: 'outdoor', mapColorScheme: 'light' }
+
+const createMapProvider = ({ drawScale = 1 } = {}) => ({ drawScale })
+
+// A minimal ol.Feature stand-in — resolvePointSymbol only ever calls
+// getProperties()/set() on it, and manager.store.source.hasFeature() to check liveness.
+const createOlFeature = (properties) => {
+  const props = { ...properties }
+  return {
+    getProperties: () => props,
+    set: jest.fn((key, value) => { props[key] = value })
+  }
+}
+
+const createManager = ({ features = [] } = {}) => ({
+  mapStyle,
+  store: {
+    source: {
+      hasFeature: jest.fn((f) => features.includes(f)),
+      getFeatures: jest.fn(() => features)
+    }
+  }
+})
+
+// symbolRegistry.rasteriseSymbolImage() draws an SVG through a real `new Image()`/onload
+// round-trip that jsdom never resolves — every other test file touching it (e.g. the
+// MapLibre adapter's pointSymbolImages.test.js) instead lets a mocked provider call
+// (addSymbolsToMap) stand in for it. This adapter calls rasteriseSymbolImage directly (it
+// *is* the last-mile pipeline, with no provider-level call to mock instead), so it's stubbed
+// here with a fake resolved ImageData keyed to the properties/pixelRatio, matching
+// getSymbolImageId's own id shape closely enough for assertions to key off it.
+const stubRasterise = () => jest.spyOn(symbolRegistry, 'rasteriseSymbolImage')
+  .mockImplementation(async (style, ms, variant, pixelRatio) => ({
+    // variant folded into the id (mirroring the real act-/sel- prefixing) so normal/active/
+    // selected resolve to distinct ids, the way real symbol configs do.
+    imageId: `${variant}-${symbolRegistry.getSymbolImageId(style, ms, false, pixelRatio)}`,
+    imageData: { width: 10, height: 10 }
+  }))
+
+beforeEach(() => {
+  clearSymbolImageCache()
+  HTMLCanvasElement.prototype.getContext = jest.fn(function () {
+    this._ctx ??= { putImageData: jest.fn() }
+    return this._ctx
+  })
+  stubRasterise()
+})
+
+afterEach(() => jest.restoreAllMocks())
+
+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('combines devicePixelRatio and mapProvider.drawScale', () => {
+    const restore = globalThis.devicePixelRatio
+    globalThis.devicePixelRatio = 2
+    expect(getPixelRatio(createMapProvider({ drawScale: 1.5 }))).toBe(3)
+    globalThis.devicePixelRatio = restore
+  })
+
+  it('falls back to 1 for either factor when unset', () => {
+    const restore = globalThis.devicePixelRatio
+    delete globalThis.devicePixelRatio
+    expect(getPixelRatio(createMapProvider({ drawScale: undefined }))).toBe(1)
+    expect(getPixelRatio(undefined)).toBe(1)
+    globalThis.devicePixelRatio = restore
+  })
+})
+
+describe('resolvePointSymbol', () => {
+  it('does nothing for a feature with no symbol config', async () => {
+    const olFeature = createOlFeature({})
+    const manager = createManager()
+    await resolvePointSymbol({ manager, mapProvider: createMapProvider(), olFeature })
+    expect(olFeature.set).not.toHaveBeenCalled()
+  })
+
+  it('rasterises, caches the canvas and writes symbolImageId/symbolPixelRatio back onto the feature', async () => {
+    const properties = { symbol: 'pin' }
+    const olFeature = createOlFeature(properties)
+    const manager = createManager({ features: [olFeature] })
+    const mapProvider = createMapProvider({ drawScale: 2 })
+
+    await resolvePointSymbol({ manager, mapProvider, olFeature })
+
+    const pixelRatio = getPixelRatio(mapProvider)
+    const baseId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, pixelRatio)
+    expect(olFeature.set).toHaveBeenCalledWith('symbolImageId', `normal-${baseId}`)
+    // symbolPixelRatio is what core/styles.js later uses to scale the (pixelRatio×-oversized)
+    // cached canvas back down to its intended CSS display size.
+    expect(olFeature.set).toHaveBeenCalledWith('symbolPixelRatio', pixelRatio)
+    expect(getCachedSymbolImage(`normal-${baseId}`)).toBeInstanceOf(HTMLCanvasElement)
+  })
+
+  it('also rasterises, caches and writes the active/selected variants — one image id each, keyed to the same symbol config', async () => {
+    const properties = { symbol: 'pin' }
+    const olFeature = createOlFeature(properties)
+    const manager = createManager({ features: [olFeature] })
+    const mapProvider = createMapProvider()
+
+    await resolvePointSymbol({ manager, mapProvider, olFeature })
+
+    const pixelRatio = getPixelRatio(mapProvider)
+    const baseId = symbolRegistry.getSymbolImageId(properties, mapStyle, false, pixelRatio)
+    expect(olFeature.set).toHaveBeenCalledWith('symbolActiveImageId', `active-${baseId}`)
+    expect(olFeature.set).toHaveBeenCalledWith('symbolSelectedImageId', `selected-${baseId}`)
+    expect(getCachedSymbolImage(`active-${baseId}`)).toBeInstanceOf(HTMLCanvasElement)
+    expect(getCachedSymbolImage(`selected-${baseId}`)).toBeInstanceOf(HTMLCanvasElement)
+    // objectContaining, not the exact `properties` object — resolvePointSymbol's own
+    // property-write calls mutate that same (by-reference) object in place afterwards, and
+    // jest's mock.calls records the reference, not a snapshot at call time.
+    const symbolMatch = expect.objectContaining({ symbol: 'pin' })
+    expect(symbolRegistry.rasteriseSymbolImage).toHaveBeenCalledWith(symbolMatch, mapStyle, 'normal', pixelRatio)
+    expect(symbolRegistry.rasteriseSymbolImage).toHaveBeenCalledWith(symbolMatch, mapStyle, 'active', pixelRatio)
+    expect(symbolRegistry.rasteriseSymbolImage).toHaveBeenCalledWith(symbolMatch, mapStyle, 'selected', pixelRatio)
+  })
+
+  it('skips just the active/selected properties if only those variants resolve null (normal still succeeds)', async () => {
+    const properties = { symbol: 'pin' }
+    const olFeature = createOlFeature(properties)
+    const manager = createManager({ features: [olFeature] })
+    symbolRegistry.rasteriseSymbolImage
+      .mockImplementationOnce(async (style, ms, variant, pixelRatio) => // normal — real stub behaviour
+        ({ imageId: `${variant}-${symbolRegistry.getSymbolImageId(style, ms, false, pixelRatio)}`, imageData: { width: 10, height: 10 } }))
+      .mockResolvedValueOnce(null) // active
+      .mockResolvedValueOnce(null) // selected
+
+    await resolvePointSymbol({ manager, mapProvider: createMapProvider(), olFeature })
+
+    expect(olFeature.set).toHaveBeenCalledWith('symbolImageId', expect.any(String))
+    expect(olFeature.set).not.toHaveBeenCalledWith('symbolActiveImageId', expect.anything())
+    expect(olFeature.set).not.toHaveBeenCalledWith('symbolSelectedImageId', expect.anything())
+  })
+
+  it('does nothing when rasterisation resolves null (e.g. an unresolvable symbol id)', async () => {
+    const properties = { symbol: 'not-a-real-symbol' }
+    const olFeature = createOlFeature(properties)
+    const manager = createManager({ features: [olFeature] })
+    symbolRegistry.rasteriseSymbolImage.mockResolvedValueOnce(null)
+
+    await resolvePointSymbol({ manager, mapProvider: createMapProvider(), olFeature })
+
+    expect(olFeature.set).not.toHaveBeenCalled()
+  })
+
+  it('does not write back if the feature was removed from the source while rasterising was in flight', async () => {
+    const properties = { symbol: 'pin' }
+    const olFeature = createOlFeature(properties)
+    const manager = createManager({ features: [] }) // not present in the source
+
+    await resolvePointSymbol({ manager, mapProvider: createMapProvider(), olFeature })
+
+    expect(olFeature.set).not.toHaveBeenCalled()
+  })
+
+  it('surfaces (rather than swallows) a rasterisation failure', async () => {
+    const properties = { symbol: 'pin' }
+    const olFeature = createOlFeature(properties)
+    olFeature.getId = () => 'p1'
+    const manager = createManager({ features: [olFeature] })
+    const error = new Error('rasterise failed')
+    symbolRegistry.rasteriseSymbolImage.mockRejectedValueOnce(error)
+    const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await resolvePointSymbol({ manager, mapProvider: createMapProvider(), olFeature })
+
+    expect(olFeature.set).not.toHaveBeenCalled()
+    expect(consoleError).toHaveBeenCalledWith('[draw] failed to resolve point symbol', 'p1', error)
+  })
+})
+
+describe('refreshAllPointSymbols', () => {
+  const feature = (getType, properties) => {
+    const f = createOlFeature(properties)
+    f.getGeometry = () => ({ getType: () => getType })
+    return f
+  }
+
+  it('re-resolves every point feature with a symbol config, ignoring non-point and unstyled features', async () => {
+    const pointWithSymbol = feature('Point', { symbol: 'pin' })
+    const pointWithoutSymbol = feature('Point', {})
+    const polygon = feature('Polygon', { symbol: 'pin' })
+    const manager = createManager({ features: [pointWithSymbol, pointWithoutSymbol, polygon] })
+    manager.store.source.hasFeature = jest.fn(() => true)
+
+    await refreshAllPointSymbols({ manager, mapProvider: createMapProvider() })
+
+    expect(pointWithSymbol.set).toHaveBeenCalledWith('symbolImageId', expect.any(String))
+    expect(pointWithoutSymbol.set).not.toHaveBeenCalled()
+    expect(polygon.set).not.toHaveBeenCalled()
+  })
+
+  it('does nothing when there are no drawn points', async () => {
+    const manager = createManager({ features: [] })
+    await expect(refreshAllPointSymbols({ manager, mapProvider: createMapProvider() })).resolves.toEqual([])
+  })
+})

package/plugins/draw/src/adapters/openlayers/snap/snapIndicator.js

@@ -37,7 +37,9 @@ export const createSnapIndicator = (map, colors) => {
   const layer = new VectorLayer({
     source,
     style: (f) => styles[f.get('snapType')] ?? null,
-    zIndex: 200,
+    // Below the draw layer (zIndex 100) and its vertex/midpoint handles (101-103), matching
+    // the ML adapter — the indicator sits behind the symbols/vertices it's snapping to.
+    zIndex: 99,
     updateWhileAnimating: true,
     updateWhileInteracting: true
   })

package/plugins/draw/src/adapters/openlayers/snap/snapInteraction.js

@@ -3,9 +3,9 @@
  * mapBrowserEvent.coordinate to the nearest snap candidate before any draw
  * or modify interaction sees it.
  *
- * Coordinate snapping applies to all pointer events (pointermove, pointerdown,
- * pointerup, singleclick) so that both rubberbanding and vertex placement are snapped.
- * The visual indicator is only updated on pointermove.
+ * The visual indicator updates on both pointermove (hover preview) and pointerdrag (an active
+ * OL Modify drag), staying visible through to release — nothing hides it on release; it only
+ * clears on a fresh query, a mode change, or snapping being switched off.
  *
  * Must be added to the map AFTER the Draw/Modify interaction so it is processed
  * first (OL iterates interactions in reverse-add order).
@@ -15,6 +15,7 @@
 import Interaction from 'ol/interaction/Interaction.js'
 
 const SNAP_EVENTS = new Set(['pointermove', 'pointerdrag', 'pointerdown', 'pointerup', 'singleclick', 'click'])
+const INDICATOR_EVENTS = new Set(['pointermove', 'pointerdrag'])
 
 const processSnapEvent = (mapBrowserEvent, engine, indicator, snapRadius, isIndicatorActive) => {
   const { type } = mapBrowserEvent
@@ -33,13 +34,9 @@ const processSnapEvent = (mapBrowserEvent, engine, indicator, snapRadius, isIndi
     mapBrowserEvent.coordinate = result.coord.slice()
   }
 
-  // Only update indicator during free mouse movement — hide during drag, no-op for clicks
-  if (type === 'pointermove' && isIndicatorActive()) {
+  // Hover preview and active drag both keep the indicator live; no update for click/down/up.
+  if (INDICATOR_EVENTS.has(type) && isIndicatorActive()) {
     result ? indicator.show(result.coord, result.type) : indicator.hide()
-  } else if (type === 'pointerdrag') {
-    indicator.hide()
-  } else {
-    // no indicator update for click/down/up events
   }
 }
 

package/plugins/draw/src/adapters/openlayers/snap/snapInteraction.test.js

@@ -35,7 +35,7 @@ test('rewrites the event coordinate to a copy of the snap candidate for all poin
   }
 })
 
-test('the indicator follows free mouse movement only', () => {
+test('the indicator follows both free mouse movement and an active drag', () => {
   const { engine, indicator, fire } = setup()
   fire('pointermove')
   expect(indicator.show).toHaveBeenCalledWith([9, 9], 'vertex')
@@ -44,17 +44,28 @@ test('the indicator follows free mouse movement only', () => {
   fire('pointermove')
   expect(indicator.hide).toHaveBeenCalledTimes(1)
 
+  // A drag (e.g. edit_vertex's mouse-drag path, edit/modifyInteraction.js) keeps it live too —
+  // it must stay visible for as long as the dragged vertex sits on a candidate, not just on a
+  // free hover. See snapInteraction.js's own comment for why: this used to force-hide it on
+  // every pointerdrag, so the indicator could never actually be seen mid-drag.
   engine.query.mockReturnValue({ type: 'edge', coord: [5, 5] })
   fire('pointerdrag')
-  expect(indicator.hide).toHaveBeenCalledTimes(2) // hidden during drags
+  expect(indicator.show).toHaveBeenCalledWith([5, 5], 'edge')
+
+  engine.query.mockReturnValue(null)
+  fire('pointerdrag')
+  expect(indicator.hide).toHaveBeenCalledTimes(2)
+
   fire('singleclick')
-  expect(indicator.show).toHaveBeenCalledTimes(1) // clicks never touch the indicator
+  expect(indicator.show).toHaveBeenCalledTimes(2) // clicks never touch the indicator
+  expect(indicator.hide).toHaveBeenCalledTimes(2)
 })
 
-test('the indicator stays untouched during pointermove when the indicator is gated off', () => {
+test('the indicator stays untouched during pointermove or a drag when the indicator is gated off', () => {
   const { indicator, fire } = setup({ indicatorActive: false })
   const { event } = fire('pointermove')
   expect(event.coordinate).toEqual([9, 9]) // snapping still applies
+  fire('pointerdrag')
   expect(indicator.show).not.toHaveBeenCalled()
   expect(indicator.hide).not.toHaveBeenCalled()
 })

package/plugins/draw/src/adapters/openlayers/utils/olCoords.js

@@ -16,7 +16,7 @@ export const pixelToCoord = (map, pixel) => {
 }
 
 /** Pixel distance between two { x, y } points */
-export const pixelDist = (a, b) => Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2)
+export const pixelDist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y)
 
 /** OL pixel array [x, y] → { x, y } */
 export const arrayToPixel = ([x, y]) => ({ x, y })

package/plugins/draw/src/api/addFeature.js

@@ -1,4 +1,13 @@
 import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+import { stripInternalProperties } from '../utils/stripInternalProperties.js'
+import { logger } from '../../../../src/services/logger.js'
+
+const SUPPORTED_GEOMETRY_TYPES = new Set(['Point', 'LineString', 'Polygon'])
+
+// type: 'Feature' is defaulted below (both adapters mishandle it missing), but a missing or
+// unsupported geometry is a genuine caller mistake, so that's rejected instead.
+const isValidFeature = (feature) =>
+  SUPPORTED_GEOMETRY_TYPES.has(feature.geometry?.type) && feature.geometry?.coordinates !== undefined
 
 export const addFeature = ({ mapProvider, services }, feature) => {
   const { draw } = mapProvider
@@ -10,6 +19,7 @@ export const addFeature = ({ mapProvider, services }, feature) => {
 
   const { stroke, fill, strokeWidth, properties, ...featureRest } = feature
   const flatFeature = {
+    type: 'Feature',
     ...featureRest,
     properties: {
       ...properties,
@@ -17,6 +27,11 @@ export const addFeature = ({ mapProvider, services }, feature) => {
     }
   }
 
+  if (!isValidFeature(flatFeature)) {
+    logger.warn('addFeature: ignoring invalid GeoJSON feature', flatFeature)
+    return
+  }
+
   draw.add(flatFeature)
-  eventBus.emit('draw:add', flatFeature)
+  eventBus.emit('draw:add', stripInternalProperties(flatFeature))
 }

package/plugins/draw/src/api/addFeature.test.js

@@ -1,9 +1,13 @@
 import { addFeature } from './addFeature.js'
 import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+import { logger } from '../../../../src/services/logger.js'
 
 jest.mock('../utils/flattenStyleProperties.js', () => ({
   flattenStyleProperties: jest.fn(() => ({ _flat: true }))
 }))
+jest.mock('../../../../src/services/logger.js', () => ({
+  logger: { warn: jest.fn(), error: jest.fn() }
+}))
 
 const setup = (draw) => {
   const eventBus = { emit: jest.fn() }
@@ -19,15 +23,27 @@ describe('addFeature', () => {
     expect(eventBus.emit).not.toHaveBeenCalled()
   })
 
-  test('flattens style properties and adds the feature', () => {
+  test('flattens style properties, defaults type to Feature, and adds the feature', () => {
     const draw = { add: jest.fn() }
     const { context, eventBus } = setup(draw)
-    const feature = { id: 'a', geometry: {}, stroke: 'red', fill: 'blue', strokeWidth: 2, properties: { name: 'x' } }
+    const feature = {
+      id: 'a',
+      geometry: { type: 'Point', coordinates: [0, 0] },
+      stroke: 'red',
+      fill: 'blue',
+      strokeWidth: 2,
+      properties: { name: 'x' }
+    }
 
     addFeature(context, feature)
 
     expect(flattenStyleProperties).toHaveBeenCalledWith({ stroke: 'red', fill: 'blue', strokeWidth: 2 })
-    const expected = { id: 'a', geometry: {}, properties: { name: 'x', _flat: true } }
+    const expected = {
+      type: 'Feature',
+      id: 'a',
+      geometry: { type: 'Point', coordinates: [0, 0] },
+      properties: { name: 'x', _flat: true }
+    }
     expect(draw.add).toHaveBeenCalledWith(expected)
     expect(eventBus.emit).toHaveBeenCalledWith('draw:add', expected)
   })
@@ -35,7 +51,48 @@ describe('addFeature', () => {
   test('handles a feature without existing properties', () => {
     const draw = { add: jest.fn() }
     const { context } = setup(draw)
-    addFeature(context, { id: 'b', geometry: {} })
-    expect(draw.add).toHaveBeenCalledWith({ id: 'b', geometry: {}, properties: { _flat: true } })
+    addFeature(context, { id: 'b', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] } })
+    expect(draw.add).toHaveBeenCalledWith({
+      type: 'Feature',
+      id: 'b',
+      geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] },
+      properties: { _flat: true }
+    })
+  })
+
+  test('does not override an explicitly supplied type', () => {
+    const draw = { add: jest.fn() }
+    const { context } = setup(draw)
+    addFeature(context, { id: 'c', type: 'Feature', geometry: { type: 'Polygon', coordinates: [[]] } })
+    expect(draw.add).toHaveBeenCalledWith(expect.objectContaining({ type: 'Feature' }))
+  })
+
+  // A missing/unsupported geometry is a genuine caller mistake — warned and dropped rather
+  // than handed to an adapter that would throw or silently misread it.
+  describe('invalid geometry', () => {
+    test('rejects a feature with no geometry at all', () => {
+      const draw = { add: jest.fn() }
+      const { context, eventBus } = setup(draw)
+      addFeature(context, { id: 'd' })
+      expect(draw.add).not.toHaveBeenCalled()
+      expect(eventBus.emit).not.toHaveBeenCalled()
+      expect(logger.warn).toHaveBeenCalledWith('addFeature: ignoring invalid GeoJSON feature', expect.objectContaining({ id: 'd' }))
+    })
+
+    test('rejects an unsupported geometry type', () => {
+      const draw = { add: jest.fn() }
+      const { context } = setup(draw)
+      addFeature(context, { id: 'e', geometry: { type: 'MultiPoint', coordinates: [[0, 0]] } })
+      expect(draw.add).not.toHaveBeenCalled()
+      expect(logger.warn).toHaveBeenCalled()
+    })
+
+    test('rejects a geometry with no coordinates', () => {
+      const draw = { add: jest.fn() }
+      const { context } = setup(draw)
+      addFeature(context, { id: 'f', geometry: { type: 'Point' } })
+      expect(draw.add).not.toHaveBeenCalled()
+      expect(logger.warn).toHaveBeenCalled()
+    })
   })
 })

package/plugins/draw/src/api/editFeature.js

@@ -18,14 +18,17 @@ export const editFeature = ({ appState, appConfig, mapState, pluginConfig, plugi
   // Per-call callback overrides the plugin-level one; events.js reads this on every commit.
   draw._geometryValidator = options.onGeometryChange ?? pluginConfig.onGeometryChange
 
-  const editModeMap = { LineString: 'edit_line', Polygon: 'edit_polygon' }
+  // A Point has no ring of vertices to edit — edit_point relocates the single coordinate
+  // instead of edit_vertex's ring-of-vertices machinery.
+  const editModeMap = { LineString: 'edit_line', Polygon: 'edit_polygon', Point: 'edit_point' }
+  const mode = existingFeature.geometry.type === 'Point' ? 'edit_point' : 'edit_vertex'
   eventBus.emit('draw:editstart', { mode: editModeMap[existingFeature.geometry.type] })
 
   const snapLayers = options.snapLayers === undefined ? (pluginConfig.snapLayers ?? null) : options.snapLayers
   draw.setSnapLayers(snapLayers)
   dispatch({ type: 'SET_HAS_SNAP_LAYERS', payload: snapLayers?.length > 0 })
 
-  draw.changeMode('edit_vertex', {
+  draw.changeMode(mode, {
     container: appState.layoutRefs.viewportRef.current,
     deleteVertexButtonId: `${appConfig.id}-draw-delete-point`,
     undoButtonId: `${appConfig.id}-draw-undo`,
@@ -42,11 +45,11 @@ export const editFeature = ({ appState, appConfig, mapState, pluginConfig, plugi
     payload: { feature, tempFeature: feature }
   })
 
-  dispatch({ type: 'SET_MODE', payload: 'edit_vertex' })
+  dispatch({ type: 'SET_MODE', payload: mode })
 
   // Seed the Done-button gate and the stroke from the feature's starting validity
   // so an already invalid feature opens dashed and cannot be "finished" until fixed.
-  const { valid } = validateGeometry(feature, { phase: 'edit-start', mode: 'edit_vertex' }, { onGeometryChange: draw._geometryValidator })
+  const { valid } = validateGeometry(feature, { phase: 'edit-start', mode }, { onGeometryChange: draw._geometryValidator })
   dispatch({ type: 'SET_GEOMETRY_VALID', payload: valid })
   draw.setInvalid?.(!valid)
 

package/plugins/draw/src/api/editFeature.test.js

@@ -74,6 +74,22 @@ describe('editFeature', () => {
     expect(eventBus.emit).toHaveBeenCalledWith('draw:editstart', { mode: 'edit_line' })
   })
 
+  // A Point has no ring of vertices — editing one goes through edit_point (relocate the
+  // single coordinate), not edit_vertex, across every mode-name site this function touches.
+  test('uses edit_point mode for a point feature', () => {
+    const { context, dispatch, eventBus, draw } = makeContext()
+    draw.get.mockReturnValue({ id: 'f1', geometry: { type: 'Point', coordinates: [0, 0] } })
+
+    editFeature(context, 'f1')
+
+    expect(eventBus.emit).toHaveBeenCalledWith('draw:editstart', { mode: 'edit_point' })
+    expect(draw.changeMode).toHaveBeenCalledWith('edit_point', expect.objectContaining({ featureId: 'f1' }))
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_MODE', payload: 'edit_point' })
+    // Point geometry is always valid (validation/rules.js has no Point branch) — the gate
+    // opens immediately, unlike a self-intersecting/zero-area polygon.
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_GEOMETRY_VALID', payload: true })
+  })
+
   test('stores a per-call onGeometryChange validator, overriding the plugin-level one', () => {
     const pluginOnGeometryChange = jest.fn()
     const onGeometryChange = jest.fn()

package/plugins/draw/src/api/newPoint.js

@@ -0,0 +1,42 @@
+import { SYMBOL_KEYS } from '../utils/symbolKeys.js'
+
+export const newPoint = ({ appState, appConfig, pluginConfig, pluginState, mapState, mapProvider, services }, featureId, options = {}) => {
+  const { dispatch } = pluginState
+  const { draw } = mapProvider
+  const { eventBus } = services
+
+  if (!draw) {
+    return
+  }
+
+  eventBus.emit('draw:started', { mode: 'draw_point' })
+
+  const snapLayers = options.snapLayers === undefined ? (pluginConfig.snapLayers ?? null) : options.snapLayers
+  draw.setSnapLayers(snapLayers)
+  dispatch({ type: 'SET_HAS_SNAP_LAYERS', payload: snapLayers?.length > 0 })
+
+  const { properties: customProperties, onGeometryChange, ...modeOptions } = options
+  // Per-call callback overrides the plugin-level one; events.js reads this on every commit.
+  draw._geometryValidator = onGeometryChange ?? pluginConfig.onGeometryChange
+
+  const symbolStyle = {}
+  SYMBOL_KEYS.forEach((key) => {
+    if (modeOptions[key] !== undefined) {
+      symbolStyle[key] = modeOptions[key]
+      delete modeOptions[key]
+    }
+  })
+
+  draw.changeMode('draw_point', {
+    container: appState.layoutRefs.viewportRef.current,
+    addVertexButtonId: `${appConfig.id}-draw-add-point`,
+    interfaceType: appState.interfaceType,
+    crossHair: mapState.crossHair,
+    getSnapEnabled: () => draw.isSnapEnabled(),
+    featureId,
+    ...modeOptions,
+    properties: { ...customProperties, ...symbolStyle }
+  })
+
+  dispatch({ type: 'SET_MODE', payload: 'draw_point' })
+}