@defra/interactive-map 0.0.7-alpha → 0.0.9-alpha

package/providers/maplibre/src/mapEvents.test.js

@@ -0,0 +1,115 @@
+import { attachMapEvents } from './mapEvents.js'
+
+jest.mock('../../../src/utils/debounce.js', () => ({
+  debounce: jest.fn(fn => {
+    const d = jest.fn((...args) => fn(...args))
+    d.cancel = jest.fn()
+    return d
+  })
+}))
+
+jest.mock('../../../src/utils/throttle.js', () => ({
+  throttle: jest.fn(fn => {
+    const t = jest.fn((...args) => fn(...args))
+    t.cancel = jest.fn()
+    return t
+  })
+}))
+
+describe('attachMapEvents', () => {
+  let map, eventBus, events, getCenter, getZoom, getBounds, getResolution, result
+
+  const handler = (evt) => map.on.mock.calls.find(([e]) => e === evt)[1]
+
+  beforeEach(() => {
+    map = {
+      on: jest.fn(),
+      once: jest.fn(),
+      off: jest.fn(),
+      getMaxZoom: jest.fn(() => 20),
+      getMinZoom: jest.fn(() => 0)
+    }
+    eventBus = { emit: jest.fn() }
+    events = {
+      MAP_LOADED: 'loaded', MAP_FIRST_IDLE: 'firstIdle', MAP_MOVE_START: 'moveStart',
+      MAP_MOVE_END: 'moveEnd', MAP_MOVE: 'move', MAP_RENDER: 'render',
+      MAP_DATA_CHANGE: 'dataChange', MAP_STYLE_CHANGE: 'styleChange', MAP_CLICK: 'click'
+    }
+    getCenter = jest.fn(() => [0, 0])
+    getZoom = jest.fn(() => 10)
+    getBounds = jest.fn(() => [[0, 0], [1, 1]])
+    getResolution = jest.fn(() => 100)
+    result = attachMapEvents({ map, events, eventBus, getCenter, getZoom, getBounds, getResolution })
+  })
+
+  test('registers listeners for all map events', () => {
+    ;['load', 'movestart', 'moveend', 'zoom', 'render', 'styledata', 'style.load', 'click'].forEach(e =>
+      expect(map.on).toHaveBeenCalledWith(e, expect.any(Function))
+    )
+    expect(map.once).toHaveBeenCalledWith('idle', expect.any(Function))
+  })
+
+  test('stateless events emit correct event names', () => {
+    handler('load')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_LOADED, undefined)
+    handler('movestart')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_MOVE_START, undefined)
+    handler('render')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_RENDER, undefined)
+    handler('style.load')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_STYLE_CHANGE, undefined)
+  })
+
+  test('stateful events emit map state', () => {
+    const state = {
+      center: [0, 0], bounds: [[0, 0], [1, 1]], resolution: 100,
+      zoom: 10, isAtMaxZoom: false, isAtMinZoom: false
+    }
+    map.once.mock.calls.find(([e]) => e === 'idle')[1]()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_FIRST_IDLE, state)
+    handler('moveend')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_MOVE_END, state)
+    handler('zoom')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_MOVE, state)
+    handler('styledata')()
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_DATA_CHANGE, state)
+  })
+
+  test('getMapState: isAtMaxZoom true at max zoom; isAtMinZoom true at min zoom', () => {
+    getZoom.mockReturnValue(20)
+    handler('moveend')()
+    expect(eventBus.emit).toHaveBeenLastCalledWith(events.MAP_MOVE_END,
+      expect.objectContaining({ isAtMaxZoom: true, isAtMinZoom: false })
+    )
+    eventBus.emit.mockClear()
+    getZoom.mockReturnValue(0)
+    handler('moveend')()
+    expect(eventBus.emit).toHaveBeenLastCalledWith(events.MAP_MOVE_END,
+      expect.objectContaining({ isAtMaxZoom: false, isAtMinZoom: true })
+    )
+  })
+
+  test('click emits MAP_CLICK with point and coords', () => {
+    handler('click')({ point: { x: 10, y: 20 }, lngLat: { lng: -1.5, lat: 52.3 } })
+    expect(eventBus.emit).toHaveBeenCalledWith(events.MAP_CLICK, {
+      point: { x: 10, y: 20 },
+      coords: [-1.5, 52.3]
+    })
+  })
+
+  test('remove() cancels debouncers and unregisters all handlers', () => {
+    const moveEndFn = handler('moveend')
+    const moveFn = handler('zoom')
+    const dataChangeFn = handler('styledata')
+
+    result.remove()
+
+    expect(moveEndFn.cancel).toHaveBeenCalled()
+    expect(moveFn.cancel).toHaveBeenCalled()
+    expect(dataChangeFn.cancel).toHaveBeenCalled()
+    expect(map.off).toHaveBeenCalledTimes(8)
+    ;['load', 'movestart', 'moveend', 'zoom', 'render', 'styledata', 'style.load', 'click'].forEach(e =>
+      expect(map.off).toHaveBeenCalledWith(e, expect.any(Function))
+    )
+  })
+})

