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

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

@@ -0,0 +1,210 @@
+import {
+  getCoords,
+  getRingSegments,
+  getSegmentForIndex,
+  getModifiableCoords
+} from './geometryHelpers.js'
+import { KEYBOARD } from '../../defaults.js'
+import {
+  getSnapInstance, isSnapActive, isSnapEnabled, getSnapLngLat,
+  getSnapRadius, triggerSnapAtPoint, clearSnapIndicator
+} from '../../utils/snapHelpers.js'
+import { MIN_VERTICES } from '../../../../validation/rules.js'
+
+const ARROW_OFFSETS = { ArrowUp: [0, -1], ArrowDown: [0, 1], ArrowLeft: [-1, 0], ArrowRight: [1, 0] }
+
+export const vertexOperations = {
+  updateMidpoint (coordinates) {
+    setTimeout(() => {
+      this.map.getSource('mapbox-gl-draw-hot').setData({
+        type: 'Feature',
+        properties: { meta: 'midpoint', active: 'true', id: 'active-midpoint' },
+        geometry: { type: 'Point', coordinates }
+      })
+    }, 0)
+  },
+
+  updateVertex (state, direction) {
+    const [idx, type] = this.getVertexOrMidpoint(state, direction)
+    if (idx < 0 || !type) {
+      return
+    }
+    this.changeMode(state, { selectedVertexIndex: idx, selectedVertexType: type, ...(type === 'vertex' && { coordPath: this.getCoordPath(state, idx) }) })
+  },
+
+  getOffset (coord, e) {
+    const pt = this.map.project(coord)
+    const offset = e?.shiftKey ? KEYBOARD.nudgeAmount : KEYBOARD.stepAmount
+    const [dx, dy] = e ? ARROW_OFFSETS[e.key].map(v => v * offset) : [0, 0]
+    return this.map.unproject({ x: pt.x + dx, y: pt.y + dy })
+  },
+
+  getNewCoord (state, e) {
+    return this.getOffset(getCoords(this.getFeature(state.featureId))[state.selectedVertexIndex], e)
+  },
+
+  // Explicit-delta counterpart to getOffset, driven by a unit direction vector and
+  // MoveControl's own Precision toggle rather than a KeyboardEvent — used by
+  // nudgeVertexByDelta below.
+  getOffsetByDelta (coord, dx, dy, isLargeStep) {
+    const pt = this.map.project(coord)
+    const amount = isLargeStep ? KEYBOARD.stepAmount : KEYBOARD.nudgeAmount
+    return this.map.unproject({ x: pt.x + dx * amount, y: pt.y + dy * amount })
+  },
+
+  // Resolves the destination coordinate for a vertex nudge by (dx, dy) unit
+  // direction, applying snap or breaking out of an already-active one — shared by
+  // the keyboard arrow-key path (_keyboardMoveTarget) and MoveControl's
+  // explicit-delta path (nudgeVertexByDelta) so both snap identically. dx/dy are
+  // only needed for the snap-escape offset; getCandidate computes the raw,
+  // un-snapped destination the caller would otherwise have used.
+  resolveSnapTarget (state, dx, dy, currentCoord, getCandidate) {
+    const snap = getSnapInstance(this.map)
+
+    // Break out of an active snap by moving beyond the snap radius
+    if (isSnapEnabled(state) && state._isSnapped && snap) {
+      const offset = getSnapRadius(snap) + 1
+      const pt = this.map.project(currentCoord)
+      state._isSnapped = false
+      clearSnapIndicator(snap, this.map)
+      return this.map.unproject({ x: pt.x + dx * offset, y: pt.y + dy * offset })
+    }
+
+    const newCoord = getCandidate()
+    if (isSnapEnabled(state) && snap) {
+      triggerSnapAtPoint(snap, this.map, this.map.project(newCoord))
+      if (isSnapActive(snap)) {
+        state._isSnapped = true
+        return getSnapLngLat(snap)
+      }
+    }
+    state._isSnapped = false
+    return newCoord
+  },
+
+  // Moves the selected vertex by an explicit (dx, dy) unit direction — the entry
+  // point for MoveControl's D-pad (see mapProvider.activeMoveTarget in events.js),
+  // as opposed to moveVertexByKey's KeyboardEvent-driven path. Each call is treated
+  // as one complete, undoable action (no held-key sequencing, since a button click
+  // has no "held" state to batch the way arrow keys do) — but still honours snap
+  // via the shared resolveSnapTarget, same as keyboard nudging.
+  nudgeVertexByDelta (state, dx, dy, isLargeStep) {
+    if (state.selectedVertexType !== 'vertex' || state.selectedVertexIndex < 0) {
+      return
+    }
+    const feature = this.getFeature(state.featureId)
+    const currentCoord = feature && getCoords(feature)?.[state.selectedVertexIndex]
+    if (!currentCoord) {
+      return
+    }
+    const previousPosition = [...currentCoord]
+    const vertexIndex = state.selectedVertexIndex
+    const target = this.resolveSnapTarget(state, dx, dy, currentCoord, () => this.getOffsetByDelta(currentCoord, dx, dy, isLargeStep))
+    this.moveVertex(state, target)
+    this.pushUndo({ type: 'move_vertex', featureId: state.featureId, vertexIndex, previousPosition })
+  },
+
+  insertVertex (state, e) {
+    const midIdx = state.selectedVertexIndex - state.vertecies.length
+    const newCoord = this.getOffset(state.midpoints[midIdx], e)
+    const feature = this.getFeature(state.featureId)
+    const geojson = feature.toGeoJSON()
+
+    // Find which segment this midpoint belongs to and calculate insertion position
+    const segments = getRingSegments(feature)
+    let globalInsertIdx = midIdx + 1
+    let insertSegment = null
+    let localInsertIdx = 0
+
+    // Map midpoint index to segment and local position
+    let midpointCounter = 0
+    for (const seg of segments) {
+      // Must match getMidpoints calculation
+      const segMidpoints = seg.closed ? seg.length : seg.length - 1
+      if (midIdx < midpointCounter + segMidpoints) {
+        insertSegment = seg
+        localInsertIdx = (midIdx - midpointCounter) + 1
+        globalInsertIdx = seg.start + localInsertIdx
+        break
+      }
+      midpointCounter += segMidpoints
+    }
+
+    if (!insertSegment) { return }
+
+    const coords = getModifiableCoords(geojson, insertSegment.path)
+    coords.splice(localInsertIdx, 0, [newCoord.lng, newCoord.lat])
+    this._ctx.api.add(geojson)
+
+    this.pushUndo({ type: 'insert_vertex', featureId: state.featureId, vertexIndex: globalInsertIdx })
+    this.changeMode(state, { selectedVertexIndex: globalInsertIdx, selectedVertexType: 'vertex', coordPath: this.getCoordPath(state, globalInsertIdx) })
+  },
+
+  moveVertex (state, coord, options = {}) {
+    if (options.checkSnap && state.enableSnap !== false) {
+      const snap = this.map._snapInstance
+      if (snap?.snapStatus && snap.snapCoords?.length >= 2) {
+        coord = { lng: snap.snapCoords[0], lat: snap.snapCoords[1] }
+      }
+    }
+
+    const feature = this.getFeature(state.featureId)
+    const geojson = feature.toGeoJSON()
+    const segments = getRingSegments(feature)
+    const result = getSegmentForIndex(segments, state.selectedVertexIndex)
+    if (!result) { return }
+
+    const coords = getModifiableCoords(geojson, result.segment.path)
+    coords[result.localIdx] = [coord.lng, coord.lat]
+    this._ctx.api.add(geojson)
+    state.vertecies = this.getVerticies(state.featureId)
+
+    this.map.fire('draw.geometrychange', state.feature)
+  },
+
+  deleteVertex (state) {
+    const feature = this.getFeature(state.featureId)
+    if (!feature) {
+      return
+    }
+
+    const segments = getRingSegments(feature)
+    const result = getSegmentForIndex(segments, state.selectedVertexIndex)
+    if (!result) {
+      return
+    }
+
+    const { segment } = result
+    // Minimum vertices per segment (mapbox-gl-draw's internal representation is
+    // a closed ring for polygons, an open path for lines) — MIN_VERTICES is the
+    // single source for this threshold (validation/rules.js).
+    const minVertices = segment.closed ? MIN_VERTICES.Polygon : MIN_VERTICES.LineString
+    if (segment.length <= minVertices) {
+      return
+    }
+
+    // Save position for undo before deletion
+    const deletedPosition = [...state.vertecies[state.selectedVertexIndex]]
+    const deletedIndex = state.selectedVertexIndex
+
+    // Remove the coordinate directly rather than via this._ctx.api.trash(), which routes through
+    // DirectSelect.trash() and calls onSetup({ featureId }) with incomplete options, crashing event registration.
+    const coordPath = [...result.segment.path, result.localIdx].join('.')
+    feature.removeCoordinate(coordPath)
+    this.fireUpdate()
+    this.clearSelectedCoordinates()
+    feature.changed()
+    this._ctx.store.render()
+
+    // Push undo operation
+    this.pushUndo({
+      type: 'delete_vertex',
+      featureId: state.featureId,
+      vertexIndex: deletedIndex,
+      position: deletedPosition
+    })
+
+    // Clear selection after delete
+    this.changeMode(state, { selectedVertexIndex: -1, selectedVertexType: null })
+  }
+}

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

