@defra/interactive-map 0.0.30-alpha → 0.0.32-alpha

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

@@ -2,11 +2,10 @@ import { attachEvents } from './events.js'
 
 const MOCK_POINT = { x: 1, y: 2 }
 const MOCK_COORDS = [1, 2]
-const INTERACT_DONE = 'interact:done'
 
 const createParams = () => {
   const appState = { layoutRefs: { viewportRef: { current: document.body } }, disabledButtons: new Set() }
-  const pluginState = { dispatch: jest.fn(), selectionBounds: null, selectedFeatures: [], selectedMarkers: [], closeOnAction: true, multiSelect: false }
+  const pluginState = { dispatch: jest.fn(), selectedFeatures: [], selectedMarkers: [], multiSelect: false }
   const clickReadyRef = { current: false }
   return {
     appState,
@@ -18,11 +17,10 @@ const createParams = () => {
       markers: { remove: jest.fn(), getMarker: jest.fn(() => null) },
       crossHair: { getDetail: jest.fn(() => ({ point: { x: 0, y: 0 }, coords: [0, 0] })) }
     },
-    buttonConfig: { selectDone: {}, selectAtTarget: {}, selectCancel: {} },
+    buttonConfig: { selectAtTarget: {} },
     events: { MAP_CLICK: 'map:click' },
     eventBus: { on: jest.fn(), off: jest.fn(), emit: jest.fn() },
-    handleInteraction: jest.fn(),
-    closeApp: jest.fn()
+    handleInteraction: jest.fn()
   }
 }
 
@@ -109,102 +107,6 @@ describe('attachEvents — click handling', () => {
   })
 })
 
-describe('attachEvents — button actions', () => {
-  let cleanup = null
-
-  beforeEach(() => { jest.useFakeTimers() })
-  afterEach(() => { cleanup?.(); jest.useRealTimers() })
-
-  it('selectDone emits correct payload and respects closeOnAction', () => {
-    const params = createParams()
-    cleanup = attachEvents(params)
-
-    params.mapState.markers.getMarker.mockReturnValue({ coords: MOCK_COORDS })
-    params.buttonConfig.selectDone.onClick()
-    expect(params.closeApp).toHaveBeenCalled()
-
-    params.closeApp.mockClear()
-    params.pluginState.closeOnAction = false
-    params.buttonConfig.selectDone.onClick()
-    expect(params.closeApp).not.toHaveBeenCalled()
-  })
-
-  it('selectDone emits selectedFeatures and selectionBounds when no marker', () => {
-    const params = createParams()
-    cleanup = attachEvents(params)
-
-    params.pluginState.selectedFeatures = [{ id: 'f1' }]
-    params.pluginState.selectionBounds = { sw: [0, 0], ne: [1, 1] }
-    params.buttonConfig.selectDone.onClick()
-
-    expect(params.eventBus.emit).toHaveBeenCalledWith(INTERACT_DONE, {
-      selectedFeatures: [{ id: 'f1' }],
-      selectionBounds: { sw: [0, 0], ne: [1, 1] }
-    })
-  })
-
-  it('selectDone includes selectedMarkers in payload when present', () => {
-    const params = createParams()
-    cleanup = attachEvents(params)
-
-    params.pluginState.selectedMarkers = ['m1', 'm2']
-    params.buttonConfig.selectDone.onClick()
-
-    expect(params.eventBus.emit).toHaveBeenCalledWith(INTERACT_DONE,
-      expect.objectContaining({ selectedMarkers: ['m1', 'm2'] })
-    )
-  })
-
-  it('selectDone omits selectedMarkers from payload when empty', () => {
-    const params = createParams()
-    cleanup = attachEvents(params)
-
-    params.buttonConfig.selectDone.onClick()
-
-    const payload = params.eventBus.emit.mock.calls.find(c => c[0] === INTERACT_DONE)[1]
-    expect(payload).not.toHaveProperty('selectedMarkers')
-  })
-
-  it('does not emit or closeApp if selectDone button is disabled', () => {
-    const params = createParams()
-    cleanup = attachEvents(params)
-
-    params.appState.disabledButtons.add('selectDone')
-    params.buttonConfig.selectDone.onClick()
-
-    expect(params.eventBus.emit).not.toHaveBeenCalled()
-    expect(params.closeApp).not.toHaveBeenCalled()
-  })
-
-  it('selectCancel emits cancel and respects closeOnAction', () => {
-    const params = createParams()
-    cleanup = attachEvents(params)
-
-    params.buttonConfig.selectCancel.onClick()
-    expect(params.closeApp).toHaveBeenCalled()
-
-    cleanup()
-    const params2 = createParams()
-    cleanup = attachEvents(params2)
-    params2.pluginState.closeOnAction = false
-    params2.buttonConfig.selectCancel.onClick()
-    expect(params2.closeApp).not.toHaveBeenCalled()
-  })
-
-  it('respects default closeOnAction when value is nullish', () => {
-    const params = createParams()
-    params.pluginState.closeOnAction = null
-    cleanup = attachEvents(params)
-
-    params.buttonConfig.selectDone.onClick()
-    expect(params.closeApp).toHaveBeenCalledTimes(1)
-
-    params.closeApp.mockClear()
-    params.buttonConfig.selectCancel.onClick()
-    expect(params.closeApp).toHaveBeenCalledTimes(1)
-  })
-})
-
 describe('attachEvents — programmatic selection', () => {
   let cleanup = null
 
@@ -232,7 +134,7 @@ describe('attachEvents — cleanup', () => {
     const params = createParams()
     const cleanup = attachEvents(params)
     cleanup()
-    Object.values(params.buttonConfig).forEach(btn => expect(btn.onClick).toBeNull())
+    expect(params.buttonConfig.selectAtTarget.onClick).toBeNull()
     jest.useRealTimers()
   })
 })

