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

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/createNewShape.js

@@ -0,0 +1,41 @@
+import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+
+// Shared body for newLine/newPolygon — the two are identical except which draw_* mode they
+// enter, so that's the only thing parameterised here. Kept out of newPoint.js: a Point also
+// needs symbol-key extraction (see newPoint.js), a genuine difference, not just the mode string.
+export const createNewShape = (mode) => ({ 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 })
+
+  const snapLayers = options.snapLayers === undefined ? (pluginConfig.snapLayers ?? null) : options.snapLayers
+  draw.setSnapLayers(snapLayers)
+  dispatch({ type: 'SET_HAS_SNAP_LAYERS', payload: snapLayers?.length > 0 })
+
+  const { stroke, fill, strokeWidth, 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 properties = {
+    ...customProperties,
+    ...flattenStyleProperties({ stroke, fill, strokeWidth })
+  }
+
+  draw.changeMode(mode, {
+    container: appState.layoutRefs.viewportRef.current,
+    addVertexButtonId: `${appConfig.id}-draw-add-point`,
+    interfaceType: appState.interfaceType,
+    crossHair: mapState.crossHair,
+    getSnapEnabled: () => draw.isSnapEnabled(),
+    featureId,
+    ...modeOptions,
+    properties
+  })
+
+  dispatch({ type: 'SET_MODE', payload: mode })
+}

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

@@ -0,0 +1,63 @@
+import { createNewShape } from './createNewShape.js'
+import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+
+jest.mock('../utils/flattenStyleProperties.js', () => ({
+  flattenStyleProperties: jest.fn(() => ({ _flat: true }))
+}))
+
+const makeContext = (overrides = {}) => {
+  const dispatch = jest.fn()
+  const eventBus = { emit: jest.fn() }
+  const draw = { setSnapLayers: jest.fn(), changeMode: jest.fn(), isSnapEnabled: jest.fn(() => false) }
+  const context = {
+    appState: { layoutRefs: { viewportRef: { current: 'viewport' } }, interfaceType: 'mouse' },
+    appConfig: { id: 'app' },
+    pluginConfig: {},
+    pluginState: { dispatch },
+    mapState: { crossHair: true },
+    mapProvider: { draw },
+    services: { eventBus },
+    ...overrides
+  }
+  return { context, dispatch, eventBus, draw }
+}
+
+beforeEach(() => jest.clearAllMocks())
+
+describe('createNewShape', () => {
+  test('does nothing when there is no draw instance', () => {
+    const { context, eventBus } = makeContext({ mapProvider: { draw: null } })
+    createNewShape('draw_line')(context, 'f1')
+    expect(eventBus.emit).not.toHaveBeenCalled()
+  })
+
+  // newLine.js/newPolygon.js only ever differ by this one argument — everything else about
+  // the returned function's behaviour is already covered end-to-end by their own tests.
+  test('threads the given mode through every call site: started event, changeMode, SET_MODE', () => {
+    const { context, dispatch, eventBus, draw } = makeContext()
+    createNewShape('draw_custom')(context, 'f1')
+
+    expect(eventBus.emit).toHaveBeenCalledWith('draw:started', { mode: 'draw_custom' })
+    expect(draw.changeMode).toHaveBeenCalledWith('draw_custom', expect.objectContaining({ featureId: 'f1' }))
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_MODE', payload: 'draw_custom' })
+  })
+
+  test('flattens style properties into the mode-change payload', () => {
+    const { context, draw } = makeContext()
+    createNewShape('draw_line')(context, 'f1', { stroke: 'red', fill: 'blue', strokeWidth: 3, properties: { name: 'x' } })
+
+    expect(flattenStyleProperties).toHaveBeenCalledWith({ stroke: 'red', fill: 'blue', strokeWidth: 3 })
+    expect(draw.changeMode.mock.calls[0][1].properties).toEqual({ name: 'x', _flat: true })
+  })
+
+  test('two factory instances stay independent — one mode never leaks into the other', () => {
+    const { context: lineCtx, draw: lineDraw } = makeContext()
+    const { context: polyCtx, draw: polyDraw } = makeContext()
+
+    createNewShape('draw_line')(lineCtx, 'f1')
+    createNewShape('draw_polygon')(polyCtx, 'f2')
+
+    expect(lineDraw.changeMode).toHaveBeenCalledWith('draw_line', expect.anything())
+    expect(polyDraw.changeMode).toHaveBeenCalledWith('draw_polygon', expect.anything())
+  })
+})

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/newLine.js