@@ -0,0 +1,167 @@
+import { createHarness, LINE } from './__helpers__/harness.js'
+
+describe('vertexOperations', () => {
+  test('updateMidpoint pushes point data to the hot source', () => {
+    jest.useFakeTimers()
+    const { ctx, map } = createHarness()
+    ctx.updateMidpoint([1, 2])
+    jest.runAllTimers()
+    expect(map.getSource).toHaveBeenCalledWith('mapbox-gl-draw-hot')
+  })
+
+  test('updateVertex changes mode for a valid target and no-ops otherwise', () => {
+    const { ctx, state, api } = createHarness()
+    state.selectedVertexIndex = 0
+    ctx.updateVertex(state, 'ArrowRight')
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({
+      selectedVertexIndex: expect.any(Number)
+    }))
+
+    api.changeMode.mockClear()
+    ctx.updateVertex({ featureId: 'missing', vertecies: [], selectedVertexIndex: -1 }, 'ArrowRight')
+    expect(api.changeMode).not.toHaveBeenCalled()
+
+    // A vertex target carries a coordPath; a midpoint target does not
+    jest.spyOn(ctx, 'getVertexOrMidpoint').mockReturnValueOnce([1, 'vertex'])
+    ctx.updateVertex(state, 'ArrowRight')
+    expect(api.changeMode.mock.calls.at(-1)[1].coordPath).toBeDefined()
+    jest.spyOn(ctx, 'getVertexOrMidpoint').mockReturnValueOnce([5, 'midpoint'])
+    ctx.updateVertex(state, 'ArrowRight')
+    expect(api.changeMode.mock.calls.at(-1)[1].coordPath).toBeUndefined()
+  })
+
+  test('getOffset applies step/nudge amounts and returns the coord unchanged without an event', () => {
+    const { ctx } = createHarness()
+    const stepped = ctx.getOffset([5, 5], { key: 'ArrowRight', shiftKey: false })
+    const nudged = ctx.getOffset([5, 5], { key: 'ArrowRight', shiftKey: true })
+    expect(stepped.lng).not.toBe(5)
+    expect(Math.abs(nudged.lng - 5)).toBeLessThan(Math.abs(stepped.lng - 5))
+    expect(ctx.getOffset([5, 5], null)).toEqual({ lng: 5, lat: 5 })
+  })
+
+  test('getNewCoord offsets the currently selected vertex', () => {
+    const { ctx, state } = createHarness()
+    state.selectedVertexIndex = 1
+    expect(ctx.getNewCoord(state, { key: 'ArrowRight', shiftKey: false })).toHaveProperty('lng')
+  })
+
+  test('getOffsetByDelta applies step/nudge amounts along an explicit direction, mirroring getOffset\'s shiftKey polarity', () => {
+    const { ctx } = createHarness()
+    const large = ctx.getOffsetByDelta([5, 5], 1, 0, true)
+    const small = ctx.getOffsetByDelta([5, 5], 1, 0, false)
+    expect(large.lng).not.toBe(5)
+    expect(Math.abs(small.lng - 5)).toBeLessThan(Math.abs(large.lng - 5))
+    expect(ctx.getOffsetByDelta([5, 5], 0, 0, true)).toEqual({ lng: 5, lat: 5 })
+  })
+
+  test('nudgeVertexByDelta moves the selected vertex and pushes a single undo entry, or no-ops for a midpoint/no selection', () => {
+    const { ctx, state, map } = createHarness()
+    state.selectedVertexIndex = 0
+    state.selectedVertexType = 'vertex'
+    const before = [...state.vertecies[0]]
+    ctx.nudgeVertexByDelta(state, 1, 0, true)
+    expect(state.vertecies[0]).not.toEqual(before)
+    expect(map._undoStack.pop()).toMatchObject({ type: 'move_vertex', vertexIndex: 0, previousPosition: before })
+
+    map._undoStack.clear()
+    ctx.nudgeVertexByDelta({ ...state, selectedVertexType: 'midpoint' }, 1, 0, true)
+    ctx.nudgeVertexByDelta({ ...state, selectedVertexIndex: -1 }, 1, 0, true)
+    // Passes the type/index guard but resolves to no coordinate — missing feature,
+    // and a valid feature with an out-of-range index.
+    ctx.nudgeVertexByDelta({ ...state, featureId: 'missing' }, 1, 0, true)
+    ctx.nudgeVertexByDelta({ ...state, selectedVertexIndex: 99 }, 1, 0, true)
+    expect(map._undoStack).toHaveLength(0)
+  })
+
+  test('nudgeVertexByDelta snaps to a nearby target, breaks out of an active snap, and falls back to the raw coord when snap is inactive — same as keyboard nudging (regression: MoveControl bypassed snap entirely before resolveSnapTarget was shared)', () => {
+    const { ctx, state, map } = createHarness()
+    state.selectedVertexIndex = 1
+    state.selectedVertexType = 'vertex'
+    state.getSnapEnabled = () => true
+
+    map._snapInstance = { status: true, snapStatus: true, snapCoords: [7, 8], snapToClosestPoint: jest.fn() }
+    ctx.nudgeVertexByDelta(state, 0, -1, true)
+    expect(state._isSnapped).toBe(true)
+    expect(state.vertecies[1]).toEqual([7, 8])
+
+    ctx.nudgeVertexByDelta(state, -1, 0, true) // already snapped → breaks out of the snap radius
+    expect(state._isSnapped).toBe(false)
+
+    map._snapInstance = { status: true, snapStatus: false, snapCoords: null, snapToClosestPoint: jest.fn() }
+    ctx.nudgeVertexByDelta(state, 1, 0, true) // snap enabled but inactive → raw offset coord
+    expect(state._isSnapped).toBe(false)
+  })
+
+  test('resolveSnapTarget is a no-op passthrough to the candidate coordinate when snap is disabled', () => {
+    const { ctx, state } = createHarness()
+    const candidate = { lng: 3, lat: 4 }
+    expect(ctx.resolveSnapTarget(state, 1, 0, [0, 0], () => candidate)).toEqual(candidate)
+  })
+
+  test('insertVertex splits a midpoint into a new vertex, records undo and selects it', () => {
+    const { ctx, state, api } = createHarness()
+    ctx.insertVertex({ ...state, selectedVertexIndex: state.vertecies.length, selectedVertexType: 'midpoint' }, { key: 'ArrowRight', shiftKey: false })
+    expect(api.add).toHaveBeenCalled()
+    expect(state.map ?? ctx.map._undoStack.length).toBeGreaterThan(0)
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({
+      selectedVertexType: 'vertex'
+    }))
+
+    // Also works for an open line segment
+    const line = createHarness(LINE())
+    line.ctx.insertVertex({ ...line.state, selectedVertexIndex: line.state.vertecies.length, selectedVertexType: 'midpoint' }, { key: 'ArrowRight', shiftKey: false })
+    expect(line.api.add).toHaveBeenCalled()
+  })
+
+  test('insertVertex bails out when the midpoint maps to no segment', () => {
+    const { ctx, state, api } = createHarness()
+    // midIdx beyond the segment's midpoint count, but with a defined midpoint coord
+    const badState = { ...state, selectedVertexIndex: state.vertecies.length + 4, midpoints: [...state.midpoints, [5, 5]] }
+    api.add.mockClear()
+    ctx.insertVertex(badState, { key: 'ArrowRight', shiftKey: false })
+    expect(api.add).not.toHaveBeenCalled()
+  })
+
+  test('moveVertex repositions a vertex, applies snap and guards an out-of-range index', () => {
+    const { ctx, state, map } = createHarness()
+    state.selectedVertexIndex = 0
+    ctx.moveVertex(state, { lng: 1, lat: 2 })
+    expect(state.vertecies[0]).toEqual([1, 2])
+
+    map._snapInstance = { snapStatus: true, snapCoords: [7, 8] }
+    ctx.moveVertex(state, { lng: 1, lat: 2 }, { checkSnap: true })
+    expect(state.vertecies[0]).toEqual([7, 8])
+
+    const before = [...state.vertecies]
+    ctx.moveVertex({ ...state, selectedVertexIndex: 99 }, { lng: 3, lat: 3 })
+    expect(ctx.getVerticies('feat-1')).toEqual(before)
+
+    // checkSnap requested but no active snap → coordinate used as-is
+    const h = createHarness()
+    h.ctx.moveVertex({ ...h.state, selectedVertexIndex: 0 }, { lng: 1, lat: 2 }, { checkSnap: true })
+    expect(h.ctx.getVerticies('feat-1')[0]).toEqual([1, 2])
+  })
+
+  test('deleteVertex removes a vertex, or no-ops for missing feature / bad index / minimum size', () => {
+    const { ctx, state, api } = createHarness()
+    ctx.deleteVertex({ ...state, featureId: 'missing' })
+    ctx.deleteVertex({ ...state, selectedVertexIndex: 99 })
+    expect(api.changeMode).not.toHaveBeenCalled()
+
+    const triangle = createHarness({ type: 'Polygon', coordinates: [[[0, 0], [10, 0], [5, 10], [0, 0]]] })
+    triangle.state.selectedVertexIndex = 0
+    triangle.ctx.deleteVertex(triangle.state) // 3 vertices → at minimum, rejected
+    expect(triangle.api.changeMode).not.toHaveBeenCalled()
+
+    state.selectedVertexIndex = 1
+    ctx.deleteVertex(state)
+    expect(ctx.map._undoStack.pop()).toMatchObject({ type: 'delete_vertex', vertexIndex: 1 })
+    expect(api.changeMode).toHaveBeenCalledWith('edit_vertex', expect.objectContaining({ selectedVertexIndex: -1 }))
+
+    // Also works on an open line segment
+    const line = createHarness(LINE())
+    line.state.selectedVertexIndex = 1
+    line.ctx.deleteVertex(line.state)
+    expect(line.ctx.getVerticies('feat-1')).toHaveLength(2)
+  })
+})

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

