@defra/interactive-map 0.0.26-alpha → 0.0.27-alpha

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

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef } from 'react'
-import { areAllContiguous } from '../utils/spatial.js'
+import { areAllContiguous, isContiguousWithAny } from '../utils/spatial.js'
 import { getFeaturesAtPoint, findMatchingFeature, buildLayerConfigMap } from '../utils/featureQueries.js'
 import { scaleFactor } from '../../../../src/config/appConfig.js'
 import { isStandaloneLabel } from '../../../../src/utils/symbolUtils.js'
@@ -16,7 +16,6 @@ import { isStandaloneLabel } from '../../../../src/utils/symbolUtils.js'
  * @param {number} scale - scaleFactor for the current mapSize (e.g. 1.5 for medium)
  * @returns {string|null}
  */
-
 const findMarkerAtPoint = (markers, point, scale) => {
   for (const marker of markers.items) {
     const el = markers.markerRefs?.get(marker.id)
@@ -42,13 +41,11 @@ const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectedMarkers,
   const lastEmittedSelectionChange = useRef(null)
 
   useEffect(() => {
-    // Skip if features exist but bounds not yet calculated
     const awaitingBounds = selectedFeatures.length > 0 && !selectionBounds
     if (awaitingBounds) {
       return
     }
 
-    // Skip if selection was already empty and remains empty
     const prev = lastEmittedSelectionChange.current
     const wasEmpty = prev === null || (prev.features.length === 0 && prev.markers.length === 0)
     if (wasEmpty && selectedFeatures.length === 0 && selectedMarkers.length === 0) {
@@ -66,6 +63,109 @@ const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectedMarkers,
   }, [selectedFeatures, selectedMarkers, selectionBounds])
 }
 
+/**
+ * Given a set of selected features, returns the largest contiguous sub-group
+ * that stays connected to features[0]. Used when deselecting a feature that
+ * may act as a bridge between two otherwise disconnected parts of the selection.
+ *
+ * Uses flood-fill: starts from features[0] and repeatedly adds any feature that
+ * touches the growing connected set, until no more can be added.
+ *
+ * @param {Array} features - Current selection minus the feature being deselected.
+ *   Each feature must have an enriched `geometry` (set by the provider at selection time).
+ * @returns {Array|null} The connected sub-group anchored at features[0],
+ *   or null if all features are already contiguous (no trimming needed).
+ */
+const trimToContiguousGroup = (features) => {
+  const connected = new Set([0])
+  let changed = true
+  while (changed) {
+    changed = false
+    for (let i = 1; i < features.length; i++) {
+      if (connected.has(i)) {
+        continue
+      }
+      const connectedFeatures = [...connected].map(idx => features[idx])
+      if (features[i].geometry?.type && isContiguousWithAny(features[i], connectedFeatures)) {
+        connected.add(i)
+        changed = true
+      }
+    }
+  }
+  if (connected.size === features.length) {
+    return null
+  }
+  return [...connected].map(idx => features[idx])
+}
+
+const buildTogglePayload = (featureId, multiSelect, config, feature) => ({
+  featureId,
+  multiSelect,
+  layerId: config.layerId,
+  idProperty: config.idProperty,
+  properties: feature.properties,
+  geometry: feature.geometry
+})
+
+/**
+ * Enforces the contiguous selection constraint when a feature is clicked.
+ * Intercepts the click and dispatches its own action when needed, returning
+ * true so the caller knows not to dispatch again.
+ *
+ * Two cases are handled:
+ *  - Deselecting a feature: if removing it would split the remaining selection
+ *    into disconnected parts, the selection is trimmed to the group that stays
+ *    connected to the first selected feature, rather than allowing a split.
+ *  - Adding a feature: if the new feature does not touch any already-selected
+ *    feature, the entire existing selection is replaced rather than extended,
+ *    keeping the selection contiguous.
+ *
+ * Returns false (no-op) when the click is a straightforward toggle that does
+ * not violate contiguity, leaving the caller to dispatch normally.
+ *
+ * @param {{ featureId, feature, config, selectedFeatures, dispatch, multiSelect }} params
+ *   feature.geometry must already be enriched by the provider before calling.
+ * @returns {boolean} True if this function dispatched; false if the caller should.
+ */
+const resolveContiguousDispatch = ({ featureId, feature, config, selectedFeatures, dispatch, multiSelect }) => {
+  if (!selectedFeatures.length) {
+    return false
+  }
+
+  const existingIndex = selectedFeatures.findIndex(
+    f => f.featureId === featureId && f.layerId === config.layerId
+  )
+
+  if (existingIndex !== -1) {
+    // Deselect: trim to first connected group if the removal splits the selection.
+    if (selectedFeatures.length < 3) { // NOSONAR
+      return false
+    }
+    const remaining = selectedFeatures.filter((_, i) => i !== existingIndex)
+    const trimmed = trimToContiguousGroup(remaining)
+    if (!trimmed) {
+      return false
+    }
+    dispatch({ type: 'SET_SELECTED_FEATURES', payload: trimmed })
+    return true
+  }
+
+  // Add: replace selection if the new feature doesn't touch any existing feature.
+  const validSelected = selectedFeatures.filter(f => f.geometry?.type)
+  if (!feature.geometry?.type || !validSelected.length) {
+    return false
+  }
+  if (isContiguousWithAny(feature, validSelected)) {
+    return false
+  }
+
+  dispatch({
+    type: 'TOGGLE_SELECTED_FEATURES',
+    payload: { ...buildTogglePayload(featureId, multiSelect, config, feature), replaceAll: true }
+  })
+  return true
+}
+
 /**
  * Core interaction hook. Processes map clicks in fixed priority order:
  * selectMarker → selectFeature → placeMarker (fallback).
@@ -81,30 +181,60 @@ const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectedMarkers,
  * @param {Object} deps.mapProvider - Map provider instance for feature queries
  * @returns {{ handleInteraction: Function }}
  */
+const useHandleInteraction = ({ mapProvider, layers, interactionModes, multiSelect, dispatch, markers, layerConfigMap, debug, tolerance, processFeatureMatch, processFallback, scale }) => {
+  return useCallback(({ point, coords }) => {
+    const debugFeatures = debug ? getFeaturesAtPoint(mapProvider, point, { radius: tolerance }) : null
+    if (debugFeatures) {
+      console.log(`--- Features at ${coords} ---`, debugFeatures) // NOSONAR
+    }
+    if (interactionModes.includes('selectMarker')) {
+      const markerHit = findMarkerAtPoint(markers, point, scale)
+      if (markerHit) {
+        dispatch({ type: 'TOGGLE_SELECTED_MARKERS', payload: { markerId: markerHit, multiSelect } })
+        return
+      }
+    }
+    if (interactionModes.includes('selectFeature') && layers.length > 0) {
+      const allFeatures = debugFeatures ?? getFeaturesAtPoint(mapProvider, point, { radius: tolerance })
+      const match = findMatchingFeature(allFeatures, layerConfigMap)
+      if (match) {
+        processFeatureMatch(match)
+        return
+      }
+    }
+    processFallback({ coords })
+  }, [mapProvider, layers, interactionModes, multiSelect, dispatch, markers, layerConfigMap, debug, tolerance, processFeatureMatch, processFallback, scale])
+}
+
 export const useInteractionHandlers = ({ mapState, pluginState, services, mapProvider }) => {
   const { markers, mapSize } = mapState
-  const { dispatch, layers, interactionModes, multiSelect, marker: markerOptions, tolerance, selectedFeatures, selectedMarkers, selectionBounds, deselectOnClickOutside } = pluginState
+  const {
+    dispatch, layers, interactionModes, multiSelect, contiguous,
+    marker: markerOptions, tolerance, selectedFeatures, selectedMarkers,
+    selectionBounds, deselectOnClickOutside
+  } = pluginState
   const { eventBus } = services
   const layerConfigMap = buildLayerConfigMap(layers)
   const scale = scaleFactor[mapSize] ?? 1
+
   const processFeatureMatch = useCallback(({ feature, config }) => {
     markers.remove('location')
     const featureId = feature.properties?.[config.idProperty] ?? feature.id
     if (featureId == null) {
       return
     }
-    dispatch({
-      type: 'TOGGLE_SELECTED_FEATURES',
-      payload: {
-        featureId,
-        multiSelect,
-        layerId: config.layerId,
-        idProperty: config.idProperty,
-        properties: feature.properties,
-        geometry: feature.geometry
+    const enrichedGeometry = mapProvider.getFeatureGeometry?.(config.layerId, featureId, config.idProperty)
+    const enrichedFeature = enrichedGeometry ? { ...feature, geometry: enrichedGeometry } : feature
+    if (contiguous && multiSelect) {
+      const handled = resolveContiguousDispatch(
+        { featureId, feature: enrichedFeature, config, selectedFeatures, dispatch, multiSelect }
+      )
+      if (handled) {
+        return
       }
-    })
-  }, [markers, dispatch, multiSelect])
+    }
+    dispatch({ type: 'TOGGLE_SELECTED_FEATURES', payload: buildTogglePayload(featureId, multiSelect, config, enrichedFeature) })
+  }, [markers, dispatch, multiSelect, contiguous, selectedFeatures, mapProvider])
 
   const processFallback = useCallback(({ coords }) => {
     const canPlace = interactionModes.includes('placeMarker')
@@ -118,31 +248,7 @@ export const useInteractionHandlers = ({ mapState, pluginState, services, mapPro
     }
   }, [interactionModes, dispatch, markers, markerOptions, eventBus, deselectOnClickOutside])
 
-  const handleInteraction = useCallback(({ point, coords }) => {
-    const debugFeatures = pluginState?.debug ? getFeaturesAtPoint(mapProvider, point, { radius: tolerance }) : null
-    if (debugFeatures) {
-      console.log(`--- Features at ${coords} ---`, debugFeatures) // NOSONAR
-    }
-
-    if (interactionModes.includes('selectMarker')) {
-      const markerHit = findMarkerAtPoint(markers, point, scale)
-      if (markerHit) {
-        dispatch({ type: 'TOGGLE_SELECTED_MARKERS', payload: { markerId: markerHit, multiSelect } })
-        return
-      }
-    }
-
-    if (interactionModes.includes('selectFeature') && layers.length > 0) {
-      const allFeatures = debugFeatures ?? getFeaturesAtPoint(mapProvider, point, { radius: tolerance })
-      const match = findMatchingFeature(allFeatures, layerConfigMap)
-      if (match) {
-        processFeatureMatch(match)
-        return
-      }
-    }
-
-    processFallback({ coords })
-  }, [
+  const handleInteraction = useHandleInteraction({
     mapProvider,
     layers,
     interactionModes,
@@ -150,12 +256,13 @@ export const useInteractionHandlers = ({ mapState, pluginState, services, mapPro
     dispatch,
     markers,
     layerConfigMap,
-    pluginState?.debug,
+    debug: pluginState?.debug,
     tolerance,
     processFeatureMatch,
     processFallback,
     scale
-  ])
+  })
+
   useSelectionChangeEmitter(eventBus, selectedFeatures, selectedMarkers, selectionBounds)
   return { handleInteraction }
 }

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

@@ -5,15 +5,33 @@ import * as featureQueries from '../utils/featureQueries.js'
 /* Mocks                                                              */
 /* ------------------------------------------------------------------ */
 
-jest.mock('../utils/spatial.js', () => ({
-  areAllContiguous: jest.fn(() => false)
-}))
 jest.mock('../utils/featureQueries.js', () => ({
   getFeaturesAtPoint: jest.fn(),
   findMatchingFeature: jest.fn(),
   buildLayerConfigMap: jest.fn(() => ({}))
 }))
 
+/* ------------------------------------------------------------------ */
+/* Real geometries — unit squares along the x-axis                   */
+/*                                                                    */
+/*  geomA  geomB  geomC        geomD (isolated)                       */
+/*  [0-1]  [1-2]  [2-3]  ...  [10-11]                                */
+/*  A and B share the x=1 edge  (contiguous)                          */
+/*  B and C share the x=2 edge  (contiguous)                          */
+/*  A and C do NOT touch        (non-contiguous)                      */
+/*  D does not touch any of A, B, or C                                */
+/* ------------------------------------------------------------------ */
+
+const square = (x0, y0, x1, y1) => ({
+  type: 'Polygon',
+  coordinates: [[[x0, y0], [x1, y0], [x1, y1], [x0, y1], [x0, y0]]]
+})
+
+const geomA = square(0, 0, 1, 1)
+const geomB = square(1, 0, 2, 1) // NOSONAR
+const geomC = square(2, 0, 3, 1) // NOSONAR
+const geomD = square(10, 0, 11, 1) // NOSONAR
+
 /* ------------------------------------------------------------------ */
 /* Helpers                                                            */
 /* ------------------------------------------------------------------ */
@@ -53,7 +71,7 @@ const setup = (pluginOverrides = {}, markerItems = [], markerRefs = new Map()) =
     services: {
       eventBus: { emit: jest.fn() }
     },
-    mapProvider: {}
+    mapProvider: { getFeatureGeometry: jest.fn(() => null) }
   }
 
   const utils = renderHook(() => useInteractionHandlers(deps))
@@ -62,7 +80,7 @@ const setup = (pluginOverrides = {}, markerItems = [], markerRefs = new Map()) =
 
 const baseFeature = {
   properties: { parcelId: 'P1' },
-  geometry: { type: 'Polygon' },
+  geometry: geomB,
   layer: { id: 'parcels' }
 }
 
@@ -336,7 +354,7 @@ it('does not emit selectionchange when features are selected but bounds not yet
       selectionBounds: null
     },
     services: { eventBus: { emit: jest.fn() } },
-    mapProvider: {}
+    mapProvider: { getFeatureGeometry: jest.fn(() => null) }
   }
 
   renderHook(() => useInteractionHandlers(deps))
@@ -353,7 +371,7 @@ it('emits selectionchange once when bounds exist', () => {
       selectionBounds: { sw: [0, 0], ne: [1, 1] }
     },
     services: { eventBus: { emit: jest.fn() } },
-    mapProvider: {}
+    mapProvider: { getFeatureGeometry: jest.fn(() => null) }
   }
 
   renderHook(() => useInteractionHandlers(deps))
@@ -378,7 +396,7 @@ it('skips emission when selection remains empty after being cleared', () => {
       mapState: { markers: { items: [], markerRefs: new Map() } },
       pluginState: { selectedFeatures: features, selectedMarkers: [], selectionBounds: { b: 1 } },
       services: { eventBus },
-      mapProvider: {}
+      mapProvider: { getFeatureGeometry: jest.fn(() => null) }
     }),
     { initialProps: { features: [{ id: 'f1' }] } }
   )
@@ -418,3 +436,217 @@ it('logs features when debug mode is enabled', () => {
 
   logSpy.mockRestore()
 })
+
+/* ------------------------------------------------------------------ */
+/* contiguous enforcement                                             */
+/* existingFeature uses geomA; baseFeature (clicked) uses geomB.     */
+/* geomA and geomB share the x=1 edge so they are contiguous.        */
+/* ------------------------------------------------------------------ */
+
+const existingFeature = { featureId: 'P0', layerId: 'parcels', geometry: geomA }
+
+describe('contiguous enforcement — selecting features', () => {
+  it('allows first selection when no features already selected', () => {
+    const { result, deps } = setup({ contiguous: true, multiSelect: true, selectedFeatures: [] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+  })
+
+  it('allows adding a contiguous feature', () => {
+    // baseFeature has geomB which shares an edge with geomA (existingFeature)
+    const { result, deps } = setup({ contiguous: true, multiSelect: true, selectedFeatures: [existingFeature] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+  })
+
+  it('replaces selection when clicking a non-contiguous feature', () => {
+    // geomD is isolated from geomA — replaceAll: true replaces rather than extends the selection
+    featureQueries.findMatchingFeature.mockReturnValue({
+      feature: { ...baseFeature, geometry: geomD },
+      config: { layerId: 'parcels', idProperty: 'parcelId' }
+    })
+    const { result, deps } = setup({ contiguous: true, multiSelect: true, selectedFeatures: [existingFeature] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES', payload: expect.objectContaining({ replaceAll: true }) })
+    )
+  })
+
+  it('allows deselecting an already-selected feature regardless of contiguity', () => {
+    const alreadySelected = { featureId: 'P1', layerId: 'parcels', geometry: geomB }
+    const { result, deps } = setup({ contiguous: true, multiSelect: true, selectedFeatures: [alreadySelected] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+  })
+})
+
+describe('contiguous enforcement — bypass conditions', () => {
+  it('does not enforce contiguous when contiguous is false', () => {
+    // geomD is isolated from geomA but contiguous enforcement is disabled
+    featureQueries.findMatchingFeature.mockReturnValue({
+      feature: { ...baseFeature, geometry: geomD },
+      config: { layerId: 'parcels', idProperty: 'parcelId' }
+    })
+    const { result, deps } = setup({ contiguous: false, multiSelect: true, selectedFeatures: [existingFeature] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+  })
+
+  it('does not enforce contiguous in single-select mode', () => {
+    // geomD is isolated but contiguous enforcement only applies in multi-select
+    featureQueries.findMatchingFeature.mockReturnValue({
+      feature: { ...baseFeature, geometry: geomD },
+      config: { layerId: 'parcels', idProperty: 'parcelId' }
+    })
+    const { result, deps } = setup({ contiguous: true, multiSelect: false, selectedFeatures: [existingFeature] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+  })
+
+  it('falls through to normal toggle when selected features have no usable geometry', () => {
+    const noGeomFeature = { featureId: 'P0', layerId: 'parcels' }
+    const { result, deps } = setup({ contiguous: true, multiSelect: true, selectedFeatures: [noGeomFeature] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES', payload: expect.not.objectContaining({ replaceAll: true }) })
+    )
+  })
+})
+
+describe('contiguous enforcement — geometry enrichment', () => {
+  it('uses the geometry returned by the provider as the dispatched geometry', () => {
+    const enriched = { type: 'MultiPolygon', coordinates: [[[[0, 0], [1, 0], [1, 1], [0, 0]]]] }
+    const { result, deps } = setup({ contiguous: false, multiSelect: true, selectedFeatures: [] })
+    deps.mapProvider.getFeatureGeometry.mockReturnValue(enriched)
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ payload: expect.objectContaining({ geometry: enriched }) })
+    )
+  })
+
+  it('uses stored geometry when provider returns null', () => {
+    const { result, deps } = setup({ contiguous: false, multiSelect: true, selectedFeatures: [] })
+    deps.mapProvider.getFeatureGeometry.mockReturnValue(null)
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ payload: expect.objectContaining({ geometry: baseFeature.geometry }) })
+    )
+  })
+
+  it('uses stored geometry when provider has no getFeatureGeometry', () => {
+    const { result, deps } = setup({ contiguous: false, multiSelect: true, selectedFeatures: [] })
+    deps.mapProvider.getFeatureGeometry = undefined
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ payload: expect.objectContaining({ geometry: baseFeature.geometry }) })
+    )
+  })
+
+  it('falls through to normal toggle when clicked feature has no geometry', () => {
+    featureQueries.findMatchingFeature.mockReturnValue({
+      feature: { properties: { parcelId: 'P1' }, geometry: null, layer: { id: 'parcels' } },
+      config: { layerId: 'parcels', idProperty: 'parcelId' }
+    })
+    const { result, deps } = setup({ contiguous: true, multiSelect: true, selectedFeatures: [existingFeature] })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+  })
+})
+
+describe('contiguous enforcement — deselect splits', () => {
+  // A=[0-1], B=[1-2], C=[2-3]: A-B touch, B-C touch, but A-C do not touch
+  const featureA = { featureId: 'P0', layerId: 'parcels', geometry: geomA }
+  const featureB = { featureId: 'P1', layerId: 'parcels', geometry: geomB }
+  const featureC = { featureId: 'P2', layerId: 'parcels', geometry: geomC }
+
+  it('trims to first contiguous group when deselecting the bridge feature', () => {
+    // A-B-C selected; deselect B (baseFeature returns P1); remaining [A, C] are non-contiguous
+    // flood-fill from A cannot reach C — result is trimmed to [A]
+    const { result, deps } = setup({
+      contiguous: true,
+      multiSelect: true,
+      selectedFeatures: [featureA, featureB, featureC]
+    })
+
+    click(result) // clicks P1 = featureB
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith({
+      type: 'SET_SELECTED_FEATURES',
+      payload: [featureA]
+    })
+  })
+
+  it('uses normal toggle when deselecting an end feature leaves a contiguous set', () => {
+    // A-B-C selected; deselect C (override mock to return P2); remaining [A, B] share the x=1 edge
+    featureQueries.findMatchingFeature.mockReturnValue({
+      feature: { properties: { parcelId: 'P2' }, geometry: { type: 'Polygon' }, layer: { id: 'parcels' } },
+      config: { layerId: 'parcels', idProperty: 'parcelId' }
+    })
+    const { result, deps } = setup({
+      contiguous: true,
+      multiSelect: true,
+      selectedFeatures: [featureA, featureB, featureC]
+    })
+
+    click(result) // clicks P2 = featureC
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+    expect(deps.pluginState.dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'SET_SELECTED_FEATURES' })
+    )
+  })
+
+  it('does not check for split when fewer than 3 features selected', () => {
+    // Only 2 features — the split-check threshold is < 3, so goes straight to normal toggle
+    const { result, deps } = setup({
+      contiguous: true,
+      multiSelect: true,
+      selectedFeatures: [featureA, featureB]
+    })
+
+    click(result) // clicks P1 = featureB
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'TOGGLE_SELECTED_FEATURES' })
+    )
+    expect(deps.pluginState.dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: 'SET_SELECTED_FEATURES' })
+    )
+  })
+})

