@defra/interactive-map 0.0.36-alpha → 0.0.38-alpha

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

@@ -0,0 +1,133 @@
+import {
+  getSnapInstance, isSnapEnabled, triggerSnapAtPoint, getSnapLngLat,
+  clearSnapState, clearSnapIndicator
+} from '../../utils/snapHelpers.js'
+import { coordPathToFlatIndex } from './geometryHelpers.js'
+import { isOnSVG } from './helpers.js'
+import { createTouchTarget, applyTouchTargetColors } from '../../../../utils/touchTarget.js'
+import { resolveColors } from '../../../../utils/resolveColors.js'
+
+export const applyTouchVertexColors = (el, mapStyle, pluginConfig = {}) => {
+  if (!el) { return }
+  const { editActive, editHalo, editVertex } = resolveColors(mapStyle, pluginConfig)
+  applyTouchTargetColors(el, { editActive, editHalo, editVertex })
+}
+
+export const touchHandlers = {
+  addTouchVertexTarget (state) {
+    state.touchVertexTarget = createTouchTarget(state.container)
+    applyTouchVertexColors(state.touchVertexTarget, this.map._drawCurrentMapStyle, this.map._drawPluginConfig)
+  },
+
+  updateTouchVertexTarget (state, point) {
+    if (point && state.interfaceType === 'touch' && state.selectedVertexIndex >= 0) {
+      Object.assign(state.touchVertexTarget.style, { display: 'block', top: `${point.y}px`, left: `${point.x}px` })
+    } else {
+      state.touchVertexTarget.style.display = 'none'
+    }
+  },
+
+  hideTouchVertexIndicator (state) {
+    state.touchVertexTarget.style.display = 'none'
+  },
+
+  onPointerevent (state, e) {
+    state.interfaceType = e.pointerType === 'touch' ? 'touch' : 'mouse'
+    state.isPanEnabled = true
+    if (e.pointerType === 'touch' && e.type === 'pointermove' && !isOnSVG(e.target.parentNode) && !state._ignorePointermoveDeselect) {
+      this.changeMode(state, { selectedVertexIndex: -1, selectedVertexType: null, coordPath: null })
+    }
+  },
+
+  // Empty stubs required by DirectSelect
+  onTouchStart () {},
+  onTouchMove () {},
+  onTouchEnd () {},
+
+  onTouchend (state) {
+    clearSnapState(getSnapInstance(this.map))
+    if (state?.featureId) {
+      this.syncVertices(state)
+
+      // Push undo for the move if touch actually moved
+      if (state._touchMoved && state._moveStartPosition && state._moveStartIndex !== undefined) {
+        this.pushUndo({
+          type: 'move_vertex',
+          featureId: state.featureId,
+          vertexIndex: state._moveStartIndex,
+          previousPosition: state._moveStartPosition
+        })
+      }
+      state._moveStartPosition = null
+      state._moveStartIndex = undefined
+      state._touchMoved = false
+    }
+  },
+
+  onTap (state, e) {
+    // Hide snap indicator on any tap
+    const snap = getSnapInstance(this.map)
+    if (snap) {
+      clearSnapIndicator(snap, this.map)
+    }
+
+    const meta = e.featureTarget?.properties.meta
+    const coordPath = e.featureTarget?.properties.coord_path
+
+    if (meta === 'vertex') {
+      const feature = this.getFeature(state.featureId)
+      const idx = coordPathToFlatIndex(feature, coordPath)
+      this.changeMode(state, {
+        selectedVertexIndex: idx,
+        selectedVertexType: 'vertex',
+        coordPath
+      })
+    } else if (meta === 'midpoint') {
+      this.insertVertex({ ...state, selectedVertexIndex: this.getVertexIndexFromMidpoint(state, coordPath), selectedVertexType: 'midpoint' })
+    } else {
+      this.clickNoTarget(state)
+    }
+  },
+
+  onTouchstart (state, e) {
+    clearSnapState(getSnapInstance(this.map))
+    // Always get fresh vertex data in case coordinates changed during previous edits
+    const freshVertices = this.getVerticies(state.featureId)
+    const vertex = freshVertices?.[state.selectedVertexIndex]
+    if (!vertex || !isOnSVG(e.target.parentNode)) {
+      return
+    }
+
+    // Save starting position for undo
+    state._moveStartPosition = [...vertex]
+    state._moveStartIndex = state.selectedVertexIndex
+    state._touchMoved = false
+
+    const touch = { x: e.touches[0].clientX, y: e.touches[0].clientY }
+    const style = window.getComputedStyle(state.touchVertexTarget)
+    state.deltaTarget = { x: touch.x - Number.parseFloat(style.left), y: touch.y - Number.parseFloat(style.top) }
+    const vertexPt = this.map.project(vertex)
+    state.deltaVertex = { x: (touch.x / state.scale) - vertexPt.x, y: (touch.y / state.scale) - vertexPt.y }
+  },
+
+  onTouchmove (state, e) {
+    if (state.selectedVertexIndex < 0 || !isOnSVG(e.target.parentNode)) {
+      return
+    }
+
+    state._touchMoved = true
+
+    const touch = { x: e.touches[0].clientX, y: e.touches[0].clientY }
+    const screenPt = { x: (touch.x / state.scale) - state.deltaVertex.x, y: (touch.y / state.scale) - state.deltaVertex.y }
+
+    let finalCoord = this.map.unproject(screenPt)
+    if (isSnapEnabled(state)) {
+      const snap = getSnapInstance(this.map)
+      triggerSnapAtPoint(snap, this.map, screenPt)
+      finalCoord = getSnapLngLat(snap) || finalCoord
+    }
+
+    this.moveVertex(state, finalCoord)
+    this.updateTouchVertexTarget(state, { x: touch.x - state.deltaTarget.x, y: touch.y - state.deltaTarget.y })
+  }
+}

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