package/providers/maplibre/src/maplibreProvider.test.js

@@ -0,0 +1,205 @@
+import MapLibreProvider from './maplibreProvider.js'
+import { attachMapEvents } from './mapEvents.js'
+import { attachAppEvents } from './appEvents.js'
+import { createMapLabelNavigator } from './utils/labels.js'
+import { updateHighlightedFeatures } from './utils/highlightFeatures.js'
+import { queryFeatures } from './utils/queryFeatures.js'
+import { getAreaDimensions, getCardinalMove, getResolution, getPaddedBounds } from './utils/spatial.js'
+
+jest.mock('./defaults.js', () => ({
+  DEFAULTS: { animationDuration: 400, coordinatePrecision: 7 },
+  supportedShortcuts: []
+}))
+jest.mock('./utils/maplibreFixes.js', () => ({
+  cleanCanvas: jest.fn(),
+  applyPreventDefaultFix: jest.fn()
+}))
+jest.mock('./mapEvents.js', () => ({ attachMapEvents: jest.fn() }))
+jest.mock('./appEvents.js', () => ({ attachAppEvents: jest.fn() }))
+jest.mock('./utils/spatial.js', () => ({
+  getAreaDimensions: jest.fn(() => '400m by 750m'),
+  getCardinalMove: jest.fn(() => 'north'),
+  getResolution: jest.fn(() => 10),
+  getPaddedBounds: jest.fn(() => [[0, 0], [1, 1]])
+}))
+jest.mock('./utils/labels.js', () => ({
+  createMapLabelNavigator: jest.fn(() => ({
+    highlightNextLabel: jest.fn(() => 'next'),
+    highlightLabelAtCenter: jest.fn(() => 'center'),
+    clearHighlightedLabel: jest.fn(() => 'cleared')
+  }))
+}))
+jest.mock('./utils/highlightFeatures.js', () => ({ updateHighlightedFeatures: jest.fn(() => []) }))
+jest.mock('./utils/queryFeatures.js', () => ({ queryFeatures: jest.fn(() => []) }))
+
+describe('MapLibreProvider', () => {
+  let map, eventBus, maplibreModule, loadCallback
+
+  beforeEach(() => {
+    loadCallback = null
+    map = {
+      touchZoomRotate: { disableRotation: jest.fn() },
+      on: jest.fn((e, fn) => { if (e === 'load') loadCallback = fn }),
+      off: jest.fn(),
+      remove: jest.fn(),
+      setPadding: jest.fn(),
+      fitBounds: jest.fn(),
+      flyTo: jest.fn(),
+      easeTo: jest.fn(),
+      panBy: jest.fn(),
+      project: jest.fn(() => ({ x: 100, y: 200 })),
+      unproject: jest.fn(() => ({ lng: 1, lat: 2 })),
+      getCenter: jest.fn(() => ({ lng: 1.2345678, lat: 2.3456789 })),
+      getZoom: jest.fn(() => 10),
+      getBounds: jest.fn(() => ({ toArray: jest.fn(() => [[0, 0], [1, 1]]) }))
+    }
+    eventBus = { emit: jest.fn() }
+    maplibreModule = { Map: jest.fn(() => map), LngLatBounds: jest.fn() }
+  })
+
+  const makeProvider = (config = {}) => new MapLibreProvider({
+    mapFramework: maplibreModule,
+    events: { MAP_READY: 'map:ready' },
+    eventBus,
+    ...config
+  })
+
+  const doInitMap = (p, extra = {}) => p.initMap({
+    container: 'div', padding: {}, mapStyle: { url: 'style.json', mapColorScheme: 'dark' },
+    center: [0, 0], zoom: 5, ...extra
+  })
+
+  test('constructor spreads mapProviderConfig and sets capabilities', () => {
+    const p = makeProvider({ mapProviderConfig: { crs: 'EPSG:4326', tileSize: 512 } })
+    expect(p.crs).toBe('EPSG:4326')
+    expect(p.tileSize).toBe(512)
+    expect(p.capabilities.supportsMapSizes).toBe(true)
+  })
+
+  test('initMap: creates map, disables rotation, attaches events, emits MAP_READY', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    expect(maplibreModule.Map).toHaveBeenCalledWith(expect.objectContaining({ style: 'style.json' }))
+    expect(map.touchZoomRotate.disableRotation).toHaveBeenCalled()
+    expect(map.setPadding).toHaveBeenCalled()
+    expect(attachMapEvents).toHaveBeenCalled()
+    expect(attachAppEvents).toHaveBeenCalled()
+    expect(eventBus.emit).toHaveBeenCalledWith('map:ready', expect.any(Object))
+  })
+
+  test('initMap: fitBounds called when bounds provided; skipped when absent; null mapStyle → style undefined', async () => {
+    const p = makeProvider()
+    await doInitMap(p, { bounds: [[0, 0], [1, 1]] })
+    expect(map.fitBounds).toHaveBeenCalledWith([[0, 0], [1, 1]], { duration: 0 })
+
+    map.fitBounds.mockClear()
+    const p2 = makeProvider()
+    await p2.initMap({ container: 'div', padding: {}, mapStyle: null, center: [0, 0], zoom: 5 })
+    expect(map.fitBounds).not.toHaveBeenCalled()
+    expect(maplibreModule.Map).toHaveBeenLastCalledWith(expect.objectContaining({ style: undefined }))
+  })
+
+  test('load callback: creates labelNavigator with mapColorScheme; undefined when mapStyle null', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    loadCallback()
+    expect(createMapLabelNavigator).toHaveBeenCalledWith(map, 'dark', expect.anything(), eventBus)
+    expect(p.labelNavigator).toBeDefined()
+
+    createMapLabelNavigator.mockClear()
+    const p2 = makeProvider()
+    await p2.initMap({ container: 'div', padding: {}, mapStyle: null, center: [0, 0], zoom: 5 })
+    loadCallback()
+    expect(createMapLabelNavigator).toHaveBeenCalledWith(map, undefined, expect.anything(), eventBus)
+  })
+
+  test('destroyMap: calls remove on mapEvents/appEvents if set; skips if absent', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    const mockRemove = jest.fn()
+    p.mapEvents = { remove: mockRemove }
+    p.appEvents = { remove: mockRemove }
+    p.destroyMap()
+    expect(mockRemove).toHaveBeenCalledTimes(2)
+    expect(map.remove).toHaveBeenCalled()
+
+    const p2 = makeProvider()
+    await doInitMap(p2)
+    expect(() => p2.destroyMap()).not.toThrow()
+  })
+
+  test('setView: uses provided center/zoom; falls back to getCenter/getZoom when omitted', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    p.setView({ center: [1, 2], zoom: 8 })
+    expect(map.flyTo).toHaveBeenCalledWith({ center: [1, 2], zoom: 8, duration: 400 })
+
+    map.flyTo.mockClear()
+    p.setView({})
+    const call = map.flyTo.mock.calls[0][0]
+    expect(call.center).toBeDefined()
+    expect(call.zoom).toBe(10)
+    expect(call.duration).toBe(400)
+  })
+
+  test('zoomIn, zoomOut, panBy, fitToBounds, setPadding delegate to map', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    p.zoomIn(1)
+    expect(map.easeTo).toHaveBeenCalledWith({ zoom: 11, duration: 400 })
+    p.zoomOut(2)
+    expect(map.easeTo).toHaveBeenCalledWith({ zoom: 8, duration: 400 })
+    p.panBy([10, 20])
+    expect(map.panBy).toHaveBeenCalledWith([10, 20], { duration: 400 })
+    p.fitToBounds([[0, 0], [1, 1]])
+    expect(map.fitBounds).toHaveBeenCalledWith([[0, 0], [1, 1]], { duration: 400 })
+    p.setPadding({ top: 5 })
+    expect(map.setPadding).toHaveBeenCalledWith({ top: 5 })
+  })
+
+  test('getCenter, getZoom, getBounds return formatted values', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    expect(p.getCenter()).toEqual([1.2345678, 2.3456789])
+    expect(p.getZoom()).toBe(10)
+    expect(p.getBounds()).toEqual([0, 0, 1, 1])
+  })
+
+  test('spatial helpers delegate correctly', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    expect(p.getAreaDimensions()).toBe('400m by 750m')
+    expect(getPaddedBounds).toHaveBeenCalled()
+    expect(getAreaDimensions).toHaveBeenCalled()
+    expect(p.getCardinalMove([0, 0], [1, 1])).toBe('north')
+    expect(getCardinalMove).toHaveBeenCalledWith([0, 0], [1, 1])
+    p.getResolution()
+    expect(getResolution).toHaveBeenCalled()
+    expect(p.mapToScreen([1, 2])).toEqual({ x: 100, y: 200 })
+    expect(p.screenToMap({ x: 100, y: 200 })).toEqual([1, 2])
+  })
+
+  test('getFeaturesAtPoint and updateHighlightedFeatures delegate correctly', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    p.getFeaturesAtPoint({ x: 10, y: 20 }, { radius: 5 })
+    expect(queryFeatures).toHaveBeenCalledWith(map, { x: 10, y: 20 }, { radius: 5 })
+    p.updateHighlightedFeatures(['feat'], { style: 1 })
+    expect(updateHighlightedFeatures).toHaveBeenCalledWith({
+      LngLatBounds: maplibreModule.LngLatBounds, map, selectedFeatures: ['feat'], stylesMap: { style: 1 }
+    })
+  })
+
+  test('label methods return null without labelNavigator; delegate when set', async () => {
+    const p = makeProvider()
+    await doInitMap(p)
+    expect(p.highlightNextLabel('ArrowRight')).toBeNull()
+    expect(p.highlightLabelAtCenter()).toBeNull()
+    expect(p.clearHighlightedLabel()).toBeNull()
+
+    loadCallback()
+    expect(p.highlightNextLabel('ArrowRight')).toBe('next')
+    expect(p.highlightLabelAtCenter()).toBe('center')
+    expect(p.clearHighlightedLabel()).toBe('cleared')
+  })
+})