@@ -1,41 +1,3 @@
-import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+import { createNewShape } from './createNewShape.js'
 
-// Near-identical to newPolygon.js, differing only in the 'draw_line'/'draw_polygon'
-// mode string — kept as two small, explicit entry points rather than one
-// mode-parameterised factory. Revisit if a third geometry type is ever added.
-export const newLine = ({ 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_line' })
-
-  const snapLayers = options.snapLayers === undefined ? (pluginConfig.snapLayers ?? null) : options.snapLayers
-  draw.setSnapLayers(snapLayers)
-  dispatch({ type: 'SET_HAS_SNAP_LAYERS', payload: snapLayers?.length > 0 })
-
-  const { stroke, fill, strokeWidth, 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 properties = {
-    ...customProperties,
-    ...flattenStyleProperties({ stroke, fill, strokeWidth })
-  }
-
-  draw.changeMode('draw_line', {
-    container: appState.layoutRefs.viewportRef.current,
-    addVertexButtonId: `${appConfig.id}-draw-add-point`,
-    interfaceType: appState.interfaceType,
-    crossHair: mapState.crossHair,
-    getSnapEnabled: () => draw.isSnapEnabled(),
-    featureId,
-    ...modeOptions,
-    properties
-  })
-
-  dispatch({ type: 'SET_MODE', payload: 'draw_line' })
-}
+export const newLine = createNewShape('draw_line')

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

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

@@ -0,0 +1,117 @@
+import { newPoint } from './newPoint.js'
+
+const makeContext = (overrides = {}) => {
+  const dispatch = jest.fn()
+  const eventBus = { emit: jest.fn() }
+  const draw = { setSnapLayers: jest.fn(), changeMode: jest.fn(), isSnapEnabled: jest.fn(() => false) }
+  const context = {
+    appState: { layoutRefs: { viewportRef: { current: 'viewport' } }, interfaceType: 'mouse' },
+    appConfig: { id: 'app' },
+    pluginConfig: { snapLayers: ['pc-layer'] },
+    pluginState: { dispatch },
+    mapState: { crossHair: true },
+    mapProvider: { draw },
+    services: { eventBus },
+    ...overrides
+  }
+  return { context, dispatch, eventBus, draw }
+}
+
+beforeEach(() => jest.clearAllMocks())
+
+describe('newPoint', () => {
+  test('does nothing when there is no draw instance', () => {
+    const { context, eventBus } = makeContext({ mapProvider: { draw: null } })
+    newPoint(context, 'f1')
+    expect(eventBus.emit).not.toHaveBeenCalled()
+  })
+
+  test('starts point placement, splitting symbol-config keys out of properties', () => {
+    const { context, dispatch, eventBus, draw } = makeContext()
+
+    newPoint(context, 'f1', {
+      symbol: 'pin',
+      symbolBackgroundColor: { outdoor: '#1d70b8' },
+      properties: { name: 'x' },
+      extra: 'opt'
+    })
+
+    expect(eventBus.emit).toHaveBeenCalledWith('draw:started', { mode: 'draw_point' })
+
+    expect(draw.changeMode).toHaveBeenCalledWith('draw_point', expect.objectContaining({
+      container: 'viewport',
+      addVertexButtonId: 'app-draw-add-point',
+      interfaceType: 'mouse',
+      crossHair: true,
+      featureId: 'f1',
+      extra: 'opt',
+      properties: { name: 'x', symbol: 'pin', symbolBackgroundColor: { outdoor: '#1d70b8' } }
+    }))
+
+    const opts = draw.changeMode.mock.calls[0][1]
+    expect(opts.getSnapEnabled()).toBe(false)
+    expect(draw.isSnapEnabled).toHaveBeenCalled()
+    // Symbol keys are pulled off modeOptions entirely, not just copied into properties.
+    expect(opts).not.toHaveProperty('symbol')
+    expect(opts).not.toHaveProperty('symbolBackgroundColor')
+
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_MODE', payload: 'draw_point' })
+  })
+
+  test('carries every recognised symbol-config key through to properties', () => {
+    const { context, draw } = makeContext()
+    const symbolStyle = {
+      symbol: 'pin',
+      symbolSvgContent: '<path/>',
+      symbolBackgroundColor: '#fff',
+      symbolForegroundColor: '#000',
+      symbolHaloWidth: 2,
+      symbolGraphic: 'g',
+      symbolViewBox: '0 0 10 10',
+      symbolAnchor: [0.5, 0.9]
+    }
+    newPoint(context, 'f1', symbolStyle)
+    expect(draw.changeMode.mock.calls[0][1].properties).toEqual(symbolStyle)
+  })
+
+  test('omits symbol-config keys entirely when none are supplied', () => {
+    const { context, draw } = makeContext()
+    newPoint(context, 'f1')
+    expect(draw.changeMode.mock.calls[0][1].properties).toEqual({})
+  })
+
+  test('prefers explicit option snapLayers and flags them', () => {
+    const { context, draw, dispatch } = makeContext()
+    newPoint(context, 'f1', { snapLayers: ['opt'] })
+    expect(draw.setSnapLayers).toHaveBeenCalledWith(['opt'])
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_HAS_SNAP_LAYERS', payload: true })
+  })
+
+  test('falls back to the plugin config snapLayers', () => {
+    const { context, draw } = makeContext()
+    newPoint(context, 'f1')
+    expect(draw.setSnapLayers).toHaveBeenCalledWith(['pc-layer'])
+  })
+
+  test('falls back to null when neither option nor config is set', () => {
+    const { context, draw, dispatch } = makeContext({ pluginConfig: {} })
+    newPoint(context, 'f1')
+    expect(draw.setSnapLayers).toHaveBeenCalledWith(null)
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_HAS_SNAP_LAYERS', payload: false })
+  })
+
+  test('stores a per-call onGeometryChange validator without leaking it into mode options', () => {
+    const { context, draw } = makeContext()
+    const onGeometryChange = jest.fn()
+    newPoint(context, 'f1', { onGeometryChange })
+    expect(draw._geometryValidator).toBe(onGeometryChange)
+    expect(draw.changeMode.mock.calls[0][1]).not.toHaveProperty('onGeometryChange')
+  })
+
+  test('falls back to the plugin-level onGeometryChange validator', () => {
+    const pluginOnGeometryChange = jest.fn()
+    const { context, draw } = makeContext({ pluginConfig: { onGeometryChange: pluginOnGeometryChange } })
+    newPoint(context, 'f1')
+    expect(draw._geometryValidator).toBe(pluginOnGeometryChange)
+  })
+})

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

@@ -1,41 +1,3 @@
-import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+import { createNewShape } from './createNewShape.js'
 
-// Near-identical to newLine.js, differing only in the 'draw_polygon'/'draw_line'
-// mode string — kept as two small, explicit entry points rather than one
-// mode-parameterised factory. Revisit if a third geometry type is ever added.
-export const newPolygon = ({ 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_polygon' })
-
-  const snapLayers = options.snapLayers === undefined ? (pluginConfig.snapLayers ?? null) : options.snapLayers
-  draw.setSnapLayers(snapLayers)
-  dispatch({ type: 'SET_HAS_SNAP_LAYERS', payload: snapLayers?.length > 0 })
-
-  const { stroke, fill, strokeWidth, 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 properties = {
-    ...customProperties,
-    ...flattenStyleProperties({ stroke, fill, strokeWidth })
-  }
-
-  draw.changeMode('draw_polygon', {
-    container: appState.layoutRefs.viewportRef.current,
-    addVertexButtonId: `${appConfig.id}-draw-add-point`,
-    interfaceType: appState.interfaceType,
-    crossHair: mapState.crossHair,
-    getSnapEnabled: () => draw.isSnapEnabled(),
-    featureId,
-    ...modeOptions,
-    properties
-  })
-
-  dispatch({ type: 'SET_MODE', payload: 'draw_polygon' })
-}
+export const newPolygon = createNewShape('draw_polygon')

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

@@ -0,0 +1,43 @@
+import { flattenStyleProperties } from '../utils/flattenStyleProperties.js'
+import { logger } from '../../../../src/services/logger.js'
+
+const STYLE_KEYS = new Set(['stroke', 'fill', 'strokeWidth'])
+
+// A partial patch — unlike addFeature.js building a whole new feature from scratch,
+// flattenStyleProperties would otherwise write stroke/fill/strokeWidth as explicit
+// `undefined` for any of the three the caller didn't mention, blanking out whatever that
+// feature already had.
+const definedOnly = (properties) => {
+  const result = {}
+  for (const [key, value] of Object.entries(properties)) {
+    if (value !== undefined) {
+      result[key] = value
+    }
+  }
+  return result
+}
+
+export const setStyle = ({ mapProvider, services }, featureId, styleChanges = {}) => {
+  const { draw } = mapProvider
+  const { eventBus } = services
+
+  if (!draw) {
+    return false
+  }
+
+  if (!draw.get(featureId)) {
+    logger.warn('setStyle: no feature found for id', featureId)
+    return false
+  }
+
+  const styleProps = {}
+  const symbolProps = {}
+  for (const [key, value] of Object.entries(styleChanges)) {
+    (STYLE_KEYS.has(key) ? styleProps : symbolProps)[key] = value
+  }
+  const properties = definedOnly({ ...flattenStyleProperties(styleProps), ...symbolProps })
+
+  draw.setStyle(featureId, properties)
+  eventBus.emit('draw:stylechange', { featureId, properties })
+  return true
+}

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

@@ -0,0 +1,75 @@
+import { setStyle } from './setStyle.js'
+import { logger } from '../../../../src/services/logger.js'
+
+jest.mock('../../../../src/services/logger.js', () => ({
+  logger: { warn: jest.fn(), error: jest.fn() }
+}))
+
+const setup = (draw) => {
+  const eventBus = { emit: jest.fn() }
+  return { context: { mapProvider: { draw }, services: { eventBus } }, eventBus }
+}
+
+beforeEach(() => jest.clearAllMocks())
+
+describe('setStyle', () => {
+  test('does nothing when there is no draw instance', () => {
+    const { context, eventBus } = setup(undefined)
+    expect(setStyle(context, 'a', { stroke: 'red' })).toBe(false)
+    expect(eventBus.emit).not.toHaveBeenCalled()
+  })
+
+  test('warns and does nothing for an id with no existing feature', () => {
+    const draw = { get: jest.fn(() => null), setStyle: jest.fn() }
+    const { context, eventBus } = setup(draw)
+    expect(setStyle(context, 'missing', { stroke: 'red' })).toBe(false)
+    expect(draw.setStyle).not.toHaveBeenCalled()
+    expect(eventBus.emit).not.toHaveBeenCalled()
+    expect(logger.warn).toHaveBeenCalledWith('setStyle: no feature found for id', 'missing')
+  })
+
+  test('flattens stroke/fill/strokeWidth and forwards symbol keys as-is', () => {
+    const draw = { get: jest.fn(() => ({ id: 'a' })), setStyle: jest.fn() }
+    const { context, eventBus } = setup(draw)
+
+    const result = setStyle(context, 'a', {
+      stroke: { outdoor: '#1d70b8', dark: '#4c9ed9' },
+      symbol: 'square',
+      symbolBackgroundColor: { outdoor: '#ca3535', dark: '#ffffff' }
+    })
+
+    const expected = {
+      stroke: '#1d70b8',
+      strokeOutdoor: '#1d70b8',
+      strokeDark: '#4c9ed9',
+      symbol: 'square',
+      symbolBackgroundColor: { outdoor: '#ca3535', dark: '#ffffff' }
+    }
+    expect(draw.setStyle).toHaveBeenCalledWith('a', expected)
+    expect(eventBus.emit).toHaveBeenCalledWith('draw:stylechange', { featureId: 'a', properties: expected })
+    expect(result).toBe(true)
+  })
+
+  // A partial patch — omitting fill/strokeWidth must leave whatever the feature already has
+  // alone, not blank them out to undefined.
+  test('only includes the style keys actually supplied, dropping the unset ones', () => {
+    const draw = { get: jest.fn(() => ({ id: 'a' })), setStyle: jest.fn() }
+    const { context } = setup(draw)
+    setStyle(context, 'a', { stroke: '#e6c700' })
+    expect(draw.setStyle).toHaveBeenCalledWith('a', { stroke: '#e6c700' })
+  })
+
+  test('drops keys explicitly passed as undefined, from both style and symbol props', () => {
+    const draw = { get: jest.fn(() => ({ id: 'a' })), setStyle: jest.fn() }
+    const { context } = setup(draw)
+    setStyle(context, 'a', { stroke: 'red', fill: undefined, symbol: 'pin', symbolBackgroundColor: undefined })
+    expect(draw.setStyle).toHaveBeenCalledWith('a', { stroke: 'red', symbol: 'pin' })
+  })
+
+  test('defaults styleChanges to {} and still resolves cleanly', () => {
+    const draw = { get: jest.fn(() => ({ id: 'a' })), setStyle: jest.fn() }
+    const { context } = setup(draw)
+    setStyle(context, 'a')
+    expect(draw.setStyle).toHaveBeenCalledWith('a', {})
+  })
+})