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

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

package/plugins/draw/src/events.js

@@ -9,10 +9,17 @@ import { ADAPTER_EVENTS } from './adapterEvents.js'
 import { validateGeometry } from './validation/validateGeometry.js'
 import { MIN_VERTICES_REASONS } from './validation/rules.js'
 import { MAP_SIZE_SCALES } from './defaults.js'
+import { stripInternalProperties } from './utils/stripInternalProperties.js'
 
 const EDIT_VERTEX_MODE = 'edit_vertex'
 const GEOMETRY_INVALID_EVENT = 'draw:geometryinvalid'
 
+// edit_point behaves like edit_vertex for the two checks below (restore-on-cancel, live
+// invalid-stroke gating) — a relocate session, just with one coordinate instead of a ring.
+// enterEditVertexMode (below) stays edit_vertex-only — it's only ever reached for a shape
+// that finished invalid, and Point geometry has no such failure mode (see rules.js).
+const EDIT_MODES = new Set([EDIT_VERTEX_MODE, 'edit_point'])
+
 // A shape that simply hasn't reached its minimum vertex count yet isn't a mistake —
 // it's the normal, expected state of "still being drawn" — so it's excluded below
 // even though it's a genuine SOFT_RULES failure like any other.
@@ -29,8 +36,8 @@ const createGeometryInvalidEmitter = (eventBus, hints) => (payload) => {
   if (payload.reason && !isIncompleteShape(payload.reason)) { hints.show(payload.reason) }
 }
 