package/plugins/interact/src/hooks/useAttachEvents.js

@@ -2,7 +2,7 @@ import { useEffect, useRef } from 'react'
 import { EVENTS } from '../../../../src/config/events.js'
 import { attachEvents } from '../events.js'
 
-export function useAttachEvents ({ pluginState, appState, mapState, buttonConfig, eventBus, handleInteraction, closeApp }) {
+export function useAttachEvents ({ pluginState, appState, mapState, buttonConfig, eventBus, handleInteraction }) {
   // Refs updated synchronously each render — keeps callbacks fresh without re-attaching events
   const handleInteractionRef = useRef(handleInteraction)
   handleInteractionRef.current = handleInteraction
@@ -37,10 +37,9 @@ export function useAttachEvents ({ pluginState, appState, mapState, buttonConfig
       events: EVENTS,
       eventBus,
       handleInteraction: (event) => handleInteractionRef.current(event),
-      clickReadyRef,
-      closeApp
+      clickReadyRef
     })
 
     return cleanupEvents
-  }, [pluginState.enabled, buttonConfig, eventBus, closeApp])
+  }, [pluginState.enabled, buttonConfig, eventBus])
 }

package/plugins/interact/src/hooks/useAttachEvents.test.js

@@ -21,7 +21,6 @@ beforeEach(() => {
     mapState: { mapStyle: {} },
     buttonConfig: {},
     eventBus: { emit: jest.fn() },
-    closeApp: jest.fn(),
     handleInteraction: handleInteractionMock
   }
 })
@@ -36,8 +35,7 @@ describe('useAttachEvents', () => {
       mapState: props.mapState,
       buttonConfig: props.buttonConfig,
       events: EVENTS,
-      eventBus: props.eventBus,
-      closeApp: props.closeApp
+      eventBus: props.eventBus
     }))
 
     const { getAppState, getPluginState, handleInteraction } = attachEvents.mock.calls.at(-1)[0]