@@ -0,0 +1,121 @@
+import {
+  getCoords,
+  getRingSegments,
+  getSegmentForIndex
+} from './geometryHelpers.js'
+import { spatialNavigate } from '../../../../utils/spatial.js'
+
+export const vertexQueries = {
+  findVertexIndex (coords, targetCoord, currentIdx) {
+    // Search for vertex, preferring matches near currentIdx to handle duplicate coords (e.g., closing vertices)
+    const matches = []
+    coords.forEach((c, i) => {
+      if (c[0] === targetCoord[0] && c[1] === targetCoord[1]) {
+        matches.push(i)
+      }
+    })
+
+    if (matches.length === 0) { return -1 }
+    if (matches.length === 1) { return matches[0] }
+
+    // Multiple matches - pick closest to current selection
+    if (currentIdx >= 0) {
+      return matches.reduce((best, idx) =>
+        Math.abs(idx - currentIdx) < Math.abs(best - currentIdx) ? idx : best
+      , matches[0])
+    }
+    return matches[0]
+  },
+
+  getCoordPath (state, idx) {
+    const feature = this.getFeature(state.featureId)
+    if (!feature) { return '0' }
+
+    const segments = getRingSegments(feature)
+    const result = getSegmentForIndex(segments, idx)
+    if (!result) { return '0' }
+
+    const { segment, localIdx } = result
+    return [...segment.path, localIdx].join('.')
+  },
+
+  syncVertices (state) {
+    state.vertecies = this.getVerticies(state.featureId)
+    state.midpoints = this.getMidpoints(state.featureId)
+  },
+
+  getVerticies (featureId) {
+    return getCoords(this.getFeature(featureId))
+  },
+
+  getMidpoints (featureId) {
+    const feature = this.getFeature(featureId)
+    const coords = getCoords(feature)
+    const segments = getRingSegments(feature)
+    if (!coords?.length || !segments.length) {
+      return []
+    }
+
+    const midpoints = []
+    // Create midpoints within each segment, respecting boundaries
+    for (const seg of segments) {
+      // For closed rings, create midpoint between every vertex including last→first
+      // For open lines, create midpoints only between consecutive vertices (no wrap-around)
+      const count = seg.closed ? seg.length : seg.length - 1
+      for (let i = 0; i < count; i++) {
+        const idx = seg.start + i
+        const nextIdx = seg.start + ((i + 1) % seg.length)
+        const [x1, y1] = coords[idx]
+        const [x2, y2] = coords[nextIdx]
+        midpoints.push([(x1 + x2) / 2, (y1 + y2) / 2])
+      }
+    }
+    return midpoints
+  },
+
+  getVertexOrMidpoint (state, direction) {
+    // Ensure vertices and midpoints are populated
+    if (!state.vertecies?.length) {
+      state.vertecies = this.getVerticies(state.featureId)
+      state.midpoints = this.getMidpoints(state.featureId)
+    }
+    if (!state.vertecies?.length) {
+      return [-1, null]
+    }
+    const project = (p) => p ? Object.values(this.map.project(p)) : null
+    const pixels = [...state.vertecies.map(project), ...state.midpoints.map(project)].filter(Boolean)
+    if (!pixels.length) {
+      return [-1, null]
+    }
+    const start = pixels[state.selectedVertexIndex] || Object.values(this.map.project(this.map.getCenter()))
+    const idx = spatialNavigate(start, pixels, direction)
+    return [idx, idx < state.vertecies.length ? 'vertex' : 'midpoint']
+  },
+
+  getVertexIndexFromMidpoint (state, coordPath) {
+    const feature = this.getFeature(state.featureId)
+    const segments = getRingSegments(feature)
+    const parts = coordPath.split('.').map(Number)
+
+    // Find which segment this coord_path belongs to
+    let midpointOffset = 0
+    for (const seg of segments) {
+      const pathMatches = seg.path.every((val, idx) => val === parts[idx])
+      if (pathMatches && parts.length === seg.path.length + 1) {
+        // In DirectSelect, midpoint coord_path represents the insertion index
+        // The midpoint between vertex N and N+1 has coord_path ending in N+1
+        // So our flat midpoint index is one less than the coord_path index
+        const insertionIdx = parts[parts.length - 1]
+        const localMidpointIdx = insertionIdx > 0 ? insertionIdx - 1 : seg.length - 2
+        // Midpoints are indexed after all vertices
+        return state.vertecies.length + midpointOffset + localMidpointIdx
+      }
+      // Count midpoints in this segment (must match getMidpoints calculation)
+      const segMidpoints = seg.closed ? seg.length : seg.length - 1
+      midpointOffset += segMidpoints
+    }
+
+    // Fallback
+    return state.vertecies.length
+  }
+}

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