package/providers/maplibre/src/utils/calculateLinearTextSize.test.js

@@ -0,0 +1,31 @@
+import { calculateLinearTextSize } from './calculateLinearTextSize.js'
+
+describe('calculateLinearTextSize', () => {
+  it('returns 0 if stops is empty', () => {
+    expect(calculateLinearTextSize({ stops: [] }, 5)).toBe(0)
+  })
+
+  it('returns single stop value if stops has one entry', () => {
+    expect(calculateLinearTextSize({ stops: [[3, 10]] }, 5)).toBe(10)
+  })
+
+  it('returns lower stop if zoom below first stop', () => {
+    expect(calculateLinearTextSize({ stops: [[3, 10], [6, 20]] }, 2)).toBe(10)
+  })
+
+  it('returns upper stop if zoom above last stop', () => {
+    expect(calculateLinearTextSize({ stops: [[3, 10], [6, 20]] }, 7)).toBe(20)
+  })
+
+  it('interpolates between stops for zoom in range', () => {
+    expect(calculateLinearTextSize({ stops: [[3, 10], [6, 20]] }, 4.5)).toBe(15)
+  })
+
+  it('works with multiple stops', () => {
+    const expr = { stops: [[0, 5], [5, 15], [10, 25]] }
+    expect(calculateLinearTextSize(expr, -1)).toBe(5)  // below first
+    expect(calculateLinearTextSize(expr, 12)).toBe(25)  // above last
+    expect(calculateLinearTextSize(expr, 2.5)).toBe(10) // between first two
+    expect(calculateLinearTextSize(expr, 7.5)).toBe(20) // between last two
+  })
+})

