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

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

@@ -0,0 +1,260 @@
+import { renderHook, act } from '@testing-library/react'
+import { useInteractionHandlers } from './useInteractionHandlers.js'
+import * as featureQueries from '../utils/featureQueries.js'
+import booleanDisjoint from '@turf/boolean-disjoint'
+
+/* ------------------------------------------------------------------ */
+/* Mocks                                                              */
+/* ------------------------------------------------------------------ */
+
+jest.mock('@turf/boolean-disjoint', () => jest.fn())
+jest.mock('../utils/turfHelpers.js', () => ({
+  toTurfGeometry: jest.fn(g => g)
+}))
+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', () => {
+    booleanDisjoint.mockReturnValue(false) // overlapping
+
+    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', () => {
+    booleanDisjoint.mockReturnValue(true) // 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(booleanDisjoint).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',
+    deps.pluginState
+  )
+})

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/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
@@ -29,7 +30,7 @@ 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 { featureId, multiSelect, layerId, idProperty, addToExisting = true, replaceAll = false, properties, geometry } = payload
   const selected = Array.isArray(state.selectedFeatures) ? [...state.selectedFeatures] : []
 
   const existingIndex = selected.findIndex(
@@ -44,6 +45,14 @@ const toggleSelectedFeatures = (state, payload) => {
     return { ...state, selectedFeatures: selected }
   }
 
+  // Replace all selected features if flag is true
+  if (replaceAll) {
+    return {
+      ...state,
+      selectedFeatures: [{ featureId, layerId, idProperty, properties, geometry }]
+    }
+  }
+
   // Multi-select mode (add to selection)
   if (multiSelect) {
     if (existingIndex === -1) {

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

@@ -0,0 +1,142 @@
+import { initialState, actions } from './reducer.js'
+
+describe('initialState', () => {
+  it('has correct defaults', () => {
+    expect(initialState).toEqual({
+      enabled: false,
+      dataLayers: [],
+      markerColor: null,
+      interactionMode: null,
+      multiSelect: false,
+      contiguous: false,
+      selectedFeatures: [],
+      selectionBounds: null,
+      closeOnAction: true
+    })
+  })
+})
+
+describe('ENABLE/DISABLE actions', () => {
+  it('ENABLE sets enabled and merges payload', () => {
+    const state = { ...initialState, enabled: false }
+    const payload = { dataLayers: [1], markerColor: 'red' }
+    const result = actions.ENABLE(state, payload)
+
+    expect(result.enabled).toBe(true)
+    expect(result.dataLayers).toEqual([1])
+    expect(result.markerColor).toBe('red')
+    expect(result).not.toBe(state)
+  })
+
+  it('DISABLE sets enabled to false but preserves other state', () => {
+    const state = { ...initialState, enabled: true, dataLayers: [1], markerColor: 'red' }
+    const result = actions.DISABLE(state)
+
+    expect(result.enabled).toBe(false)
+    expect(result.dataLayers).toEqual([1])
+    expect(result.markerColor).toBe('red')
+    expect(result).not.toBe(state)
+  })
+})
+
+
+describe('TOGGLE_SELECTED_FEATURES action', () => {
+  const createFeature = (id, layerId = 'layer1') => ({
+    featureId: id,
+    layerId,
+    idProperty: 'id',
+    properties: { name: `Feature ${id}` },
+    geometry: { type: 'Point', coordinates: [0, 0] }
+  })
+
+  it('handles single-select, multi-select, add/remove, and replaceAll', () => {
+    let state = { ...initialState }
+
+    // Single-select: add
+    state = actions.TOGGLE_SELECTED_FEATURES(state, createFeature('f1'))
+    expect(state.selectedFeatures).toHaveLength(1)
+
+    // Single-select: replace
+    state = actions.TOGGLE_SELECTED_FEATURES(state, createFeature('f2'))
+    expect(state.selectedFeatures[0].featureId).toBe('f2')
+
+    // Toggle off same
+    state = actions.TOGGLE_SELECTED_FEATURES(state, createFeature('f2'))
+    expect(state.selectedFeatures).toHaveLength(0)
+
+    // Multi-select: add multiple
+    state = actions.TOGGLE_SELECTED_FEATURES(state, { ...createFeature('f1'), multiSelect: true })
+    state = actions.TOGGLE_SELECTED_FEATURES(state, { ...createFeature('f2'), multiSelect: true })
+    expect(state.selectedFeatures.map(f => f.featureId)).toEqual(['f1', 'f2'])
+
+    // Multi-select: remove
+    state = actions.TOGGLE_SELECTED_FEATURES(state, { ...createFeature('f1'), multiSelect: true })
+    expect(state.selectedFeatures.map(f => f.featureId)).toEqual(['f2'])
+
+    // addToExisting false removes only the feature
+    state = actions.TOGGLE_SELECTED_FEATURES(state, { ...createFeature('f2'), addToExisting: false })
+    expect(state.selectedFeatures).toHaveLength(0)
+
+    // replaceAll replaces everything
+    state = actions.TOGGLE_SELECTED_FEATURES(state, { ...createFeature('f3'), replaceAll: true })
+    expect(state.selectedFeatures).toHaveLength(1)
+    expect(state.selectedFeatures[0].featureId).toBe('f3')
+  })
+
+  it('handles null or empty selectedFeatures gracefully', () => {
+    let state = { ...initialState, selectedFeatures: null }
+    state = actions.TOGGLE_SELECTED_FEATURES(state, createFeature('f1'))
+    expect(state.selectedFeatures).toHaveLength(1)
+
+    state = { ...initialState, selectedFeatures: [] }
+    state = actions.TOGGLE_SELECTED_FEATURES(state, { ...createFeature('f2'), addToExisting: false })
+    expect(state.selectedFeatures).toEqual([])
+  })
+
+  it('matches by both featureId and layerId', () => {
+    const state = { ...initialState, selectedFeatures: [createFeature('f1', 'layer1')] }
+    const payload = createFeature('f1', 'layer2')
+    const result = actions.TOGGLE_SELECTED_FEATURES(state, payload)
+    expect(result.selectedFeatures[0].layerId).toBe('layer2')
+  })
+})
+
+describe('UPDATE_SELECTED_BOUNDS action', () => {
+  it('updates selectionBounds correctly', () => {
+    const state = { ...initialState, selectionBounds: { sw: [0, 0], ne: [1, 1] } }
+    const newBounds = { sw: [0, 0], ne: [2, 2] }
+    const result = actions.UPDATE_SELECTED_BOUNDS(state, newBounds)
+    expect(result.selectionBounds).toEqual(newBounds)
+
+    // unchanged bounds returns same state
+    const result2 = actions.UPDATE_SELECTED_BOUNDS(state, { sw: [0, 0], ne: [1, 1] })
+    expect(result2).toBe(state)
+  })
+})
+
+describe('CLEAR_SELECTED_FEATURES action', () => {
+  it('resets selection and bounds', () => {
+    const state = {
+      ...initialState,
+      selectedFeatures: [1],
+      selectionBounds: { sw: [0, 0], ne: [1, 1] }
+    }
+    const result = actions.CLEAR_SELECTED_FEATURES(state)
+    expect(result.selectedFeatures).toEqual([])
+    expect(result.selectionBounds).toBeNull()
+    expect(result).not.toBe(state)
+  })
+})
+
+describe('actions object', () => {
+  it('exports all action handlers as functions', () => {
+    expect(Object.keys(actions)).toEqual([
+      'ENABLE',
+      'DISABLE',
+      'TOGGLE_SELECTED_FEATURES',
+      'UPDATE_SELECTED_BOUNDS',
+      'CLEAR_SELECTED_FEATURES'
+    ])
+    Object.values(actions).forEach(fn => expect(typeof fn).toBe('function'))
+  })
+})

package/plugins/interact/src/utils/buildStylesMap.test.js

@@ -0,0 +1,57 @@
+import { buildStylesMap } from './buildStylesMap.js'
+import { DEFAULTS } from '../defaults.js'
+import { getValueForStyle } from '../../../../src/utils/getValueForStyle.js'
+
+jest.mock('../../../../src/utils/getValueForStyle.js', () => ({
+  getValueForStyle: jest.fn((value) => value)
+}))
+
+describe('buildStylesMap', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('returns empty object when mapStyle is falsy or dataLayers empty', () => {
+    expect(buildStylesMap([{ layerId: 'test' }], null)).toEqual({})
+    expect(buildStylesMap([{ layerId: 'test' }], undefined)).toEqual({})
+    expect(buildStylesMap([], { id: 'default' })).toEqual({})
+  })
+
+  it('builds correct stylesMap with defaults and layer overrides', () => {
+    const dataLayers = [
+      { layerId: 'custom1', selectedStroke: 'red', selectedFill: 'blue', selectedStrokeWidth: 5 },
+      { layerId: 'custom2' } // uses defaults
+    ]
+    const mapStyle = { id: 'default-style' }
+
+    const result = buildStylesMap(dataLayers, mapStyle)
+
+    // Layer-specific values
+    expect(result.custom1).toEqual({
+      stroke: 'red',
+      fill: 'blue',
+      strokeWidth: 5
+    })
+
+    // Default fallback values
+    expect(result.custom2.stroke).toBe(DEFAULTS.selectedStroke)
+    expect(result.custom2.fill).toBe(DEFAULTS.selectedFill)
+    expect(result.custom2.strokeWidth).toBe(DEFAULTS.selectedStrokeWidth)
+  })
+
+  it('calls getValueForStyle for stroke and fill with mapStyle.id', () => {
+    const dataLayers = [
+      { layerId: 'layer1', selectedStroke: 'strokeVal', selectedFill: 'fillVal' }
+    ]
+    const mapStyle = { id: 'mapStyleId' }
+
+    buildStylesMap(dataLayers, mapStyle)
+
+    expect(getValueForStyle).toHaveBeenCalledWith('strokeVal', 'mapStyleId')
+    expect(getValueForStyle).toHaveBeenCalledWith('fillVal', 'mapStyleId')
+
+    // Ensure strokeWidth is not passed to getValueForStyle
+    const numberCalls = getValueForStyle.mock.calls.filter(call => typeof call[0] === 'number')
+    expect(numberCalls).toHaveLength(0)
+  })
+})

package/plugins/interact/src/utils/featureQueries.test.js

@@ -0,0 +1,56 @@
+import { buildLayerConfigMap, getFeaturesAtPoint, findMatchingFeature } from './featureQueries.js'
+
+describe('buildLayerConfigMap', () => {
+  it('builds map keyed by layerId, handles empty array', () => {
+    const dataLayers = [
+      { layerId: 'a', value: 1 },
+      { layerId: 'b', value: 2 }
+    ]
+
+    const result = buildLayerConfigMap(dataLayers)
+    expect(result).toEqual({
+      a: { layerId: 'a', value: 1 },
+      b: { layerId: 'b', value: 2 }
+    })
+
+    expect(buildLayerConfigMap([])).toEqual({})
+  })
+})
+
+describe('getFeaturesAtPoint', () => {
+  it('returns features or empty array, handles errors', () => {
+    const features = [{ id: 'f1' }]
+    const mockProvider = {
+      getFeaturesAtPoint: jest.fn(() => features)
+    }
+
+    expect(getFeaturesAtPoint(mockProvider, { x: 0, y: 0 })).toBe(features)
+    expect(getFeaturesAtPoint(null, { x: 0, y: 0 })).toEqual([])
+    expect(getFeaturesAtPoint(undefined, { x: 0, y: 0 })).toEqual([])
+
+    // error handling
+    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const errorProvider = { getFeaturesAtPoint: jest.fn(() => { throw new Error('fail') }) }
+    expect(getFeaturesAtPoint(errorProvider, { x: 0, y: 0 })).toEqual([])
+    expect(consoleSpy).toHaveBeenCalledWith('Feature query failed:', expect.any(Error))
+    consoleSpy.mockRestore()
+  })
+})
+
+describe('findMatchingFeature', () => {
+  const layerConfigMap = { layer1: { layerId: 'layer1' } }
+
+  it('returns first feature matching config, null otherwise', () => {
+    const features = [
+      { id: 'f1', layer: { id: 'unknown' } },
+      { id: 'f2', layer: { id: 'layer1' } }
+    ]
+    const result = findMatchingFeature(features, layerConfigMap)
+    expect(result).toEqual({ feature: features[1], config: layerConfigMap.layer1 })
+
+    expect(findMatchingFeature([], layerConfigMap)).toBeNull()
+    expect(findMatchingFeature([{ id: 'f3', layer: {} }], layerConfigMap)).toBeNull()
+    expect(findMatchingFeature([{ id: 'f4' }], layerConfigMap)).toBeNull()
+    expect(findMatchingFeature([{ id: 'f5', layer: { id: 'other' } }], {})).toBeNull()
+  })
+})