@@ -0,0 +1,73 @@
+import { createHarness, LINE } from './__helpers__/harness.js'
+
+describe('vertexQueries', () => {
+  test('findVertexIndex handles no, single and duplicate matches', () => {
+    const { ctx } = createHarness()
+    expect(ctx.findVertexIndex([[0, 0], [1, 1]], [9, 9], -1)).toBe(-1)
+    expect(ctx.findVertexIndex([[0, 0], [1, 1]], [1, 1], -1)).toBe(1)
+    expect(ctx.findVertexIndex([[0, 0], [1, 1], [0, 0]], [0, 0], 2)).toBe(2)
+    expect(ctx.findVertexIndex([[0, 0], [1, 1], [0, 0]], [0, 0], -1)).toBe(0)
+    expect(ctx.findVertexIndex([[0, 0], [1, 1], [0, 0]], [0, 0], 0)).toBe(0)
+  })
+
+  test('getCoordPath resolves an index, or returns "0" without a feature or segment', () => {
+    const { ctx, state } = createHarness()
+    expect(ctx.getCoordPath(state, 2)).toBe('0.2')
+    expect(ctx.getCoordPath(state, 99)).toBe('0')
+    expect(ctx.getCoordPath({ featureId: 'missing' }, 0)).toBe('0')
+  })
+
+  test('getVerticies / getMidpoints for closed rings, open lines and missing features', () => {
+    const { ctx } = createHarness()
+    expect(ctx.getVerticies('feat-1')).toHaveLength(4)
+    expect(ctx.getMidpoints('feat-1')).toHaveLength(4)
+    expect(ctx.getMidpoints('missing')).toEqual([])
+    const line = createHarness(LINE())
+    expect(line.ctx.getMidpoints('feat-1')).toHaveLength(2)
+  })
+
+  test('syncVertices refreshes the cached vertex and midpoint lists', () => {
+    const { ctx, state } = createHarness()
+    state.vertecies = []
+    state.midpoints = []
+    ctx.syncVertices(state)
+    expect(state.vertecies).toHaveLength(4)
+    expect(state.midpoints).toHaveLength(4)
+  })
+
+  test('getVertexOrMidpoint repopulates empty lists, navigates, and guards empty features', () => {
+    const { ctx, state } = createHarness()
+    state.vertecies = []
+    state.selectedVertexIndex = 0
+    const [idx, type] = ctx.getVertexOrMidpoint(state, 'ArrowRight')
+    expect(idx).toBeGreaterThanOrEqual(0)
+    expect(['vertex', 'midpoint']).toContain(type)
+
+    expect(ctx.getVertexOrMidpoint({ featureId: 'missing', vertecies: [] }, 'ArrowRight')).toEqual([-1, null])
+    expect(ctx.getVertexOrMidpoint({ ...state, vertecies: [null], midpoints: [], selectedVertexIndex: 0 }, 'ArrowRight')).toEqual([-1, null])
+
+    // Falls back to the map centre when the current index has no pixel, and can resolve a vertex target
+    const fresh = createHarness()
+    expect(fresh.ctx.getVertexOrMidpoint({ ...fresh.state, selectedVertexIndex: -1 }, 'ArrowRight')[0]).toBeGreaterThanOrEqual(0)
+    const types = new Set()
+    for (let s = 0; s < fresh.state.vertecies.length + fresh.state.midpoints.length; s++) {
+      for (const d of ['ArrowRight', 'ArrowLeft', 'ArrowUp', 'ArrowDown']) {
+        types.add(fresh.ctx.getVertexOrMidpoint({ ...fresh.state, selectedVertexIndex: s }, d)[1])
+      }
+    }
+    expect(types.has('vertex')).toBe(true)
+  })
+
+  test('getVertexIndexFromMidpoint maps coord paths (insertion index, wrap-around and fallback)', () => {
+    const { ctx, state, features } = createHarness()
+    expect(ctx.getVertexIndexFromMidpoint(state, '0.2')).toBe(5)
+    expect(ctx.getVertexIndexFromMidpoint(state, '0.0')).toBe(6)
+    expect(ctx.getVertexIndexFromMidpoint(state, '5.0')).toBe(4)
+
+    // Counts earlier segments for multi-part geometry (closed and open)
+    features.set('multipoly', { type: 'MultiPolygon', coordinates: [[[[0, 0], [1, 0], [1, 1], [0, 0]]], [[[5, 5], [6, 5], [6, 6], [5, 5]]]] })
+    expect(ctx.getVertexIndexFromMidpoint({ ...state, featureId: 'multipoly', vertecies: new Array(8).fill([0, 0]) }, '1.0.1')).toBeGreaterThan(8)
+    features.set('multiline', { type: 'MultiLineString', coordinates: [[[0, 0], [1, 1]], [[5, 5], [6, 6]]] })
+    expect(ctx.getVertexIndexFromMidpoint({ ...state, featureId: 'multiline', vertecies: new Array(4).fill([0, 0]) }, '1.1')).toBeGreaterThan(4)
+  })
+})