package/providers/maplibre/src/utils/detectWebgl.test.js

@@ -0,0 +1,63 @@
+import { getWebGL } from './detectWebgl.js'
+
+describe('getWebGL', () => {
+  const originalWebGL = window.WebGLRenderingContext
+  const originalCreateElement = document.createElement
+
+  afterEach(() => {
+    window.WebGLRenderingContext = originalWebGL
+    document.createElement = originalCreateElement
+    jest.restoreAllMocks()
+  })
+
+  it('returns disabled if WebGL is not supported', () => {
+    window.WebGLRenderingContext = undefined
+    expect(getWebGL(['webgl'])).toEqual({
+      isEnabled: false,
+      error: 'WebGL is not supported'
+    })
+  })
+
+  it('returns enabled if WebGL context is created successfully', () => {
+    window.WebGLRenderingContext = class {}
+    const fakeContext = { getParameter: () => true }
+    document.createElement = jest.fn(() => ({
+      getContext: jest.fn(() => fakeContext)
+    }))
+    expect(getWebGL(['webgl'])).toEqual({ isEnabled: true })
+  })
+
+  it('returns disabled if WebGL is supported but context fails', () => {
+    window.WebGLRenderingContext = class {}
+    document.createElement = jest.fn(() => ({
+      getContext: jest.fn(() => null)
+    }))
+    expect(getWebGL(['webgl'])).toEqual({
+      isEnabled: false,
+      error: 'WebGL is supported, but disabled'
+    })
+  })
+
+  it('tries multiple context names and succeeds on second', () => {
+    window.WebGLRenderingContext = class {}
+    let call = 0
+    document.createElement = jest.fn(() => ({
+      getContext: jest.fn(() => {
+        call++
+        return call === 2 ? { getParameter: () => true } : null
+      })
+    }))
+    expect(getWebGL(['webgl1', 'webgl2'])).toEqual({ isEnabled: true })
+  })
+
+  it('catches errors from getContext and continues', () => {
+    window.WebGLRenderingContext = class {}
+    document.createElement = jest.fn(() => ({
+      getContext: jest.fn(() => { throw new Error('fail') })
+    }))
+    expect(getWebGL(['webgl', 'webgl2'])).toEqual({
+      isEnabled: false,
+      error: 'WebGL is supported, but disabled'
+    })
+  })
+})

