@defra/interactive-map 0.0.3-alpha → 0.0.5-alpha

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

@@ -1,6 +1,35 @@
 import { useCallback, useEffect, useRef } from 'react'
+import { isContiguousWithAny, canSplitFeatures, areAllContiguous } from '../utils/spatial.js'
 import { getFeaturesAtPoint, findMatchingFeature, buildLayerConfigMap } from '../utils/featureQueries.js'
 
+const useSelectionChangeEmitter = (eventBus, selectedFeatures, selectionBounds) => {
+  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.length === 0
+    if (wasEmpty && selectedFeatures.length === 0) {
+      return
+    }
+
+    eventBus.emit('interact:selectionchange', {
+      selectedFeatures,
+      selectionBounds,
+      canMerge: areAllContiguous(selectedFeatures),
+      canSplit: canSplitFeatures(selectedFeatures)
+    })
+
+    lastEmittedSelectionChange.current = selectedFeatures
+  }, [selectedFeatures, selectionBounds])
+}
+
 export const useInteractionHandlers = ({
   mapState,
   pluginState,
@@ -8,65 +37,75 @@ export const useInteractionHandlers = ({
   mapProvider,
 }) => {
   const { markers } = mapState
-  const { dispatch, dataLayers, interactionMode, multiSelect, markerColor, selectedFeatures, selectionBounds } = pluginState
+  const { dispatch, dataLayers, interactionMode, multiSelect, contiguous, markerColor, tolerance, selectedFeatures, selectionBounds } = pluginState
   const { eventBus } = services
-  const lastEmittedSelectionChange = useRef(null)
   const layerConfigMap = buildLayerConfigMap(dataLayers)
 
   const handleInteraction = useCallback(({ point, coords }) => {
-    const allFeatures = getFeaturesAtPoint(mapProvider, point)
+    const allFeatures = getFeaturesAtPoint(mapProvider, point, { radius: tolerance })
     const hasDataLayers = dataLayers.length > 0
 
-    const match = hasDataLayers &&
-      (interactionMode === 'select' || interactionMode === 'auto')
-        ? findMatchingFeature(allFeatures, layerConfigMap)
-        : null
-
-    if (match) {
-      markers.remove('location')
+    if (pluginState?.debug) {
+      console.log(`--- Features at ${coords} ---`, allFeatures)
+    }
 
-      const { feature, config } = match
-      const featureId = feature.properties?.[config.idProperty]
-
-      if (featureId) {
-        dispatch({
-          type: 'TOGGLE_SELECTED_FEATURES',
-          payload: {
-            featureId,
-            multiSelect,
-            layerId: config.layerId,
-            idProperty: config.idProperty,
-            properties: feature.properties,
-            geometry: feature.geometry
-          },
-        })
-      }
+    const canMatch = hasDataLayers && (interactionMode === 'select' || interactionMode === 'auto')
+    const match = canMatch ? findMatchingFeature(allFeatures, layerConfigMap) : null
 
+    // 1. Handle Feature Match
+    if (match) {
+      processFeatureMatch(match)
       return
     }
 
-    // Marker mode
-    if (interactionMode === 'marker' || (interactionMode === 'auto' && hasDataLayers)) {
+    // 2. Handle Marker Mode (Fallback)
+    const isMarkerMode = interactionMode === 'marker' || (interactionMode === 'auto' && hasDataLayers)
+    if (isMarkerMode) {
       dispatch({ type: 'CLEAR_SELECTED_FEATURES' })
       markers.add('location', coords, { color: markerColor })
-
       eventBus.emit('interact:markerchange', { coords })
     }
-  }, [mapProvider, dataLayers, interactionMode, multiSelect, eventBus, dispatch, markers])
 
-  // Emit event when selectedFeatures change
-  useEffect(() => {
-    if (!selectionBounds || selectedFeatures === lastEmittedSelectionChange.current) {
-      return
-    }
+    // Internal helper to keep complexity low
+    function processFeatureMatch({ feature, config }) {
+      markers.remove('location')
+      const isNewContiguous = contiguous && isContiguousWithAny(feature, selectedFeatures)
+      const featureId = feature.properties?.[config.idProperty] ?? feature.id
 
-    eventBus.emit('interact:selectionchange', {
-      selectedFeatures,
-      selectionBounds
-    })
+      if (!featureId) {
+        return
+      }
 
-    lastEmittedSelectionChange.current = selectedFeatures
-  }, [selectedFeatures, selectionBounds])
+      dispatch({
+        type: 'TOGGLE_SELECTED_FEATURES',
+        payload: {
+          featureId,
+          multiSelect,
+          layerId: config.layerId,
+          idProperty: config.idProperty,
+          properties: feature.properties,
+          geometry: feature.geometry,
+          replaceAll: contiguous && !isNewContiguous
+        }
+      })
+    }
+  }, [
+    mapProvider,
+    dataLayers,
+    interactionMode,
+    multiSelect,
+    eventBus,
+    dispatch,
+    markers,
+    contiguous,
+    selectedFeatures,
+    layerConfigMap,
+    pluginState?.debug,
+    tolerance,
+    markerColor
+  ])
+
+  useSelectionChangeEmitter(eventBus, selectedFeatures, selectionBounds)
 
   return {
     handleInteraction

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

@@ -0,0 +1,316 @@
+import { renderHook, act } from '@testing-library/react'
+import { useInteractionHandlers } from './useInteractionHandlers.js'
+import * as featureQueries from '../utils/featureQueries.js'
+import { isContiguousWithAny } from '../utils/spatial.js'
+
+/* ------------------------------------------------------------------ */
+/* Mocks                                                              */
+/* ------------------------------------------------------------------ */
+
+jest.mock('../utils/spatial.js', () => ({
+  isContiguousWithAny: jest.fn(),
+  canSplitFeatures: jest.fn(() => false),
+  areAllContiguous: jest.fn(() => false)
+}))
+jest.mock('../utils/featureQueries.js', () => ({
+  getFeaturesAtPoint: jest.fn(),
+  findMatchingFeature: jest.fn(),
+  buildLayerConfigMap: jest.fn(() => ({}))
+}))
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+const click = result =>
+  act(() =>
+    result.current.handleInteraction({
+      point: { x: 10, y: 20 },
+      coords: [1, 2]
+    })
+  )
+
+const setup = (pluginOverrides = {}) => {
+  const deps = {
+    mapState: {
+      markers: { add: jest.fn(), remove: jest.fn() }
+    },
+    pluginState: {
+      dispatch: jest.fn(),
+      dataLayers: [{ layerId: 'parcels', idProperty: 'parcelId' }],
+      interactionMode: 'select',
+      multiSelect: false,
+      contiguous: false,
+      markerColor: 'red',
+      selectedFeatures: [],
+      selectionBounds: null,
+      ...pluginOverrides
+    },
+    services: {
+      eventBus: { emit: jest.fn() }
+    },
+    mapProvider: {}
+  }
+
+  const utils = renderHook(() => useInteractionHandlers(deps))
+  return { ...utils, deps }
+}
+
+const baseFeature = {
+  properties: { parcelId: 'P1' },
+  geometry: { type: 'Polygon' },
+  layer: { id: 'parcels' }
+}
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  featureQueries.getFeaturesAtPoint.mockReturnValue([baseFeature])
+  featureQueries.findMatchingFeature.mockReturnValue({
+    feature: baseFeature,
+    config: { layerId: 'parcels', idProperty: 'parcelId' }
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* Marker mode                                                        */
+/* ------------------------------------------------------------------ */
+
+describe('marker mode', () => {
+  it('places marker, clears selection, and emits event', () => {
+    const { result, deps } = setup({ interactionMode: 'marker' })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith({
+      type: 'CLEAR_SELECTED_FEATURES'
+    })
+    expect(deps.mapState.markers.add).toHaveBeenCalledWith(
+      'location',
+      [1, 2],
+      { color: 'red' }
+    )
+    expect(deps.services.eventBus.emit).toHaveBeenCalledWith(
+      'interact:markerchange',
+      { coords: [1, 2] }
+    )
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* Select & Auto modes                                                */
+/* ------------------------------------------------------------------ */
+
+describe.each(['select', 'auto'])('%s mode feature selection', mode => {
+  it('dispatches selection for matching feature', () => {
+    const { result, deps } = setup({ interactionMode: mode })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'TOGGLE_SELECTED_FEATURES',
+        payload: expect.objectContaining({
+          featureId: 'P1',
+          layerId: 'parcels'
+        })
+      })
+    )
+  })
+})
+
+it('falls back to marker in auto mode when no feature found', () => {
+  featureQueries.getFeaturesAtPoint.mockReturnValue([])
+  featureQueries.findMatchingFeature.mockReturnValue(null)
+
+  const { result, deps } = setup({ interactionMode: 'auto' })
+
+  click(result)
+
+  expect(deps.mapState.markers.add).toHaveBeenCalled()
+})
+
+/* ------------------------------------------------------------------ */
+/* featureId guard (FULL COVERAGE)                                    */
+/* ------------------------------------------------------------------ */
+
+it('skips dispatch when idProperty exists but featureId is falsy', () => {
+  featureQueries.findMatchingFeature.mockReturnValue({
+    feature: {
+      properties: { parcelId: undefined },
+      geometry: { type: 'Point' },
+      layer: { id: 'parcels' }
+    },
+    config: { layerId: 'parcels', idProperty: 'parcelId' }
+  })
+
+  const { result, deps } = setup()
+
+  click(result)
+
+  expect(deps.pluginState.dispatch).not.toHaveBeenCalled()
+})
+
+/* ------------------------------------------------------------------ */
+/* Multi-select                                                       */
+/* ------------------------------------------------------------------ */
+
+it('passes multiSelect flag through to dispatch', () => {
+  const { result, deps } = setup({ multiSelect: true })
+
+  click(result)
+
+  expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+    expect.objectContaining({
+      payload: expect.objectContaining({ multiSelect: true })
+    })
+  )
+})
+
+/* ------------------------------------------------------------------ */
+/* Contiguous selection (FULL COVERAGE)                               */
+/* ------------------------------------------------------------------ */
+
+describe('contiguous selection', () => {
+  it('does NOT replace selection when feature is contiguous', () => {
+    isContiguousWithAny.mockReturnValue(true) // contiguous
+
+    const { result, deps } = setup({
+      contiguous: true,
+      selectedFeatures: [{ geometry: { type: 'Polygon' } }]
+    })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          replaceAll: false
+        })
+      })
+    )
+  })
+
+  it('replaces selection when feature is NOT contiguous', () => {
+    isContiguousWithAny.mockReturnValue(false) // disjoint
+
+    const { result, deps } = setup({
+      contiguous: true,
+      selectedFeatures: [{ geometry: { type: 'Polygon' } }]
+    })
+
+    click(result)
+
+    expect(deps.pluginState.dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          replaceAll: true
+        })
+      })
+    )
+  })
+
+  it('does not compute contiguity when contiguous is false', () => {
+    const { result } = setup({ contiguous: false })
+
+    click(result)
+
+    expect(isContiguousWithAny).not.toHaveBeenCalled()
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* Marker condition guard (FULL COVERAGE)                             */
+/* ------------------------------------------------------------------ */
+
+it('does NOT place marker in auto mode when no dataLayers exist', () => {
+  featureQueries.getFeaturesAtPoint.mockReturnValue([])
+  featureQueries.findMatchingFeature.mockReturnValue(null)
+
+  const { result, deps } = setup({
+    interactionMode: 'auto',
+    dataLayers: []
+  })
+
+  click(result)
+
+  expect(deps.mapState.markers.add).not.toHaveBeenCalled()
+})
+
+/* ------------------------------------------------------------------ */
+/* Selection change event                                             */
+/* ------------------------------------------------------------------ */
+
+it('emits selectionchange once when bounds exist', () => {
+  const deps = {
+    mapState: { markers: { add: jest.fn(), remove: jest.fn() } },
+    pluginState: {
+      selectedFeatures: [{ featureId: 'F1' }],
+      selectionBounds: { sw: [0, 0], ne: [1, 1] }
+    },
+    services: { eventBus: { emit: jest.fn() } },
+    mapProvider: {}
+  }
+
+  renderHook(() => useInteractionHandlers(deps))
+
+  expect(deps.services.eventBus.emit).toHaveBeenCalledWith(
+    'interact:selectionchange',
+    expect.objectContaining({
+      selectedFeatures: deps.pluginState.selectedFeatures,
+      selectionBounds: deps.pluginState.selectionBounds,
+      canMerge: false,
+      canSplit: false
+    })
+  )
+})
+
+it('skips emission when selection remains empty after being cleared', () => {
+  const eventBus = { emit: jest.fn() }
+  
+  // 1. First render with a feature (prev is null, emission happens)
+  const { rerender } = renderHook(
+    ({ features }) => useInteractionHandlers({
+      mapState: { markers: {} },
+      pluginState: { selectedFeatures: features, selectionBounds: { b: 1 } },
+      services: { eventBus },
+      mapProvider: {}
+    }),
+    { initialProps: { features: [{ id: 'f1' }] } }
+  )
+  
+  expect(eventBus.emit).toHaveBeenCalledTimes(1)
+  eventBus.emit.mockClear()
+
+  // 2. Rerender with empty selection (prev is now [{id: 'f1'}], emission happens)
+  rerender({ features: [] })
+  expect(eventBus.emit).toHaveBeenCalledTimes(1)
+  eventBus.emit.mockClear()
+
+  // 3. Rerender with empty selection AGAIN 
+  // This triggers: prev !== null AND prev.length === 0
+  rerender({ features: [] })
+  
+  // Should skip emission because wasEmpty is true (via prev.length === 0) 
+  // and current features.length is 0
+  expect(eventBus.emit).not.toHaveBeenCalled()
+})
+
+/* ------------------------------------------------------------------ */
+/* Debug mode                                                         */
+/* ------------------------------------------------------------------ */
+
+it('logs features when debug mode is enabled', () => {
+  const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+
+  const { result } = setup({ debug: true })
+
+  click(result)
+
+  expect(logSpy).toHaveBeenCalledWith(
+    expect.stringContaining('--- Features at'),
+    expect.any(Array)
+  )
+
+  logSpy.mockRestore()
+})

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

@@ -0,0 +1,22 @@
+import createPlugin from './index.js'
+
+jest.mock('./interact.scss', () => ({}))
+
+describe('createPlugin', () => {
+  it('returns plugin with fixed id and load function', () => {
+    const plugin = createPlugin({ foo: 'bar' })
+    expect(plugin.id).toBe('interact')
+    expect(typeof plugin.load).toBe('function')
+    expect(plugin.foo).toBe('bar') // merged option
+  })
+
+  it('load() returns manifest', async () => {
+    const plugin = createPlugin()
+    const manifest = await plugin.load()
+    expect(manifest).toBeDefined()
+    expect(manifest.InitComponent).toBeDefined()
+    expect(manifest.reducer).toBeDefined()
+    expect(Array.isArray(manifest.buttons)).toBe(true)
+    expect(manifest.api).toBeDefined()
+  })
+})

package/plugins/interact/src/interact.scss

@@ -21,4 +21,10 @@
 .im-o-app--mobile .im-c-mark-location .im-c-map-button {
     flex: 1 1 auto;
     min-width: fit-content;
+}
+
+// Position touch select button
+.im-c-button-wrapper--select-at-target {
+    position: absolute;
+    bottom: calc(100% + var(--primary-gap));
 }

package/plugins/interact/src/manifest.js

@@ -20,7 +20,7 @@ export const manifest = {
     label: 'Done',
     variant: 'primary',
     excludeWhen: ({ appState, pluginState }) => !pluginState.enabled || !appState.isFullscreen,
-    enableWhen: ({ mapState, pluginState }) => !!mapState.markers.items.find(m => m.id === 'location') || !!pluginState.selectionBounds,
+    enableWhen: ({ mapState, pluginState }) => !!mapState.markers.items.some(m => m.id === 'location') || !!pluginState.selectionBounds,
     mobile: {
       slot: 'actions',
       showLabel: true

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

@@ -0,0 +1,94 @@
+import { manifest } from './manifest.js'
+import { initialState, actions } from './reducer.js'
+
+jest.mock('./api/enable.js', () => ({ enable: jest.fn() }))
+jest.mock('./api/disable.js', () => ({ disable: jest.fn() }))
+jest.mock('./api/clear.js', () => ({ clear: jest.fn() }))
+jest.mock('./api/selectFeature.js', () => ({ selectFeature: jest.fn() }))
+jest.mock('./api/unselectFeature.js', () => ({ unselectFeature: jest.fn() }))
+
+describe('manifest', () => {
+  it('has InitComponent', () => {
+    expect(manifest.InitComponent).toBeDefined()
+  })
+
+  it('has reducer with initialState and actions', () => {
+    expect(manifest.reducer.initialState).toBeDefined()
+    expect(manifest.reducer.actions).toBeDefined()
+  })
+
+  it('defines buttons with correct ids', () => {
+    const ids = manifest.buttons.map(b => b.id)
+    expect(ids).toEqual(expect.arrayContaining(['selectDone', 'selectAtTarget', 'selectCancel']))
+  })
+
+  it('buttons have slots and showLabel', () => {
+    manifest.buttons.forEach(b => {
+      ['mobile','tablet','desktop'].forEach(dev => {
+        expect(b[dev].slot).toBe('actions')
+        expect(b[dev].showLabel).toBe(true)
+      })
+    })
+  })
+
+  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', () => {
+    expect(Array.isArray(manifest.keyboardShortcuts)).toBe(true)
+  })
+
+  it('api exposes expected methods', () => {
+    ['enable','disable','clear','selectFeature','unselectFeature'].forEach(fn => {
+      expect(typeof manifest.api[fn]).toBe('function')
+    })
+  })
+})

package/plugins/interact/src/reducer.js

@@ -4,6 +4,7 @@ const initialState = {
   markerColor: null,
   interactionMode: null,
   multiSelect: false,
+  contiguous: false,
   selectedFeatures: [],
   selectionBounds: null,
   closeOnAction: true // Done or Cancel
@@ -20,7 +21,9 @@ const enable = (state, payload) => {
 const disable = (state) => {
   return {
     ...state,
-    enabled: false
+    enabled: false,
+    selectedFeatures: [],
+    selectionBounds: null
   }
 }
 
@@ -29,37 +32,41 @@ const disable = (state) => {
  * Structure of items in Set: { featureId: string, layerId: string, idProperty: string }
  */
 const toggleSelectedFeatures = (state, payload) => {
-  const { featureId, multiSelect, layerId, idProperty, addToExisting = true, properties, geometry } = payload
-  const selected = Array.isArray(state.selectedFeatures) ? [...state.selectedFeatures] : []
-
-  const existingIndex = selected.findIndex(
+  const { featureId, multiSelect, layerId, idProperty, addToExisting = true, replaceAll = false, properties, geometry } = payload
+  const currentSelected = Array.isArray(state.selectedFeatures) ? state.selectedFeatures : []
+  
+  const existingIndex = currentSelected.findIndex(
     f => f.featureId === featureId && f.layerId === layerId
   )
 
-  // Handle explicit unselect
+  // 1. Handle explicit unselect
   if (addToExisting === false) {
-    if (existingIndex !== -1) {
-      selected.splice(existingIndex, 1) // remove the feature
-    }
-    return { ...state, selectedFeatures: selected }
+    const filtered = currentSelected.filter((_, i) => i !== existingIndex)
+    return { ...state, selectedFeatures: filtered, selectionBounds: null }
   }
 
-  // Multi-select mode (add to selection)
-  if (multiSelect) {
+  // Define the feature object once to avoid repetition
+  const featureObj = { featureId, layerId, idProperty, properties, geometry }
+  let nextSelected
+
+  // 2. Determine New State 
+  // We combine 'replaceAll' and 'single-select' because they share the same logic
+  if (multiSelect && !replaceAll) {
+    const selectedCopy = [...currentSelected]
     if (existingIndex === -1) {
-      selected.push({ featureId, layerId, idProperty, properties, geometry })
+      selectedCopy.push(featureObj)
     } else {
-      // optional: could also remove existing on toggle
-      selected.splice(existingIndex, 1)
+      selectedCopy.splice(existingIndex, 1)
     }
-    return { ...state, selectedFeatures: selected }
+    nextSelected = selectedCopy
+  } else {
+    // Both 'replaceAll' and single-select mode logic:
+    // If same feature is already the only one, toggle off; otherwise return just this feature.
+    const isSameSingle = existingIndex !== -1 && currentSelected.length === 1
+    nextSelected = isSameSingle ? [] : [featureObj]
   }
 
-  // Single-select mode
-  const isSameSingle = existingIndex !== -1 && selected.length === 1
-  const newSelected = isSameSingle ? [] : [{ featureId, layerId, idProperty, properties, geometry }]
-
-  return { ...state, selectedFeatures: newSelected }
+  return { ...state, selectedFeatures: nextSelected, selectionBounds: null }
 }
 
 // Update bounds (called from useEffect after map provider calculates them)