-// Claims MoveControl's D-pad for the currently selected vertex — see the generic
-// mapProvider.activeMoveTarget contract (MoveControl.jsx). Any plugin could use
+// Claims MoveControls' D-pad for the currently selected vertex — see the generic
+// mapProvider.activeMoveTarget contract (MoveControls.jsx). Any plugin could use
 // this slot; the draw plugin is just its first consumer.
 const buildVertexMoveTarget = (draw) => ({
   move: (dx, dy, isLargeStep) => draw.nudgeSelectedVertex(dx, dy, isLargeStep),
@@ -38,7 +45,7 @@ const buildVertexMoveTarget = (draw) => ({
 })
 
 // Vertex-selection handlers: sync pluginState.selectedVertexIndex, and claim/release
-// MoveControl's D-pad via buildVertexMoveTarget above.
+// MoveControls' D-pad via buildVertexMoveTarget above.
 const createVertexSelectionHandlers = ({ draw, pluginState, mapProvider, eventBus }) => ({
   onVertexSelection: (e) => {
     pluginState.dispatch({ type: 'SET_SELECTED_VERTEX_INDEX', payload: e })
@@ -86,10 +93,10 @@ function createHandlers ({ appState, appConfig, mapState, pluginState, mapProvid
     handleDone: () => { draw.done() },
     handleCancel: () => {
       const mode = draw.getMode()
-      if (mode === EDIT_VERTEX_MODE && tempFeature?.id) { draw.add(feature) }
+      if (EDIT_MODES.has(mode) && tempFeature?.id) { draw.add(feature) }
       pendingCreateId = null
       draw.cancel(); resetState()
-      eventBus.emit('draw:cancelled', feature)
+      eventBus.emit('draw:cancelled', stripInternalProperties(feature))
     },
     handleUndo: () => draw.undo(),
     handleDeleteVertex: () => draw.deleteVertex(),
@@ -104,11 +111,11 @@ function createHandlers ({ appState, appConfig, mapState, pluginState, mapProvid
       const { valid, reason } = validateGeometry(f, { phase: 'create', mode: draw.getMode() }, { onGeometryChange: draw._geometryValidator })
       if (!valid) {
         pendingCreateId = f.id
-        emitGeometryInvalid({ feature: f, reason, phase: 'create', mode: EDIT_VERTEX_MODE })
+        emitGeometryInvalid({ feature: stripInternalProperties(f), reason, phase: 'create', mode: EDIT_VERTEX_MODE })
         setTimeout(() => enterEditVertexMode({ draw, appState, appConfig, mapState, dispatch }, f.id), 0)
         return
       }
-      resetState(); setTimeout(() => draw.changeMode('disabled'), 0); eventBus.emit('draw:created', f)
+      resetState(); setTimeout(() => draw.changeMode('disabled'), 0); eventBus.emit('draw:created', stripInternalProperties(f))
     },
     onEditFinish: (f) => {
       resetState()
@@ -116,15 +123,15 @@ function createHandlers ({ appState, appConfig, mapState, pluginState, mapProvid
       // A shape that was drawn-then-fixed reports as a creation, not an edit.
       if (pendingCreateId && f.id === pendingCreateId) {
         pendingCreateId = null
-        eventBus.emit('draw:created', f)
+        eventBus.emit('draw:created', stripInternalProperties(f))
       } else {
-        eventBus.emit('draw:edited', f)
+        eventBus.emit('draw:edited', stripInternalProperties(f))
       }
     },
     onCancel: () => {},
     ...createVertexSelectionHandlers({ draw, pluginState, mapProvider, eventBus }),
     onUndoChange: (l) => { pluginState.dispatch({ type: 'SET_UNDO_STACK_LENGTH', payload: l }) },
-    onUpdate: (f) => { eventBus.emit('draw:updated', f) },
+    onUpdate: (f) => { eventBus.emit('draw:updated', stripInternalProperties(f)) },
     onGeometryChange: (e) => {
       // Only commit-level changes (commit-add/move/insert/delete) carry a `phase`.
       // Preview events (e.g. split's live preview) have none and are ignored.
@@ -141,17 +148,17 @@ function createHandlers ({ appState, appConfig, mapState, pluginState, mapProvid
       // The invalid stroke is committed-validity-driven in edit mode only; in draw
       // mode the adapters drive it live from the displayed geometry (placed
       // vertices + cursor) on every rubber-band move.
-      if (mode === EDIT_VERTEX_MODE) {
+      if (EDIT_MODES.has(mode)) {
         draw.setInvalid?.(!valid)
       }
       if (!valid) {
-        emitGeometryInvalid({ reason, ...context, feature: e.feature })
+        emitGeometryInvalid({ reason, ...context, feature: stripInternalProperties(e.feature) })
       }
     },
     // A vertex placement was rejected (hard rule or user callback veto). Surface it
     // on the public bus with phase 'place', and as a hint toast, so the reason is visible.
     onPlacementBlocked: (e) => {
-      emitGeometryInvalid(e)
+      emitGeometryInvalid({ ...e, feature: stripInternalProperties(e.feature) })
     },
     // Live (mid-drag) validity flip while editing — the displayed shape is exactly
     // what Done finishes there, so it gates the Done button in real time. Emitted
@@ -226,7 +233,7 @@ export function attachEvents ({ appState, appConfig, mapState, pluginState, mapP
   const resetState = () => {
     pluginState.dispatch({ type: 'SET_MODE', payload: null })
     pluginState.dispatch({ type: 'SET_FEATURE', payload: { feature: null, tempFeature: null } })
-    // Release MoveControl's D-pad back to panning the map whenever a draw/edit
+    // Release MoveControls' D-pad back to panning the map whenever a draw/edit
     // session ends — a stale claim here would silently hijack it for good.
     mapProvider.activeMoveTarget = null
   }

package/plugins/draw/src/events.test.js

@@ -88,6 +88,13 @@ describe('button handlers', () => {
     expect(mapProvider.activeMoveTarget).toBeNull()
   })
 
+  test('cancel re-adds the feature when cancelling a point edit too', () => {
+    const { buttonConfig, draw } = setup()
+    draw.getMode.mockReturnValue('edit_point')
+    buttonConfig.drawCancel.onClick()
+    expect(draw.add).toHaveBeenCalledWith({ id: 'F' })
+  })
+
   test('cancel does not re-add outside a vertex edit', () => {
     const { buttonConfig, draw } = setup()
     draw.getMode.mockReturnValue('draw_polygon')
@@ -172,7 +179,7 @@ describe('draw event handlers', () => {
     expect(() => drawHandler(draw, 'cancel')()).not.toThrow()
   })
 
-  test('vertexselection dispatches, emits, and claims mapProvider.activeMoveTarget for MoveControl', () => {
+  test('vertexselection dispatches, emits, and claims mapProvider.activeMoveTarget for MoveControls', () => {
     const { draw, dispatch, eventBus, mapProvider } = setup()
     drawHandler(draw, 'vertexselection')({ index: 2 })
     expect(dispatch).toHaveBeenCalledWith({ type: 'SET_SELECTED_VERTEX_INDEX', payload: { index: 2 } })
@@ -308,6 +315,13 @@ describe('geometrychange validation', () => {
     expect(draw.setInvalid).toHaveBeenCalledWith(true)
   })
 
+  test('drives the invalid stroke from committed validity in a point edit too', () => {
+    const { draw } = setup()
+    draw.getMode.mockReturnValue('edit_point')
+    drawHandler(draw, 'geometrychange')({ feature: squareFeature, phase: 'commit-move', vertexIndex: 0 })
+    expect(draw.setInvalid).toHaveBeenCalledWith(false)
+  })
+
   test('a live validity flip (edit drag) drives the Done gate', () => {
     const { draw, dispatch } = setup()
     drawHandler(draw, 'validitychange')({ valid: false, reason: 'Shape must not intersect itself' })

package/plugins/draw/src/manifest.js

@@ -2,8 +2,10 @@ import { initialState, actions } from './reducer.js'
 import { DrawInit } from './DrawInit.jsx'
 import { newPolygon } from './api/newPolygon.js'
 import { newLine } from './api/newLine.js'
+import { newPoint } from './api/newPoint.js'
 import { editFeature } from './api/editFeature.js'
 import { addFeature } from './api/addFeature.js'
+import { setStyle } from './api/setStyle.js'
 import { deleteFeature } from './api/deleteFeature.js'
 import { split } from './api/split.js'
 import { merge } from './api/merge.js'
@@ -11,6 +13,11 @@ import { isMac } from '../../../src/utils/isMac.js'
 
 const DRAW_ACTIONS_SLOT = 'top-middle'
 
+// edit_point behaves like edit_vertex for Done/Menu/Undo, but stays out of drawDeletePoint and mergeShapes (neither applies to a single coordinate).
+const EDIT_MODES = new Set(['edit_vertex', 'edit_point'])
+// .has(), not spread — [...aSet] can silently misbehave under a loose-mode Babel build (see OLDrawManager.js's emit()).
+const isEditMode = (mode) => EDIT_MODES.has(mode)
+
 // Show the platform-appropriate undo modifier (⌘ on macOS, Ctrl elsewhere).
 const undoCommand = isMac() ? '<kbd>Command</kbd> + <kbd>Z</kbd>' : '<kbd>Ctrl</kbd> + <kbd>Z</kbd>'
 
@@ -43,7 +50,7 @@ export const manifest = {
       variant: 'primary',
       exclusiveSlot: true,
       hiddenWhen: ({ appState, pluginState }) =>
-        !['draw_polygon', 'draw_line'].includes(pluginState.mode) || appState.interfaceType !== 'touch',
+        !['draw_polygon', 'draw_line', 'draw_point'].includes(pluginState.mode) || appState.interfaceType !== 'touch',
       // Disabled while placing at the crosshair would be vetoed (validatePlacement) —
       // driven live so the button never looks active when a tap would do nothing.
       enableWhen: ({ pluginState }) => pluginState.canAddPoint,
@@ -54,27 +61,30 @@ export const manifest = {
       label: 'Done',
       variant: 'primary',
       exclusiveSlot: true,
-      hiddenWhen: ({ pluginState }) => !['draw_polygon', 'draw_line', 'edit_vertex'].includes(pluginState.mode),
+      hiddenWhen: ({ pluginState }) => !(['draw_polygon', 'draw_line'].includes(pluginState.mode) || isEditMode(pluginState.mode)),
       enableWhen: ({ pluginState }) => {
         const { mode, geometryValid } = pluginState
         // Min-vertices, area and self-intersection are all enforced by the validation
         // rules via geometryValid, so the gate is simply "is the geometry valid now".
-        return ['draw_polygon', 'draw_line', 'edit_vertex'].includes(mode) && geometryValid
+        return (['draw_polygon', 'draw_line'].includes(mode) || isEditMode(mode)) && geometryValid
       },
       ...createButtonSlots(true)
     },
     {
       id: 'drawMenu',
-      label: ({ pluginState }) => pluginState.mode === 'edit_vertex' ? 'Edit actions' : 'Draw actions',
+      label: ({ pluginState }) => isEditMode(pluginState.mode) ? 'Edit actions' : 'Draw actions',
       iconId: 'menu',
       exclusiveSlot: true,
-      hiddenWhen: ({ pluginState }) => !['draw_polygon', 'draw_line', 'edit_vertex'].includes(pluginState.mode),
+      // draw_point belongs here too — it has no Undo (nothing to undo before a single-click
+      // commit, gated separately below) and no delete-vertex, but it DOES support snapping,
+      // and the Snap toggle is a menuItem living inside this same button.
+      hiddenWhen: ({ pluginState }) => !(['draw_polygon', 'draw_line', 'draw_point'].includes(pluginState.mode) || isEditMode(pluginState.mode)),
       menuItems: [
         {
           id: 'drawUndo',
           label: 'Undo',
           iconId: 'undo',
-          hiddenWhen: ({ pluginState }) => !['draw_polygon', 'draw_line', 'edit_vertex'].includes(pluginState.mode),
+          hiddenWhen: ({ pluginState }) => !(['draw_polygon', 'draw_line'].includes(pluginState.mode) || isEditMode(pluginState.mode)),
           enableWhen: ({ pluginState }) => {
             if (['draw_polygon', 'draw_line'].includes(pluginState.mode)) {
               return pluginState.numVertices > 0
@@ -161,8 +171,10 @@ export const manifest = {
   api: {
     newPolygon,
     newLine,
+    newPoint,
     editFeature,
     addFeature,
+    setStyle,
     deleteFeature,
     split,
     merge

package/plugins/draw/src/manifest.test.js

@@ -9,7 +9,7 @@ describe('manifest structure', () => {
     expect(manifest.reducer).toHaveProperty('actions')
     expect(manifest.InitComponent).toBeDefined()
     expect(Object.keys(manifest.api)).toEqual(expect.arrayContaining([
-      'newPolygon', 'newLine', 'editFeature', 'addFeature', 'deleteFeature', 'split', 'merge'
+      'newPolygon', 'newLine', 'newPoint', 'editFeature', 'addFeature', 'setStyle', 'deleteFeature', 'split', 'merge'
     ]))
   })
 })
@@ -44,12 +44,14 @@ describe('drawDone', () => {
   test('is hidden outside draw/edit modes', () => {
     expect(btn().hiddenWhen({ pluginState: { mode: null } })).toBe(true)
     expect(btn().hiddenWhen({ pluginState: { mode: 'draw_polygon' } })).toBe(false)
+    expect(btn().hiddenWhen({ pluginState: { mode: 'edit_point' } })).toBe(false)
   })
 
   test('enables in a draw/edit mode only when the geometry is valid', () => {
     expect(btn().enableWhen({ pluginState: { mode: 'draw_polygon', geometryValid: true } })).toBe(true)
     expect(btn().enableWhen({ pluginState: { mode: 'draw_line', geometryValid: true } })).toBe(true)
     expect(btn().enableWhen({ pluginState: { mode: 'edit_vertex', geometryValid: true } })).toBe(true)
+    expect(btn().enableWhen({ pluginState: { mode: 'edit_point', geometryValid: true } })).toBe(true)
     expect(btn().enableWhen({ pluginState: { mode: 'disabled', geometryValid: true } })).toBe(false)
   })
 
@@ -57,6 +59,7 @@ describe('drawDone', () => {
     expect(btn().enableWhen({ pluginState: { mode: 'draw_polygon', geometryValid: false } })).toBe(false)
     expect(btn().enableWhen({ pluginState: { mode: 'draw_line', geometryValid: false } })).toBe(false)
     expect(btn().enableWhen({ pluginState: { mode: 'edit_vertex', geometryValid: false } })).toBe(false)
+    expect(btn().enableWhen({ pluginState: { mode: 'edit_point', geometryValid: false } })).toBe(false)
   })
 })
 
@@ -66,12 +69,24 @@ describe('drawMenu', () => {
     expect(findButton('drawMenu').hiddenWhen({ pluginState: { mode: 'edit_vertex' } })).toBe(false)
   })
 
+  // draw_point has no Undo and no delete-vertex, but it does support snapping, and Snap is
+  // a menuItem inside this same button — so the button itself must stay visible for it even
+  // though drawUndo/drawDeletePoint (below) correctly keep excluding it.
+  test('is visible during draw_point, for the Snap toggle, even though it has no undo/delete', () => {
+    expect(findButton('drawMenu').hiddenWhen({ pluginState: { mode: 'draw_point' } })).toBe(false)
+  })
+
   test('labels "Edit actions" in edit mode, "Draw actions" otherwise', () => {
     expect(findButton('drawMenu').label({ pluginState: { mode: 'edit_vertex' } })).toBe('Edit actions')
+    expect(findButton('drawMenu').label({ pluginState: { mode: 'edit_point' } })).toBe('Edit actions')
     expect(findButton('drawMenu').label({ pluginState: { mode: 'draw_polygon' } })).toBe('Draw actions')
     expect(findButton('drawMenu').label({ pluginState: { mode: 'draw_line' } })).toBe('Draw actions')
   })
 
+  test('is visible during edit_point', () => {
+    expect(findButton('drawMenu').hiddenWhen({ pluginState: { mode: 'edit_point' } })).toBe(false)
+  })
+
   describe('drawUndo', () => {
     const item = () => findMenuItem('drawMenu', 'drawUndo')
 
@@ -80,11 +95,21 @@ describe('drawMenu', () => {
       expect(item().hiddenWhen({ pluginState: { mode: 'draw_line' } })).toBe(false)
     })
 
+    test('is visible in edit_point', () => {
+      expect(item().hiddenWhen({ pluginState: { mode: 'edit_point' } })).toBe(false)
+    })
+
+    test('stays hidden for draw_point — nothing to undo before a single-click commit', () => {
+      expect(item().hiddenWhen({ pluginState: { mode: 'draw_point' } })).toBe(true)
+    })
+
     test('enables from vertex count while drawing and from the undo stack while editing', () => {
       expect(item().enableWhen({ pluginState: { mode: 'draw_polygon', numVertices: 1 } })).toBe(true)
       expect(item().enableWhen({ pluginState: { mode: 'draw_polygon', numVertices: 0 } })).toBe(false)
       expect(item().enableWhen({ pluginState: { mode: 'edit_vertex', undoStackLength: 2 } })).toBe(true)
       expect(item().enableWhen({ pluginState: { mode: 'edit_vertex', undoStackLength: 0 } })).toBe(false)
+      expect(item().enableWhen({ pluginState: { mode: 'edit_point', undoStackLength: 1 } })).toBe(true)
+      expect(item().enableWhen({ pluginState: { mode: 'edit_point', undoStackLength: 0 } })).toBe(false)
     })
   })
 
@@ -111,6 +136,12 @@ describe('drawMenu', () => {
       expect(item().hiddenWhen({ pluginState: { mode: 'edit_vertex' } })).toBe(false)
     })
 
+    // Deliberately excluded from edit_point — deleting a point's one coordinate is deleting
+    // the whole feature (deleteFeature's job), not a per-vertex action.
+    test('stays hidden for edit_point', () => {
+      expect(item().hiddenWhen({ pluginState: { mode: 'edit_point' } })).toBe(true)
+    })
+
     test('enables only with a selection and enough vertices (polygon vs line)', () => {
       expect(item().enableWhen({ pluginState: { selectedVertexIndex: -1 } })).toBe(false)
       expect(item().enableWhen({ pluginState: { selectedVertexIndex: 0, feature: { geometry: { type: 'Polygon' } }, numVertices: 4 } })).toBe(true)

package/plugins/draw/src/reducer.test.js

@@ -77,6 +77,13 @@ describe('SET_UNDO_STACK_LENGTH', () => {
   })
 })
 
+describe('SET_GEOMETRY_VALID', () => {
+  test('coerces the payload to a boolean', () => {
+    expect(actions.SET_GEOMETRY_VALID(initialState, false).geometryValid).toBe(false)
+    expect(actions.SET_GEOMETRY_VALID(initialState, 1).geometryValid).toBe(true)
+  })
+})
+
 describe('SET_CAN_ADD_POINT', () => {
   test('coerces the payload to a boolean', () => {
     expect(actions.SET_CAN_ADD_POINT(initialState, false).canAddPoint).toBe(false)

package/plugins/draw/src/utils/stripInternalProperties.js

@@ -0,0 +1,19 @@
+import { SYMBOL_KEYS } from './symbolKeys.js'
+
+// Drops adapter-derived bookkeeping from a feature before it reaches a public event:
+// symbol* keys not in SYMBOL_KEYS (e.g. symbolImageId, symbolPixelRatio), and `sortKey`
+// (drives fill/line/symbol-sort-key render order — see MaplibreDrawAdapter.js — never
+// caller-supplied or meaningful application data).
+export const stripInternalProperties = (feature) => {
+  if (!feature?.properties) {
+    return feature
+  }
+  const properties = {}
+  for (const [key, value] of Object.entries(feature.properties)) {
+    const isInternal = key === 'sortKey' || (key.startsWith('symbol') && !SYMBOL_KEYS.has(key))
+    if (!isInternal) {
+      properties[key] = value
+    }
+  }
+  return { ...feature, properties }
+}

package/plugins/draw/src/utils/stripInternalProperties.test.js

@@ -0,0 +1,50 @@
+import { stripInternalProperties } from './stripInternalProperties.js'
+
+describe('stripInternalProperties', () => {
+  test('drops adapter-derived symbol* keys not in SYMBOL_KEYS', () => {
+    const feature = {
+      id: 'a',
+      properties: {
+        symbol: 'pin',
+        symbolBackgroundColor: '#ca3535',
+        symbolImageId: 'symbol-abc-2x',
+        symbolIconAnchor: 'bottom',
+        symbolIconOffset: [0, -10],
+        symbolPixelRatio: 2,
+        symbolActiveImageId: 'symbol-act-abc-2x',
+        symbolSelectedImageId: 'symbol-sel-abc-2x'
+      }
+    }
+
+    expect(stripInternalProperties(feature)).toEqual({
+      id: 'a',
+      properties: { symbol: 'pin', symbolBackgroundColor: '#ca3535' }
+    })
+  })
+
+  test('drops the internal sortKey property', () => {
+    const feature = { id: 'a', properties: { label: 'My point', sortKey: 3 } }
+    expect(stripInternalProperties(feature)).toEqual({ id: 'a', properties: { label: 'My point' } })
+  })
+
+  test('leaves non-symbol-prefixed properties untouched', () => {
+    const feature = { id: 'a', properties: { label: 'My point', stroke: '#1d70b8' } }
+    expect(stripInternalProperties(feature)).toEqual(feature)
+  })
+
+  test('does not mutate the original feature', () => {
+    const feature = { id: 'a', properties: { symbol: 'pin', symbolImageId: 'x' } }
+    stripInternalProperties(feature)
+    expect(feature.properties.symbolImageId).toBe('x')
+  })
+
+  test('returns the feature unchanged when it has no properties', () => {
+    const feature = { id: 'a', geometry: { type: 'Point', coordinates: [0, 0] } }
+    expect(stripInternalProperties(feature)).toBe(feature)
+  })
+
+  test('returns null/undefined as-is', () => {
+    expect(stripInternalProperties(null)).toBeNull()
+    expect(stripInternalProperties(undefined)).toBeUndefined()
+  })
+})

package/plugins/draw/src/utils/symbolKeys.js

@@ -0,0 +1,5 @@
+// Public symbol-config keys a caller can set on a Point (see docs/api/symbol-config.md).
+export const SYMBOL_KEYS = new Set([
+  'symbol', 'symbolSvgContent', 'symbolBackgroundColor', 'symbolForegroundColor',
+  'symbolHaloWidth', 'symbolGraphic', 'symbolViewBox', 'symbolAnchor'
+])