package/providers/maplibre/src/utils/highlightFeatures.test.js

@@ -0,0 +1,126 @@
+import { updateHighlightedFeatures } from './highlightFeatures.js'
+
+describe('Highlighting Utils', () => {
+  let map
+  const LngLatBounds = function() {
+    this.coords = []
+    this.extend = (c) => this.coords.push(c)
+    this.getWest = () => Math.min(...this.coords.map(c => c[0]))
+    this.getSouth = () => Math.min(...this.coords.map(c => c[1]))
+    this.getEast = () => Math.max(...this.coords.map(c => c[0]))
+    this.getNorth = () => Math.max(...this.coords.map(c => c[1]))
+  }
+
+  beforeEach(() => {
+    map = {
+      _highlightedSources: new Set(['stale']),
+      getLayer: jest.fn(),
+      addLayer: jest.fn(),
+      setFilter: jest.fn(),
+      setPaintProperty: jest.fn(),
+      queryRenderedFeatures: jest.fn()
+    }
+  })
+
+  test('All branches', () => {
+    // Coverage for Line 93: Null map check
+    expect(updateHighlightedFeatures({ map: null })).toBeNull()
+
+    map.getLayer.mockImplementation((id) => {
+      if (id.includes('stale')) return true // Coverage for Line 49
+      if (id === 'l1') return { source: 's1', type: 'fill' }
+      if (id === 'l2') return { source: 's2', type: 'line' }
+      if (id === 'highlight-s2-fill') return true // Coverage for Line 124
+      return null // Coverage for Line 13
+    })
+
+    const selectedFeatures = [
+      // Coverage for Lines 37-40: Polygon & MultiPolygon checks
+      { featureId: 1, layerId: 'l1', geometry: { type: 'Polygon' } },
+      { featureId: 2, layerId: 'l1', geometry: { type: 'MultiPolygon' } },
+      // Coverage for Line 13: Invalid layer
+      { featureId: 3, layerId: 'invalid' },
+      // Coverage for Line 116: idProperty exists
+      { featureId: 4, layerId: 'l2', idProperty: 'customId', geometry: { type: 'Point' } }
+    ]
+
+    const stylesMap = {
+      l1: { stroke: 'red', fill: 'blue' },
+      l2: { stroke: 'green' }
+    }
+
+    // Coverage for Lines 78-80: Recursive coordinate handling (numbers vs arrays)
+    map.queryRenderedFeatures.mockReturnValue([
+      { id: 1, geometry: { coordinates: [10, 10] } }, // Simple point
+      { id: 2, properties: { customId: 4 }, geometry: { coordinates: [[0, 0], [5, 5]] } } // Nested
+    ])
+
+    const bounds = updateHighlightedFeatures({ LngLatBounds, map, selectedFeatures, stylesMap })
+
+    // Line 13 verify: map.getLayer returned null and function returned early
+    // Line 49-50 verify: Stale sources filtered out
+    expect(map.setFilter).toHaveBeenCalledWith('highlight-stale-fill', ['==', 'id', ''])
+    
+    // Line 124 verify: Clear fill highlight when switching to line geometry
+    expect(map.setFilter).toHaveBeenCalledWith('highlight-s2-fill', ['==', 'id', ''])
+
+    // Line 116 verify: Using ['get', idProperty]
+    expect(map.setFilter).toHaveBeenCalledWith('highlight-s2-line', expect.arrayContaining([['get', 'customId']]))
+
+    // Line 80-82 verify: Recursive LngLatBounds logic
+    expect(bounds).toEqual([0, 0, 10, 10])
+  })
+
+  test('undefined _highlightedSources falls back to empty set; line geom skips absent fill layer', () => {
+    // line 93: || new Set() fallback; line 124 false: no pre-existing fill to clear
+    map._highlightedSources = undefined
+    map.getLayer.mockImplementation(id => id === 'l1' ? { source: 's1', type: 'line' } : null)
+    map.queryRenderedFeatures.mockReturnValue([])
+    updateHighlightedFeatures({ LngLatBounds, map,
+      selectedFeatures: [{ featureId: 1, layerId: 'l1' }],
+      stylesMap: { l1: { stroke: 'red' } }
+    })
+    expect(map.setFilter).not.toHaveBeenCalledWith('highlight-s1-fill', expect.anything())
+  })
+
+  test('persistent source skips cleanup; missing stale layers skip setFilter', () => {
+    // line 37 false: src IS in currentSources; line 41 false: getLayer returns null for stale layers
+    map._highlightedSources = new Set(['stale', 's1'])
+    map.getLayer.mockImplementation(id => id === 'l1' ? { source: 's1', type: 'line' } : null)
+    map.queryRenderedFeatures.mockReturnValue([])
+    updateHighlightedFeatures({ LngLatBounds, map,
+      selectedFeatures: [{ featureId: 1, layerId: 'l1' }],
+      stylesMap: { l1: { stroke: 'red' } }
+    })
+    expect(map.setFilter).not.toHaveBeenCalledWith(expect.stringContaining('stale'), expect.anything())
+  })
+
+  test('reuses existing highlight layer; new layer spreads sourceLayer', () => {
+    // line 50 false: getLayer truthy → skip addLayer for s1
+    // line 55: srcLayer truthy → 'source-layer' spread in addLayer for s2
+    map.getLayer.mockImplementation(id => {
+      if (id === 'l1') return { source: 's1', type: 'line' }
+      if (id === 'l2') return { source: 's2', type: 'line', sourceLayer: 'tiles' }
+      if (id === 'highlight-s1-line') return true
+      return null
+    })
+    map.queryRenderedFeatures.mockReturnValue([])
+    updateHighlightedFeatures({ LngLatBounds, map,
+      selectedFeatures: [
+        { featureId: 1, layerId: 'l1' },
+        { featureId: 2, layerId: 'l2' }
+      ],
+      stylesMap: { l1: { stroke: 'blue' }, l2: { stroke: 'green' } }
+    })
+    expect(map.addLayer).toHaveBeenCalledTimes(1)
+    expect(map.addLayer).toHaveBeenCalledWith(expect.objectContaining({ 'source-layer': 'tiles' }))
+  })
+
+  test('Empty features coverage', () => {
+    // Coverage for Line 72: empty renderedFeatures
+    map.getLayer.mockReturnValue({ source: 's1', type: 'line' })
+    map.queryRenderedFeatures.mockReturnValue([])
+    const res = updateHighlightedFeatures({ LngLatBounds, map, selectedFeatures: [], stylesMap: {} })
+    expect(res).toBeNull()
+  })
+})

package/providers/maplibre/src/utils/labels.js

@@ -234,9 +234,7 @@ export function createMapLabelNavigator(map, mapColorScheme, events, eventBus) {
     }
     const centerPoint = map.project(map.getCenter())
     const closest = findClosestLabel(state.labels, centerPoint)
-    if (closest) {
-      state.currentPixel = { x: closest.x, y: closest.y }
-    }
+    state.currentPixel = { x: closest.x, y: closest.y }
     applyHighlight(map, closest, state)
     return `${closest.text} (${closest.layer.id})`
   }