package/plugins/interact/src/hooks/useCrossHairVisibility.js

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useRef } from 'react'
-import { getInterfaceType, subscribeToInterfaceChangesImmediate } from '../../../../src/utils/detectInterfaceType.js'
 
 export function useCrossHairVisibility ({ crossHair, enabled, selectMarkerOnly, appState }) {
   const enabledRef = useRef(enabled)
@@ -9,9 +8,11 @@ export function useCrossHairVisibility ({ crossHair, enabled, selectMarkerOnly,
   const crossHairRef = useRef(crossHair)
   crossHairRef.current = crossHair
   const listboxFocusRef = useRef(false)
+  const interfaceTypeRef = useRef(appState.interfaceType)
+  interfaceTypeRef.current = appState.interfaceType
 
   const updateCrossHair = useCallback(() => {
-    const type = getInterfaceType()
+    const type = interfaceTypeRef.current
     const isToK = ['touch', 'keyboard'].includes(type)
     if (enabledRef.current && !listboxFocusRef.current && isToK && !(type === 'touch' && selectMarkerOnlyRef.current)) {
       crossHairRef.current.fixAtCenter()
@@ -20,17 +21,10 @@ export function useCrossHairVisibility ({ crossHair, enabled, selectMarkerOnly,
     }
   }, [])
 
-  // Toggle target marker visibility on enabled/interactionModes changes
   useEffect(() => {
     updateCrossHair()
-  }, [enabled, selectMarkerOnly, updateCrossHair])
+  }, [enabled, selectMarkerOnly, appState.interfaceType, updateCrossHair])
 
-  // Toggle target marker visibility immediately on interface type change (no 150ms React delay)
-  useEffect(() => {
-    return subscribeToInterfaceChangesImmediate(updateCrossHair)
-  }, [updateCrossHair])
-
-  // Hide crosshair when listbox has focus
   useEffect(() => {
     const container = appState.layoutRefs?.appContainerRef?.current
     if (!container) { return undefined }

package/plugins/interact/src/hooks/useCrossHairVisibility.test.js

@@ -1,20 +1,15 @@
 import { act, renderHook } from '@testing-library/react'
 import { useCrossHairVisibility } from './useCrossHairVisibility.js'
-import { getInterfaceType } from '../../../../src/utils/detectInterfaceType.js'
-
-jest.mock('../../../../src/utils/detectInterfaceType.js', () => ({
-  getInterfaceType: jest.fn(() => 'mouse'),
-  subscribeToInterfaceChangesImmediate: jest.fn(() => () => {})
-}))
 
 let crossHair
 let appState
 
 beforeEach(() => {
-  jest.clearAllMocks()
   crossHair = { fixAtCenter: jest.fn(), hide: jest.fn() }
-  appState = { layoutRefs: { appContainerRef: { current: document.createElement('div') } } }
-  getInterfaceType.mockReturnValue('mouse')
+  appState = {
+    interfaceType: 'mouse',
+    layoutRefs: { appContainerRef: { current: document.createElement('div') } }
+  }
 })
 
 describe('useCrossHairVisibility', () => {
@@ -26,7 +21,7 @@ describe('useCrossHairVisibility', () => {
 
   it('shows crosshair on touch/keyboard and hides when listbox has focus', () => {
     const container = appState.layoutRefs.appContainerRef.current
-    getInterfaceType.mockReturnValue('touch')
+    appState.interfaceType = 'touch'
     renderHook(() => useCrossHairVisibility({ crossHair, enabled: true, selectMarkerOnly: false, appState }))
 
     expect(crossHair.fixAtCenter).toHaveBeenCalled()

package/plugins/interact/src/hooks/useHighlightSync.js

@@ -9,16 +9,12 @@ import { buildStylesMap } from '../utils/buildStylesMap.js'
  * (shown with the keyboard cursor ring) as separate arguments so the provider can style them
  * differently. Also re-applies highlights after a map style reload, since highlight layers
  * are removed when the base style changes.
- *
- * Dispatches UPDATE_SELECTED_BOUNDS with the bounding box returned by the provider so
- * downstream consumers (e.g. interact:done) receive up-to-date bounds.
  */
 export const useHighlightSync = ({
   mapProvider,
   mapStyle,
   pluginState,
   selectedFeatures,
-  dispatch,
   events,
   eventBus
 }) => {
@@ -37,12 +33,7 @@ export const useHighlightSync = ({
     const activeFeatures = listboxActiveItem
       ? [{ featureId: listboxActiveItem.featureId, layerId: listboxActiveItem.layerId, idProperty: listboxActiveItem.idProperty, geometry: listboxActiveItem.geometry }]
       : []
-    const bounds = mapProvider.updateHighlightedFeatures?.(selectedFeatures, activeFeatures, stylesMap)
-
-    dispatch({
-      type: 'UPDATE_SELECTED_BOUNDS',
-      payload: bounds
-    })
+    mapProvider.updateHighlightedFeatures?.(selectedFeatures, activeFeatures, stylesMap)
   }
 
   useEffect(() => {

package/plugins/interact/src/hooks/useHighlightSync.test.js

@@ -30,7 +30,6 @@ beforeEach(() => {
       layers: [{ layerId: 'layer1' }]
     },
     selectedFeatures: [],
-    dispatch: jest.fn(),
     events: { MAP_STYLE_CHANGE: STYLE_CHANGE, MAP_DATA_CHANGE: DATA_CHANGE },
     eventBus: {
       on: jest.fn((event, handler) => {
@@ -51,7 +50,7 @@ beforeEach(() => {
 // ─── useHighlightSync — highlighting ─────────────────────────────────────────
 
 describe('useHighlightSync — highlighting', () => {
-  it('updates map highlights and dispatches bounds', () => {
+  it('updates map highlights', () => {
     mockDeps.selectedFeatures = [{ featureId: 'F1', layerId: 'layer1' }]
 
     render()
@@ -61,22 +60,6 @@ describe('useHighlightSync — highlighting', () => {
       [],
       expect.any(Object)
     )
-    expect(mockDeps.dispatch).toHaveBeenCalledWith({
-      type: 'UPDATE_SELECTED_BOUNDS',
-      payload: { sw: [0, 0], ne: [1, 1] }
-    })
-  })
-
-  it('dispatches null bounds when provider returns null', () => {
-    mockDeps.selectedFeatures = [{ featureId: 'F1' }]
-    mockDeps.mapProvider.updateHighlightedFeatures.mockReturnValue(null)
-
-    render()
-
-    expect(mockDeps.dispatch).toHaveBeenCalledWith({
-      type: 'UPDATE_SELECTED_BOUNDS',
-      payload: null
-    })
   })
 })
 
@@ -144,9 +127,7 @@ describe('useHighlightSync — guards', () => {
     mockDeps.mapProvider = null
     mockDeps.selectedFeatures = [{ featureId: 'F1' }]
 
-    render()
-
-    expect(mockDeps.dispatch).not.toHaveBeenCalled()
+    expect(() => render()).not.toThrow()
   })
 
   it('does nothing when mapStyle is null', () => {

package/plugins/interact/src/hooks/useInteractionHandlers.js

@@ -37,15 +37,10 @@ const findMarkerAtPoint = (markers, point, scale) => {
   return null
 }
 
-const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectedMarkers, selectionBounds) => {
+const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectedMarkers) => {
   const lastEmittedSelectionChange = useRef(null)
 
   useEffect(() => {
-    const awaitingBounds = selectedFeatures.length > 0 && !selectionBounds
-    if (awaitingBounds) {
-      return
-    }
-
     const prev = lastEmittedSelectionChange.current
     const wasEmpty = prev === null || (prev.features.length === 0 && prev.markers.length === 0)
     if (wasEmpty && selectedFeatures.length === 0 && selectedMarkers.length === 0) {
@@ -53,14 +48,13 @@ const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectedMarkers,
     }
 
     eventBus.emit('interact:selectionchange', {
-      selectedFeatures,
+      selectedFeatures: selectedFeatures.map(({ featureId, layerId, idProperty, properties }) => ({ featureId, layerId, idProperty, properties })),
       selectedMarkers,
-      selectionBounds,
       contiguous: areAllContiguous(selectedFeatures)
     })
 
     lastEmittedSelectionChange.current = { features: selectedFeatures, markers: selectedMarkers }
-  }, [selectedFeatures, selectedMarkers, selectionBounds])
+  }, [selectedFeatures, selectedMarkers])
 }
 
 /**
@@ -166,6 +160,15 @@ const resolveContiguousDispatch = ({ featureId, feature, config, selectedFeature
   return true
 }
 
+const logDebugFeatures = (coords, features) => {
+  const [lng, lat] = coords
+  console.groupCollapsed(`[interact] click (${lng.toFixed(4)}, ${lat.toFixed(4)}) — ${features.length} feature${features.length !== 1 ? 's' : ''}`) // NOSONAR
+  features.forEach(f => { // NOSONAR
+    console.log({ layer: f.layer.id, type: f.layer.type, id: f.id ?? '—', sourceLayer: f.sourceLayer ?? '—', properties: f.properties }) // NOSONAR
+  })
+  console.groupEnd() // NOSONAR
+}
+
 /**
  * Core interaction hook. Processes map clicks in fixed priority order:
  * selectMarker → selectFeature → placeMarker (fallback).
@@ -185,7 +188,7 @@ const useHandleInteraction = ({ mapProvider, layers, interactionModes, multiSele
   return useCallback(({ point, coords }) => {
     const debugFeatures = debug ? getFeaturesAtPoint(mapProvider, point, { radius: tolerance }) : null
     if (debugFeatures) {
-      console.log(`--- Features at ${coords} ---`, debugFeatures) // NOSONAR
+      logDebugFeatures(coords, debugFeatures)
     }
     if (interactionModes.includes('selectMarker')) {
       const markerHit = findMarkerAtPoint(markers, point, scale)
@@ -211,7 +214,7 @@ export const useInteractionHandlers = ({ mapState, pluginState, services, mapPro
   const {
     dispatch, layers, interactionModes, multiSelect, contiguous,
     marker: markerOptions, tolerance, selectedFeatures, selectedMarkers,
-    selectionBounds, deselectOnClickOutside
+    deselectOnClickOutside
   } = pluginState
   const { eventBus } = services
   const layerConfigMap = buildLayerConfigMap(layers)
@@ -263,6 +266,6 @@ export const useInteractionHandlers = ({ mapState, pluginState, services, mapPro
     scale
   })
 
-  useSelectionChangeEmitter(eventBus, selectedFeatures, selectedMarkers, selectionBounds)
+  useSelectionChangeEmitter(eventBus, selectedFeatures, selectedMarkers)
   return { handleInteraction }
 }

package/plugins/interact/src/hooks/useInteractionHandlers.test.js

@@ -65,7 +65,6 @@ const setup = (pluginOverrides = {}, markerItems = [], markerRefs = new Map()) =
       marker: { symbol: 'pin', backgroundColor: 'red' },
       selectedFeatures: [],
       selectedMarkers: [],
-      selectionBounds: null,
       ...pluginOverrides
     },
     services: {
@@ -345,30 +344,12 @@ it('does not check markers when selectMarker is not in interactionModes', () =>
 /* Selection change event                                             */
 /* ------------------------------------------------------------------ */
 
-it('does not emit selectionchange when features are selected but bounds not yet calculated', () => {
+it('emits selectionchange when features are selected', () => {
   const deps = {
     mapState: { markers: { add: jest.fn(), remove: jest.fn(), items: [], markerRefs: new Map() } },
     pluginState: {
-      selectedFeatures: [{ featureId: 'F1' }],
-      selectedMarkers: [],
-      selectionBounds: null
-    },
-    services: { eventBus: { emit: jest.fn() } },
-    mapProvider: { getFeatureGeometry: jest.fn(() => null) }
-  }
-
-  renderHook(() => useInteractionHandlers(deps))
-
-  expect(deps.services.eventBus.emit).not.toHaveBeenCalled()
-})
-
-it('emits selectionchange once when bounds exist', () => {
-  const deps = {
-    mapState: { markers: { add: jest.fn(), remove: jest.fn(), items: [], markerRefs: new Map() } },
-    pluginState: {
-      selectedFeatures: [{ featureId: 'F1' }],
-      selectedMarkers: [],
-      selectionBounds: { sw: [0, 0], ne: [1, 1] }
+      selectedFeatures: [{ featureId: 'F1', layerId: 'l1', idProperty: 'id', properties: { name: 'A' }, geometry: { type: 'Point', coordinates: [0, 0] } }],
+      selectedMarkers: []
     },
     services: { eventBus: { emit: jest.fn() } },
     mapProvider: { getFeatureGeometry: jest.fn(() => null) }
@@ -379,9 +360,8 @@ it('emits selectionchange once when bounds exist', () => {
   expect(deps.services.eventBus.emit).toHaveBeenCalledWith(
     'interact:selectionchange',
     expect.objectContaining({
-      selectedFeatures: deps.pluginState.selectedFeatures,
+      selectedFeatures: [{ featureId: 'F1', layerId: 'l1', idProperty: 'id', properties: { name: 'A' } }],
       selectedMarkers: [],
-      selectionBounds: deps.pluginState.selectionBounds,
       contiguous: false
     })
   )
@@ -394,7 +374,7 @@ it('skips emission when selection remains empty after being cleared', () => {
   const { rerender } = renderHook(
     ({ features }) => useInteractionHandlers({
       mapState: { markers: { items: [], markerRefs: new Map() } },
-      pluginState: { selectedFeatures: features, selectedMarkers: [], selectionBounds: { b: 1 } },
+      pluginState: { selectedFeatures: features, selectedMarkers: [] },
       services: { eventBus },
       mapProvider: { getFeatureGeometry: jest.fn(() => null) }
     }),
@@ -423,18 +403,37 @@ it('skips emission when selection remains empty after being cleared', () => {
 /* ------------------------------------------------------------------ */
 
 it('logs features when debug mode is enabled', () => {
+  const groupSpy = jest.spyOn(console, 'groupCollapsed').mockImplementation(() => {})
   const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+  const groupEndSpy = jest.spyOn(console, 'groupEnd').mockImplementation(() => {})
 
   const { result } = setup({ debug: true })
 
   click(result)
 
-  expect(logSpy).toHaveBeenCalledWith(
-    expect.stringContaining('--- Features at'),
-    expect.any(Array)
-  )
+  expect(groupSpy).toHaveBeenCalledWith(expect.stringContaining('[interact] click ('))
+  expect(groupSpy).toHaveBeenCalledWith(expect.stringContaining('1 feature'))
+  expect(logSpy).toHaveBeenCalledWith(expect.objectContaining({ layer: 'parcels' }))
+  expect(groupEndSpy).toHaveBeenCalled()
 
+  groupSpy.mockRestore()
   logSpy.mockRestore()
+  groupEndSpy.mockRestore()
+})
+
+it('uses plural label when multiple features are found', () => {
+  const groupSpy = jest.spyOn(console, 'groupCollapsed').mockImplementation(() => {})
+  jest.spyOn(console, 'log').mockImplementation(() => {})
+  jest.spyOn(console, 'groupEnd').mockImplementation(() => {})
+
+  featureQueries.getFeaturesAtPoint.mockReturnValue([baseFeature, baseFeature])
+
+  const { result } = setup({ debug: true })
+  click(result)
+
+  expect(groupSpy).toHaveBeenCalledWith(expect.stringContaining('2 features'))
+
+  jest.restoreAllMocks()
 })
 
 /* ------------------------------------------------------------------ */

package/plugins/interact/src/manifest.js

@@ -21,23 +21,6 @@ export const manifest = {
   },
 
   buttons: [{
-    id: 'selectCancel',
-    label: 'Back',
-    variant: 'tertiary',
-    hiddenWhen: ({ appConfig, appState, pluginState }) => !pluginState.enabled || !(['hybrid', 'buttonFirst'].includes(appConfig.behaviour) && appState.isFullscreen),
-    mobile: {
-      slot: 'actions',
-      showLabel: true
-    },
-    tablet: {
-      slot: 'actions',
-      showLabel: true
-    },
-    desktop: {
-      slot: 'actions',
-      showLabel: true
-    }
-  }, {
     id: 'selectAtTarget',
     label: 'Select',
     variant: 'primary',
@@ -54,24 +37,6 @@ export const manifest = {
     desktop: {
       slot: 'actions'
     }
-  }, {
-    id: 'selectDone',
-    label: 'Continue',
-    variant: 'primary',
-    excludeWhen: ({ appState, pluginState }) => !pluginState.enabled || !appState.isFullscreen,
-    enableWhen: ({ mapState, pluginState }) => !!mapState.markers.items.some(m => m.id === 'location') || !!pluginState.selectionBounds,
-    mobile: {
-      slot: 'actions',
-      showLabel: true
-    },
-    tablet: {
-      slot: 'actions',
-      showLabel: true
-    },
-    desktop: {
-      slot: 'actions',
-      showLabel: true
-    }
   }],
 
   keyboardShortcuts: [

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

@@ -18,7 +18,9 @@ describe('manifest', () => {
 
   it('defines buttons with correct ids', () => {
     const ids = manifest.buttons.map(b => b.id)
-    expect(ids).toEqual(expect.arrayContaining(['selectDone', 'selectAtTarget', 'selectCancel']))
+    expect(ids).toEqual(expect.arrayContaining(['selectAtTarget']))
+    expect(ids).not.toContain('selectDone')
+    expect(ids).not.toContain('selectCancel')
   })
 
   it('buttons have slots and showLabel', () => {
@@ -33,54 +35,12 @@ describe('manifest', () => {
   })
 
   it('button logic functions cover all branches', () => {
-    const done = manifest.buttons.find(b => b.id === 'selectDone')
     const atTarget = manifest.buttons.find(b => b.id === 'selectAtTarget')
-    const cancel = manifest.buttons.find(b => b.id === 'selectCancel')
-
-    // selectDone.excludeWhen
-    expect(done.excludeWhen({ appState: { isFullscreen: false }, pluginState: { enabled: true } })).toBe(true)
-    expect(done.excludeWhen({ appState: { isFullscreen: true }, pluginState: { enabled: true } })).toBe(false)
-
-    // selectDone.enableWhen
-    expect(done.enableWhen({
-      mapState: { markers: { items: [{ id: 'location' }] } },
-      pluginState: { selectionBounds: null }
-    })).toBe(true)
-    expect(done.enableWhen({
-      mapState: { markers: { items: [] } },
-      pluginState: { selectionBounds: null }
-    })).toBe(false)
-    expect(done.enableWhen({
-      mapState: { markers: { items: [] } },
-      pluginState: { selectionBounds: { sw: [0, 0], ne: [1, 1] } }
-    })).toBe(true)
 
     // selectAtTarget.hiddenWhen
     expect(atTarget.hiddenWhen({ appState: { interfaceType: 'pointer' }, pluginState: { enabled: true } })).toBe(true)
     expect(atTarget.hiddenWhen({ appState: { interfaceType: 'touch' }, pluginState: { enabled: true } })).toBe(false)
     expect(atTarget.hiddenWhen({ appState: { interfaceType: 'touch' }, pluginState: { enabled: false } })).toBe(true)
-
-    // selectCancel.hiddenWhen
-    expect(cancel.hiddenWhen({
-      appConfig: { behaviour: 'always' },
-      appState: { isFullscreen: true },
-      pluginState: { enabled: true }
-    })).toBe(true)
-    expect(cancel.hiddenWhen({
-      appConfig: { behaviour: 'hybrid' },
-      appState: { isFullscreen: true },
-      pluginState: { enabled: true }
-    })).toBe(false)
-    expect(cancel.hiddenWhen({
-      appConfig: { behaviour: 'hybrid' },
-      appState: { isFullscreen: false },
-      pluginState: { enabled: true }
-    })).toBe(true)
-    expect(cancel.hiddenWhen({
-      appConfig: { behaviour: 'hybrid' },
-      appState: { isFullscreen: true },
-      pluginState: { enabled: false }
-    })).toBe(true)
   })
 
   it('keyboardShortcuts array exists', () => {