@@ -0,0 +1,105 @@
+import { createHarness, svgTarget } from './__helpers__/harness.js'
+import { applyTouchVertexColors } from './touchHandlers.js'
+
+describe('touchHandlers', () => {
+  test('applyTouchVertexColors returns early for a null element and defaults the colour scheme', () => {
+    expect(() => applyTouchVertexColors(null, {})).not.toThrow()
+    const { state } = createHarness()
+    expect(() => applyTouchVertexColors(state.touchVertexTarget, null)).not.toThrow()
+  })
+
+  test('applyTouchVertexColors applies a pluginConfig override to the CSS custom properties', () => {
+    const el = document.createElement('div')
+    applyTouchVertexColors(el, { mapColorScheme: 'light' }, { editVertex: '#custom' })
+    expect(el.style.getPropertyValue('--draw-primary')).toBe('#custom')
+  })
+
+  test('addTouchVertexTarget resolves colours from map._drawPluginConfig', () => {
+    const { ctx, state, map } = createHarness()
+    map._drawPluginConfig = { editVertex: '#custom' }
+    ctx.addTouchVertexTarget(state)
+    expect(state.touchVertexTarget.style.getPropertyValue('--draw-primary')).toBe('#custom')
+  })
+
+  test('updateTouchVertexTarget shows the target for a touch selection and hides it otherwise', () => {
+    const { ctx, state } = createHarness()
+    state.interfaceType = 'touch'
+    state.selectedVertexIndex = 0
+    ctx.updateTouchVertexTarget(state, { x: 12, y: 34 })
+    expect(state.touchVertexTarget.style.display).toBe('block')
+    ctx.updateTouchVertexTarget(state, null)
+    expect(state.touchVertexTarget.style.display).toBe('none')
+  })
+
+  test('onPointerevent deselects on touch drag off the target, and just tracks the interface for mouse', () => {
+    const { ctx, state, api } = createHarness()
+    ctx.onPointerevent(state, { pointerType: 'mouse', type: 'pointermove', target: { parentNode: document.createElement('div') } })
+    expect(state.interfaceType).toBe('mouse')
+    expect(api.changeMode).not.toHaveBeenCalled()
+
+    state._ignorePointermoveDeselect = false
+    ctx.onPointerevent(state, { pointerType: 'touch', type: 'pointermove', target: { parentNode: document.createElement('div') } })
+    expect(state.interfaceType).toBe('touch')
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({ selectedVertexIndex: -1 }))
+  })
+
+  test('onTouchend records a move undo only when a touch move occurred', () => {
+    const { ctx, state, map } = createHarness()
+    ctx.onTouchend({ }) // no featureId → no-op
+    ctx.onTouchend({ ...state, _touchMoved: false }) // feature but no move → no undo
+    expect(map._undoStack.length).toBe(0)
+    state._touchMoved = true
+    state._moveStartPosition = [0, 0]
+    state._moveStartIndex = 1
+    ctx.onTouchend(state)
+    expect(map._undoStack.pop()).toMatchObject({ type: 'move_vertex', vertexIndex: 1 })
+  })
+
+  test('onTouchstart captures move start state, ignoring taps off the vertex/target', () => {
+    const { ctx, state } = createHarness()
+    ctx.onTouchstart(state, { target: { parentNode: document.createElement('div') }, touches: [{ clientX: 1, clientY: 1 }] })
+    expect(state._moveStartIndex).toBeUndefined()
+
+    state.selectedVertexIndex = 1
+    ctx.onTouchstart(state, { target: svgTarget(state), touches: [{ clientX: 20, clientY: 20 }] })
+    expect(state._moveStartIndex).toBe(1)
+    expect(state._touchMoved).toBe(false)
+  })
+
+  test('onTouchmove moves the selected vertex, honouring snap, and ignores non-target moves', () => {
+    const { ctx, state, map } = createHarness()
+    state.selectedVertexIndex = 1
+    ctx.onTouchstart(state, { target: svgTarget(state), touches: [{ clientX: 20, clientY: 20 }] })
+
+    ctx.onTouchmove(state, { target: { parentNode: document.createElement('div') }, touches: [{ clientX: 5, clientY: 5 }] })
+    expect(state.vertecies[1]).toEqual([10, 0]) // off-target move ignored
+    ctx.onTouchmove(state, { target: svgTarget(state), touches: [{ clientX: 30, clientY: 40 }] })
+
+    state.getSnapEnabled = () => true
+    map._snapInstance = { status: true, snapStatus: true, snapCoords: [7, 8], snapToClosestPoint: jest.fn() }
+    ctx.onTouchmove(state, { target: svgTarget(state), touches: [{ clientX: 50, clientY: 60 }] })
+    expect(state.vertecies[1]).toEqual([7, 8])
+
+    // Snap enabled but no snap point → falls back to the pointer position
+    map._snapInstance = { status: true, snapStatus: false, snapCoords: null, snapToClosestPoint: jest.fn() }
+    ctx.onTouchmove(state, { target: svgTarget(state), touches: [{ clientX: 35, clientY: 45 }] })
+    expect(state._touchMoved).toBe(true)
+  })
+
+  test('onTap clears the snap indicator, then selects a vertex, inserts on a midpoint, or clears with no target', () => {
+    const { ctx, state, api, map } = createHarness()
+    map._snapInstance = { status: true, snapStatus: true, snapCoords: [1, 1] }
+    ctx.onTap(state, { featureTarget: { properties: { meta: 'vertex', coord_path: '0.2' } } })
+    expect(map.getLayer).toHaveBeenCalledWith('snap-helper-circle')
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({ selectedVertexType: 'vertex' }))
+
+    api.changeMode.mockClear()
+    ctx.onTap(state, { featureTarget: { properties: { meta: 'midpoint', coord_path: '0.1' } } })
+    expect(api.add).toHaveBeenCalled() // insertVertex path
+
+    api.changeMode.mockClear()
+    map._snapInstance = null // no snap indicator to clear
+    ctx.onTap(state, { featureTarget: undefined })
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({ selectedVertexIndex: -1 }))
+  })
+})

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