package/plugins/interact/src/reducer.js

@@ -143,6 +143,12 @@ const unselectMarker = (state, { markerId }) => {
   }
 }
 
+const setSelectedFeatures = (state, features) => ({
+  ...state,
+  selectedFeatures: features,
+  selectionBounds: null
+})
+
 const actions = {
   ENABLE: enable,
   DISABLE: disable,
@@ -150,6 +156,7 @@ const actions = {
   TOGGLE_SELECTED_MARKERS: toggleSelectedMarkers,
   UPDATE_SELECTED_BOUNDS: updateSelectedBounds,
   CLEAR_SELECTED_FEATURES: clearSelectedFeatures,
+  SET_SELECTED_FEATURES: setSelectedFeatures,
   SELECT_MARKER: selectMarker,
   UNSELECT_MARKER: unselectMarker,
   SET_LISTBOX_ACTIVE: setListboxActive

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

@@ -240,6 +240,21 @@ describe('UNSELECT_MARKER action', () => {
   })
 })
 
+describe('SET_SELECTED_FEATURES action', () => {
+  it('replaces selectedFeatures and clears bounds', () => {
+    const state = {
+      ...initialState,
+      selectedFeatures: [{ featureId: 'A' }, { featureId: 'B' }, { featureId: 'C' }],
+      selectionBounds: [0, 0, 1, 1]
+    }
+    const trimmed = [{ featureId: 'A' }]
+    const result = actions.SET_SELECTED_FEATURES(state, trimmed)
+    expect(result.selectedFeatures).toEqual(trimmed)
+    expect(result.selectionBounds).toBeNull()
+    expect(result).not.toBe(state)
+  })
+})
+
 describe('actions object', () => {
   it('exports all action handlers as functions', () => {
     expect(Object.keys(actions)).toEqual([
@@ -249,6 +264,7 @@ describe('actions object', () => {
       'TOGGLE_SELECTED_MARKERS',
       'UPDATE_SELECTED_BOUNDS',
       'CLEAR_SELECTED_FEATURES',
+      'SET_SELECTED_FEATURES',
       'SELECT_MARKER',
       'UNSELECT_MARKER',
       'SET_LISTBOX_ACTIVE'