@defra/interactive-map 0.0.40-alpha → 0.0.41-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/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' })
+}

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.
@@ -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

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')
@@ -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