@@ -0,0 +1,166 @@
+import {
+  getRingSegments,
+  getSegmentForIndex,
+  getModifiableCoords
+} from './geometryHelpers.js'
+import { scalePoint } from './helpers.js'
+
+// Map an undo-stack op type onto the geometry-change `phase` consumed by validation.
+const UNDO_OP_PHASE = {
+  move_vertex: 'commit-move',
+  insert_vertex: 'commit-insert',
+  delete_vertex: 'commit-delete'
+}
+
+// Undoing an op commits the inverse change (undo of a delete re-inserts, etc.),
+// so its re-validation reports the inverse phase.
+const UNDO_INVERSE_PHASE = {
+  move_vertex: 'commit-move',
+  insert_vertex: 'commit-delete',
+  delete_vertex: 'commit-insert'
+}
+
+export const undoHandlers = {
+  // Fire geometry change event (for external listeners)
+  fireGeometryChange (state) {
+    const feature = this.getFeature(state.featureId)
+    if (feature) {
+      this.map.fire('draw.update', {
+        features: [feature.toGeoJSON()],
+        action: 'change_coordinates'
+      })
+    }
+  },
+
+  // Emit a commit-level geometrychange (feature + change phase + vertex index) so the
+  // validation layer can accept or reject the change. Deferred a tick to avoid
+  // re-entrancy: rejection calls draw.undo(), which must run after the current
+  // mutation (and its undo bookkeeping) has fully settled.
+  emitGeometryValidation (phase, vertexIndex, featureId) {
+    if (!phase) { return }
+    setTimeout(() => {
+      const feature = this.getFeature(featureId)
+      if (!feature) { return }
+      this.map.fire('draw.geometrychange', { feature: feature.toGeoJSON(), phase, vertexIndex })
+    }, 0)
+  },
+
+  // Undo support
+  pushUndo (operation) {
+    const undoStack = this.map._undoStack
+    if (!undoStack) {
+      return
+    }
+    undoStack.push(operation)
+    // Every edit commit (move/insert/delete, via mouse or keyboard) records an undo
+    // op here, so this is the single point that feeds commit-level validation.
+    this.emitGeometryValidation(UNDO_OP_PHASE[operation.type], operation.vertexIndex, operation.featureId)
+  },
+
+  handleUndo (state) {
+    const undoStack = this.map._undoStack
+    if (!undoStack || undoStack.length === 0) {
+      return
+    }
+
+    const op = undoStack.pop()
+
+    if (op.type === 'move_vertex') {
+      this.undoMoveVertex(state, op)
+    } else if (op.type === 'insert_vertex') {
+      this.undoInsertVertex(state, op)
+    } else if (op.type === 'delete_vertex') {
+      this.undoDeleteVertex(state, op)
+    } else {
+      // No action
+    }
+    // An undo commits the inverse change, so it must re-validate like any other
+    // commit — otherwise the invalid stroke and the Done gate go stale.
+    this.emitGeometryValidation(UNDO_INVERSE_PHASE[op.type], op.vertexIndex, op.featureId)
+  },
+
+  undoMoveVertex (state, op) {
+    const { vertexIndex, previousPosition, featureId } = op
+    const feature = this.getFeature(featureId)
+    if (!feature) { return }
+
+    const geojson = feature.toGeoJSON()
+    const segments = getRingSegments(feature)
+    const result = getSegmentForIndex(segments, vertexIndex)
+    if (!result) { return }
+
+    const coords = getModifiableCoords(geojson, result.segment.path)
+    coords[result.localIdx] = previousPosition
+    this._applyUndoAndSync(state, geojson, featureId)
+
+    // Update touch vertex target position
+    const vertex = state.vertecies[state.selectedVertexIndex]
+    if (vertex) {
+      this.updateTouchVertexTarget(state, scalePoint(this.map.project(vertex), state.scale))
+    }
+  },
+
+  undoInsertVertex (state, op) {
+    const { vertexIndex, featureId } = op
+    const feature = this.getFeature(featureId)
+    if (!feature) { return }
+
+    const geojson = feature.toGeoJSON()
+    const segments = getRingSegments(feature)
+    const result = getSegmentForIndex(segments, vertexIndex)
+    if (!result) { return }
+
+    const coords = getModifiableCoords(geojson, result.segment.path)
+    coords.splice(result.localIdx, 1)
+    this._applyUndoAndSync(state, geojson, featureId)
+
+    // Clear DirectSelect's coordinate selection
+    this.clearSelectedCoordinates()
+    this.hideTouchVertexIndicator(state)
+    this.changeMode(state, { selectedVertexIndex: -1, selectedVertexType: null })
+  },
+
+  undoDeleteVertex (state, op) {
+    const { vertexIndex, position, featureId } = op
+    const feature = this.getFeature(featureId)
+    if (!feature) {
+      return
+    }
+
+    const geojson = feature.toGeoJSON()
+    const segments = getRingSegments(feature)
+
+    // Try to find segment containing vertexIndex
+    let result = getSegmentForIndex(segments, vertexIndex)
+
+    // If not found, vertex might be at segment boundary
+    if (!result) {
+      for (const seg of segments) {
+        if (vertexIndex === seg.start + seg.length) {
+          result = { segment: seg, localIdx: seg.length }
+          break
+        }
+      }
+    }
+
+    if (!result) {
+      return
+    }
+
+    const coords = getModifiableCoords(geojson, result.segment.path)
+    coords.splice(result.localIdx, 0, position)
+    this._applyUndoAndSync(state, geojson, featureId)
+
+    // Re-insertion always lands the vertex back at vertexIndex, so it is guaranteed present
+    this.updateTouchVertexTarget(state, scalePoint(this.map.project(state.vertecies[vertexIndex]), state.scale))
+    this.changeMode(state, { selectedVertexIndex: vertexIndex, selectedVertexType: 'vertex', coordPath: this.getCoordPath(state, vertexIndex) })
+  },
+
+  _applyUndoAndSync (state, geojson, featureId) {
+    this._ctx.api.add(geojson)
+    state.vertecies = this.getVerticies(featureId)
+    state.midpoints = this.getMidpoints(featureId)
+    this._ctx.store.render()
+    this.fireGeometryChange(state)
+  }
+}

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

@@ -0,0 +1,133 @@
+import { createHarness } from './__helpers__/harness.js'
+import { createUndoStack } from '../../../../utils/undoStack.js'
+import { getRingSegments } from './geometryHelpers.js'
+
+describe('undoHandlers', () => {
+  test('pushUndo is a no-op without a stack and pushes otherwise', () => {
+    const { ctx, map } = createHarness()
+    map._undoStack = null
+    expect(() => ctx.pushUndo({ type: 'move_vertex' })).not.toThrow()
+    map._undoStack = createUndoStack(() => {})
+    ctx.pushUndo({ type: 'move_vertex' })
+    expect(map._undoStack.length).toBe(1)
+  })
+
+  test('pushUndo emits a deferred commit-level geometrychange with the change phase', () => {
+    jest.useFakeTimers()
+    const { ctx, map } = createHarness()
+    map.fire.mockClear()
+
+    ctx.pushUndo({ type: 'move_vertex', featureId: 'feat-1', vertexIndex: 2 })
+    // Deferred a tick to avoid re-entrancy — nothing fired synchronously.
+    expect(map.fire).not.toHaveBeenCalledWith('draw.geometrychange', expect.anything())
+
+    jest.runAllTimers()
+    expect(map.fire).toHaveBeenCalledWith('draw.geometrychange', expect.objectContaining({
+      phase: 'commit-move',
+      vertexIndex: 2,
+      feature: expect.any(Object)
+    }))
+    jest.useRealTimers()
+  })
+
+  test('pushUndo does not emit a geometrychange for unmapped op types', () => {
+    jest.useFakeTimers()
+    const { ctx, map } = createHarness()
+    map.fire.mockClear()
+    ctx.pushUndo({ type: 'draw_vertex', featureId: 'feat-1' })
+    jest.runAllTimers()
+    expect(map.fire).not.toHaveBeenCalledWith('draw.geometrychange', expect.anything())
+    jest.useRealTimers()
+  })
+
+  test('emitGeometryValidation does not fire once the feature is gone', () => {
+    jest.useFakeTimers()
+    const { ctx, map } = createHarness()
+    map.fire.mockClear()
+    ctx.emitGeometryValidation('commit-move', 0, 'missing-feature')
+    jest.runAllTimers()
+    expect(map.fire).not.toHaveBeenCalledWith('draw.geometrychange', expect.anything())
+    jest.useRealTimers()
+  })
+
+  test('handleUndo ignores an empty stack and dispatches by operation type', () => {
+    const { ctx, state, map } = createHarness()
+    ctx.handleUndo(state) // empty → no throw
+    const spies = ['undoMoveVertex', 'undoInsertVertex', 'undoDeleteVertex'].map((m) => jest.spyOn(ctx, m).mockImplementation(() => {}))
+    map._undoStack.push({ type: 'move_vertex', featureId: 'feat-1', vertexIndex: 0, previousPosition: [0, 0] })
+    ctx.handleUndo(state)
+    map._undoStack.push({ type: 'insert_vertex', featureId: 'feat-1', vertexIndex: 1 })
+    ctx.handleUndo(state)
+    map._undoStack.push({ type: 'delete_vertex', featureId: 'feat-1', vertexIndex: 1, position: [0, 0] })
+    ctx.handleUndo(state)
+    expect(spies.every((s) => s.mock.calls.length === 1)).toBe(true)
+
+    map._undoStack.push({ type: 'unknown' })
+    expect(() => ctx.handleUndo(state)).not.toThrow()
+  })
+
+  test('handleUndo re-validates with the inverse change phase (undo of a delete re-inserts)', () => {
+    jest.useFakeTimers()
+    const { ctx, state, map } = createHarness()
+    jest.spyOn(ctx, 'undoDeleteVertex').mockImplementation(() => {})
+    map._undoStack.push({ type: 'delete_vertex', featureId: 'feat-1', vertexIndex: 1, position: [0, 0] })
+    map.fire.mockClear()
+    ctx.handleUndo(state)
+    jest.runAllTimers()
+    expect(map.fire).toHaveBeenCalledWith('draw.geometrychange', expect.objectContaining({
+      phase: 'commit-insert',
+      vertexIndex: 1,
+      feature: expect.any(Object)
+    }))
+    jest.useRealTimers()
+  })
+
+  test('fireGeometryChange fires draw.update only when the feature exists', () => {
+    const { ctx, state, map } = createHarness()
+    ctx.fireGeometryChange(state)
+    expect(map.fire).toHaveBeenCalledWith('draw.update', expect.objectContaining({ action: 'change_coordinates' }))
+    map.fire.mockClear()
+    ctx.fireGeometryChange({ featureId: 'missing' })
+    expect(map.fire).not.toHaveBeenCalled()
+  })
+
+  test('undoMoveVertex restores the previous position, guarding missing feature/segment', () => {
+    const { ctx, state } = createHarness()
+    ctx.undoMoveVertex({ ...state, featureId: 'missing' }, { vertexIndex: 0, previousPosition: [0, 0], featureId: 'missing' })
+    ctx.undoMoveVertex(state, { vertexIndex: 99, previousPosition: [0, 0], featureId: 'feat-1' })
+    state.selectedVertexIndex = 0
+    ctx.undoMoveVertex(state, { vertexIndex: 0, previousPosition: [3, 4], featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')[0]).toEqual([3, 4])
+
+    // Skips the touch target update when the selected vertex is gone
+    ctx.undoMoveVertex({ ...state, selectedVertexIndex: 99 }, { vertexIndex: 0, previousPosition: [1, 1], featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')[0]).toEqual([1, 1])
+  })
+
+  test('undoInsertVertex removes the inserted vertex and clears the selection', () => {
+    const { ctx, state, api } = createHarness()
+    ctx.undoInsertVertex(state, { vertexIndex: 1, featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')).toHaveLength(3)
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({ selectedVertexIndex: -1 }))
+
+    // Guards a missing feature and an out-of-range index
+    ctx.undoInsertVertex({ ...state, featureId: 'missing' }, { vertexIndex: 0, featureId: 'missing' })
+    ctx.undoInsertVertex(state, { vertexIndex: 999, featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')).toHaveLength(3)
+  })
+
+  test('undoDeleteVertex re-inserts, handling boundary, fallback and missing feature', () => {
+    const { ctx, state } = createHarness()
+    ctx.undoDeleteVertex({ ...state, featureId: 'missing' }, { vertexIndex: 0, position: [1, 1], featureId: 'missing' })
+    // Fallback: index far beyond any segment boundary → no result → no-op
+    ctx.undoDeleteVertex(state, { vertexIndex: 999, position: [1, 1], featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')).toHaveLength(4)
+    // Success: re-insert at index 1
+    ctx.undoDeleteVertex(state, { vertexIndex: 1, position: [1, 1], featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')).toHaveLength(5)
+    // Boundary: index === segment.start + segment.length
+    const seg = getRingSegments(ctx.getFeature('feat-1'))[0]
+    ctx.undoDeleteVertex(state, { vertexIndex: seg.start + seg.length, position: [2, 2], featureId: 'feat-1' })
+    expect(ctx.getVerticies('feat-1')).toHaveLength(6)
+  })
+})