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

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

@@ -0,0 +1,231 @@
+import {
+  getGeometryCenter, evalInterpolate, getHighlightColors, extractTextPropertyName,
+  buildLabelFromFeature, buildLabelsFromLayers, findClosestLabel,
+  createHighlightLayerConfig, removeHighlightLayer, applyHighlight,
+  navigateToNextLabel, createMapLabelNavigator
+} from './labels.js'
+
+jest.mock('./spatial.js', () => ({ spatialNavigate: jest.fn() }))
+jest.mock('./calculateLinearTextSize.js', () => ({ calculateLinearTextSize: jest.fn(() => 12) }))
+
+import { spatialNavigate } from './spatial.js'
+import { calculateLinearTextSize } from './calculateLinearTextSize.js'
+
+describe('labels utils', () => {
+
+  test('getGeometryCenter all geometry types', () => {
+    expect(getGeometryCenter({ type: 'Point', coordinates: [1, 2] })).toEqual([1, 2])
+    expect(getGeometryCenter({ type: 'MultiPoint', coordinates: [[3, 4]] })).toEqual([3, 4])
+    expect(getGeometryCenter({ type: 'LineString', coordinates: [[0, 0], [4, 4]] })).toEqual([2, 2])
+    expect(getGeometryCenter({ type: 'MultiLineString', coordinates: [[[0, 0], [4, 4]]] })).toEqual([2, 2])
+    expect(getGeometryCenter({ type: 'Polygon', coordinates: [[[0, 0], [2, 0], [2, 2], [0, 2]]] })).toEqual([1, 1])
+    expect(getGeometryCenter({ type: 'MultiPolygon', coordinates: [[[[0, 0], [2, 0], [2, 2], [0, 2]]]] })).toEqual([1, 1])
+    expect(getGeometryCenter({ type: 'GeometryCollection', coordinates: [] })).toBeNull()
+  })
+
+  test('evalInterpolate all branches', () => {
+    expect(evalInterpolate(14, 10)).toBe(14)
+    expect(evalInterpolate('label', 10)).toBe(12)
+    expect(calculateLinearTextSize).toHaveBeenCalledWith('label', 10)
+    expect(evalInterpolate(['literal', 'x'], 10)).toBe(12)
+    expect(() => evalInterpolate(['interpolate', ['linear'], ['get', 'p'], 5, 10], 10)).toThrow()
+    const expr = ['interpolate', ['linear'], ['zoom'], 5, 10, 10, 20]
+    expect(evalInterpolate(expr, 3)).toBe(10)    // zoom <= z0
+    expect(evalInterpolate(expr, 7.5)).toBe(15)  // interpolated
+    expect(evalInterpolate(expr, 15)).toBe(20)   // beyond last stop
+  })
+
+  test('getHighlightColors', () => {
+    expect(getHighlightColors(true)).toEqual({ text: '#ffffff', halo: '#000000' })
+    expect(getHighlightColors(false)).toEqual({ text: '#000000', halo: '#ffffff' })
+  })
+
+  test('extractTextPropertyName all branches', () => {
+    expect(extractTextPropertyName('{name}')).toBe('name')
+    expect(extractTextPropertyName('plain')).toBeUndefined()
+    expect(extractTextPropertyName(['label', ['get', 'title']])).toBe('title')
+    expect(extractTextPropertyName(['label'])).toBeUndefined()
+    expect(extractTextPropertyName(null)).toBeNull()
+  })
+
+  test('buildLabelFromFeature: null center returns null; valid returns label', () => {
+    const map = { project: jest.fn(({ lng, lat }) => ({ x: lng, y: lat })) }
+    expect(buildLabelFromFeature(
+      { geometry: { type: 'Unknown', coordinates: [] }, properties: {} }, {}, 'n', map
+    )).toBeNull()
+    const result = buildLabelFromFeature(
+      { geometry: { type: 'Point', coordinates: [1, 2] }, properties: { n: 'A' } },
+      { id: 'l1' }, 'n', map
+    )
+    expect(result).toMatchObject({ text: 'A', x: 1, y: 2 })
+  })
+
+  test('buildLabelsFromLayers: skips no-propName layer; filters null-center labels', () => {
+    const map = { project: jest.fn(({ lng, lat }) => ({ x: lng, y: lat })) }
+    const layers = [
+      { id: 'l1', layout: {} },
+      { id: 'l2', layout: { 'text-field': '{name}' } }
+    ]
+    const features = [
+      { layer: { id: 'l2' }, properties: { name: 'Town' }, geometry: { type: 'Point', coordinates: [1, 2] } },
+      { layer: { id: 'l2' }, properties: { name: 'X' }, geometry: { type: 'Unknown', coordinates: [] } }
+    ]
+    const result = buildLabelsFromLayers(map, layers, features)
+    expect(result).toHaveLength(1)
+    expect(result[0].text).toBe('Town')
+  })
+
+  test('findClosestLabel: empty → undefined; returns closest; skips farther', () => {
+    expect(findClosestLabel([], { x: 0, y: 0 })).toBeUndefined()
+    const labels = [{ x: 2, y: 0 }, { x: 10, y: 0 }]  // closer first → second hits false branch
+    expect(findClosestLabel(labels, { x: 0, y: 0 })).toBe(labels[0])
+  })
+
+  test('createHighlightLayerConfig returns merged config', () => {
+    const config = createHighlightLayerConfig(
+      { id: 'sl', type: 'symbol', layout: { 'text-font': ['Open Sans'] }, paint: {} },
+      18, { text: '#fff', halo: '#000' }
+    )
+    expect(config.id).toBe('highlight-sl')
+    expect(config.layout['text-size']).toBe(18)
+    expect(config.layout['text-allow-overlap']).toBe(true)
+    expect(config.paint['text-color']).toBe('#fff')
+  })
+
+  test('removeHighlightLayer: skips when no id or layer absent; removes when present', () => {
+    const map = { getLayer: jest.fn(), removeLayer: jest.fn() }
+    const state = { highlightLayerId: null, highlightedExpr: 'x' }
+    removeHighlightLayer(map, state)
+    expect(map.removeLayer).not.toHaveBeenCalled()
+    state.highlightLayerId = 'h1'
+    map.getLayer.mockReturnValue(null)
+    removeHighlightLayer(map, state)
+    expect(map.removeLayer).not.toHaveBeenCalled()
+    map.getLayer.mockReturnValue(true)
+    removeHighlightLayer(map, state)
+    expect(map.removeLayer).toHaveBeenCalledWith('h1')
+    expect(state.highlightLayerId).toBeNull()
+  })
+
+  test('applyHighlight: early returns without feature.layer; applies otherwise', () => {
+    const map = {
+      getLayer: jest.fn(), removeLayer: jest.fn(),
+      getSource: jest.fn(() => ({ setData: jest.fn() })),
+      getZoom: jest.fn(() => 10), addLayer: jest.fn(), moveLayer: jest.fn()
+    }
+    const state = { highlightLayerId: null, highlightedExpr: null, isDarkStyle: false }
+    applyHighlight(map, null, state)
+    applyHighlight(map, { feature: null }, state)
+    applyHighlight(map, { feature: {} }, state)
+    expect(map.addLayer).not.toHaveBeenCalled()
+    applyHighlight(map, {
+      feature: { id: 1, type: 'Feature', properties: {}, geometry: { type: 'Point', coordinates: [0, 0] }, layer: { id: 'l1' } },
+      layer: { id: 'l1', layout: { 'text-size': 12 }, paint: {} }
+    }, state)
+    expect(map.addLayer).toHaveBeenCalled()
+    expect(map.moveLayer).toHaveBeenCalledWith('highlight-l1')
+  })
+
+  test('navigateToNextLabel all branches', () => {
+    expect(navigateToNextLabel('ArrowRight', { currentPixel: null })).toBeNull()
+    expect(navigateToNextLabel('ArrowRight', {
+      currentPixel: { x: 1, y: 1 }, labels: [{ x: 1, y: 1 }]
+    })).toBeNull()
+    const state = { currentPixel: { x: 0, y: 0 }, labels: [{ x: 0, y: 0 }, { x: 5, y: 5 }] }
+    spatialNavigate.mockReturnValue(-1)  // out of range → use 0
+    expect(navigateToNextLabel('ArrowRight', state)).toBe(state.labels[1])
+    spatialNavigate.mockReturnValue(0)   // valid index
+    expect(navigateToNextLabel('ArrowRight', state)).toBe(state.labels[1])
+  })
+
+  describe('createMapLabelNavigator', () => {
+    let map, layers
+
+    beforeEach(() => {
+      layers = [
+        { id: 's1', type: 'symbol', layout: { 'symbol-placement': 'line', 'text-field': '{name}', 'text-size': 12 }, paint: {} },
+        { id: 's2', type: 'symbol', layout: { 'text-field': '{name}', 'text-size': 14 }, paint: {} },
+        { id: 'fill', type: 'fill', layout: {} }
+      ]
+      map = {
+        getStyle: jest.fn(() => ({ layers })),
+        setLayoutProperty: jest.fn(),
+        setPaintProperty: jest.fn(),
+        getSource: jest.fn().mockReturnValueOnce(null).mockReturnValue({ setData: jest.fn() }),
+        addSource: jest.fn(),
+        getLayer: jest.fn(() => null),
+        removeLayer: jest.fn(),
+        addLayer: jest.fn(),
+        moveLayer: jest.fn(),
+        on: jest.fn(),
+        once: jest.fn(),
+        queryRenderedFeatures: jest.fn(() => []),
+        project: jest.fn(c => ({ x: c.lng ?? 0, y: c.lat ?? 0 })),
+        getCenter: jest.fn(() => ({ lng: 0, lat: 0 })),
+        getZoom: jest.fn(() => 10)
+      }
+    })
+
+    test('init, full highlight lifecycle, and zoom handler branches', () => {
+      const eventBus = { on: jest.fn() }
+      const nav = createMapLabelNavigator(map, 'dark', { MAP_SET_STYLE: 'set-style' }, eventBus)
+
+      // Init: line-center placement, addSource, eventBus registration
+      expect(map.setLayoutProperty).toHaveBeenCalledWith('s1', 'symbol-placement', 'line-center')
+      expect(map.setLayoutProperty).not.toHaveBeenCalledWith('s2', 'symbol-placement', expect.anything())
+      expect(map.addSource).toHaveBeenCalled()
+      expect(eventBus.on).toHaveBeenCalledWith('set-style', expect.any(Function))
+
+      // No labels → null for both highlight functions
+      expect(nav.highlightLabelAtCenter()).toBeNull()
+      expect(nav.highlightNextLabel('ArrowRight')).toBeNull()
+
+      // Zoom handler: no active highlight → no-op
+      const zoomHandler = map.on.mock.calls.find(([e]) => e === 'zoom')[1]
+      map.setLayoutProperty.mockClear()
+      zoomHandler()
+      expect(map.setLayoutProperty).not.toHaveBeenCalled()
+
+      // One feat: highlightNext without currentPixel falls back to highlightCenter (lines 249-251)
+      const feat1 = { layer: { id: 's2' }, properties: { name: 'City1' }, geometry: { type: 'Point', coordinates: [1, 2] } }
+      map.queryRenderedFeatures.mockReturnValue([feat1])
+      expect(nav.highlightNextLabel('ArrowRight')).toContain('City1')
+
+      // Single label at currentPixel → navigateToNextLabel → null (lines 253-255)
+      expect(nav.highlightNextLabel('ArrowRight')).toBeNull()
+
+      // Zoom handler: active highlight → updates text-size
+      map.setLayoutProperty.mockClear()
+      zoomHandler()
+      expect(map.setLayoutProperty).toHaveBeenCalledWith('highlight-s2', 'text-size', expect.any(Number))
+
+      // Two feats: navigation path sets currentPixel + applies highlight (lines 256-258)
+      const feat2 = { layer: { id: 's2' }, properties: { name: 'City2' }, geometry: { type: 'Point', coordinates: [3, 4] } }
+      map.queryRenderedFeatures.mockReturnValue([feat1, feat2])
+      spatialNavigate.mockReturnValue(0)
+      expect(nav.highlightNextLabel('ArrowRight')).toContain('City2')
+
+      // clearHighlightedLabel removes layer
+      map.getLayer.mockReturnValue(true)
+      nav.clearHighlightedLabel()
+      expect(map.removeLayer).toHaveBeenCalledWith('highlight-s2')
+    })
+
+    test('initLabelSource skips addSource when source exists; MAP_SET_STYLE triggers re-init', () => {
+      map.getSource.mockReset().mockReturnValue({ setData: jest.fn() })  // source always exists
+      const eventBus = { on: jest.fn() }
+      createMapLabelNavigator(map, 'light', { MAP_SET_STYLE: 'set-style' }, eventBus)
+      expect(map.addSource).not.toHaveBeenCalled()
+
+      // Fire MAP_SET_STYLE → styledata → idle → setLineCenterPlacement + initLabelSource
+      const styleHandler = eventBus.on.mock.calls[0][1]
+      styleHandler({ mapColorScheme: 'dark' })
+      const styleDataHandler = map.once.mock.calls.find(([e]) => e === 'styledata')[1]
+      styleDataHandler()
+      map.setLayoutProperty.mockClear()
+      const idleHandler = map.once.mock.calls.find(([e]) => e === 'idle')[1]
+      idleHandler()
+      expect(map.setLayoutProperty).toHaveBeenCalledWith('s1', 'symbol-placement', 'line-center')
+    })
+  })
+})

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

@@ -0,0 +1,66 @@
+import { cleanCanvas, applyPreventDefaultFix } from './maplibreFixes.js'
+
+describe('cleanCanvas', () => {
+  it('removes and sets correct attributes on the canvas', () => {
+    const canvas = document.createElement('canvas')
+    canvas.setAttribute('role', 'presentation')
+    canvas.setAttribute('aria-label', 'map')
+    canvas.style.display = 'none'
+
+    const map = { getCanvas: () => canvas }
+
+    cleanCanvas(map)
+
+    expect(canvas.hasAttribute('role')).toBe(false)
+    expect(canvas.getAttribute('tabindex')).toBe('-1')
+    expect(canvas.hasAttribute('aria-label')).toBe(false)
+    expect(canvas.style.display).toBe('block')
+  })
+})
+
+describe('applyPreventDefaultFix', () => {
+  let map, canvas, spy
+
+  beforeEach(() => {
+    canvas = document.createElement('div')
+    map = { getCanvas: () => canvas }
+    spy = jest.spyOn(Event.prototype, 'preventDefault')
+  })
+
+  afterEach(() => {
+    spy.mockRestore()
+  })
+
+  it('skips preventDefault for non-cancelable touch events on the map', () => {
+    applyPreventDefaultFix(map)
+    const e = new Event('touchmove', { cancelable: false })
+    Object.defineProperty(e, 'target', { value: canvas })
+    e.preventDefault()
+    expect(spy).not.toHaveBeenCalled()
+  })
+
+  it('calls original preventDefault for events outside the map', () => {
+    applyPreventDefaultFix(map)
+    const e = new Event('touchstart', { cancelable: false })
+    const outside = document.createElement('div')
+    Object.defineProperty(e, 'target', { value: outside })
+    e.preventDefault()
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it('calls original preventDefault for cancelable touch events on the map', () => {
+    applyPreventDefaultFix(map)
+    const e = new Event('touchmove', { cancelable: true }) // cancelable true
+    Object.defineProperty(e, 'target', { value: canvas })
+    e.preventDefault()
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it('calls original preventDefault for non-touch events', () => {
+    applyPreventDefaultFix(map)
+    const e = new Event('mousedown', { cancelable: false }) // not touch
+    Object.defineProperty(e, 'target', { value: canvas })
+    e.preventDefault()
+    expect(spy).toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,60 @@
+import { queryFeatures } from './queryFeatures.js'
+
+const mockMap = {
+  project: (l) => ({ x: l[0], y: l[1] }),
+  unproject: (p) => ({ lng: p.x, lat: p.y }),
+  queryRenderedFeatures: () => []
+}
+
+describe('queryFeatures coverage', () => {
+  test('all branches and sorting', () => {
+    // 1. Test empty case
+    expect(queryFeatures(mockMap, { x: 0, y: 0 })).toEqual([])
+
+    // 2. Data-driven loop for all geometry types and distance edge cases
+    const cases = [
+      { type: 'Point', coords: [0, 0], p: { x: 3, y: 4 } },
+      { type: 'LineString', coords: [[0, 0], [10, 0]], p: { x: 5, y: 5 } }, // t=0.5
+      { type: 'LineString', coords: [[0, 0], [0, 0]], p: { x: 1, y: 1 } },   // l2=0
+      { type: 'LineString', coords: [[0, 0], [10, 0]], p: { x: -5, y: 0 } }, // t<0
+      { type: 'MultiPoint', coords: [[0, 0], [10, 10]], p: { x: 1, y: 0 } },
+      { type: 'MultiLineString', coords: [[[0, 0], [10, 0]]], p: { x: 5, y: 1 } },
+      { type: 'Polygon', coords: [[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]], p: { x: 5, y: 5 } }, // Inside
+      { type: 'MultiPolygon', coords: [[[[0, 0], [10, 0], [10, 10], [0, 0]]]], p: { x: 20, y: 20 } },  // Outside
+      { type: 'Unknown', coords: [], p: { x: 0, y: 0 } }
+    ]
+
+    cases.forEach(({ type, coords, p }) => {
+      const feat = { id: type, layer: { id: 'L1' }, geometry: { type, coordinates: coords } }
+      const map = { ...mockMap, queryRenderedFeatures: () => [feat, feat] } // Hits deduplication
+      expect(queryFeatures(map, p).length).toBe(1)
+    })
+
+    // 3. Hits Line 144 (.sort) and property-based ID fallback
+    const f1 = { 
+      properties: { key: 'a' }, 
+      layer: { id: 'layer-A' }, 
+      geometry: { type: 'Point', coordinates: [10, 10] } 
+    }
+    const f2 = { 
+      id: 'b', 
+      layer: { id: 'layer-B' }, 
+      geometry: { type: 'Point', coordinates: [0, 0] } 
+    }
+    
+    // map.queryRenderedFeatures returns multiple items to trigger .sort()
+    const sortMap = { ...mockMap, queryRenderedFeatures: () => [f1, f2] }
+    const result = queryFeatures(sortMap, { x: 0, y: 0 })
+    
+    expect(result.length).toBe(2)
+    expect(result[0].layer.id).toBe('layer-A') // Sorted by layerStack index
+
+    // 4. Hit ray-casting intersect logic (Line 42 branch)
+    const polyFeat = {
+      layer: { id: 'L' },
+      geometry: { type: 'Polygon', coordinates: [[[0, 0], [10, 10], [0, 10], [0, 0]]] }
+    }
+    const rayMap = { ...mockMap, queryRenderedFeatures: () => [polyFeat] }
+    expect(queryFeatures(rayMap, { x: -1, y: 5 }).length).toBe(1)
+  })
+})

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

@@ -28,7 +28,8 @@ const formatDimension = (meters) => {
 
   const miles = meters / METERS_PER_MILE
 
-  if (miles < MILE_THRESHOLD / METERS_PER_MILE) {
+  // Check if we are under the half-mile threshold
+  if (miles < MILE_THRESHOLD) {
     return `${Math.round(meters)}m`
   }
 
@@ -39,8 +40,7 @@ const formatDimension = (meters) => {
   }
 
   const rounded = Math.round(miles)
-  const unit = rounded === 1 ? 'mile' : 'miles'
-  return `${rounded} ${unit}`
+  return `${rounded} miles`
 }
 
 // -----------------------------------------------------------------------------
@@ -191,5 +191,6 @@ export {
   getCardinalMove,
   spatialNavigate,
   getResolution,
-  getPaddedBounds
+  getPaddedBounds,
+  formatDimension
 }

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

@@ -0,0 +1,96 @@
+// tests/utils/spatial.test.js
+import * as spatial from '../../src/utils/spatial.js'
+
+jest.mock('geodesy/latlon-spherical.js', () =>
+  jest.fn().mockImplementation((lat, lng) => ({
+    distanceTo: jest.fn((other) => Math.abs(lat - (other.lat || 0)) * 1609 + Math.abs(lng - (other.lon || 0)) * 1609)
+  }))
+)
+
+describe('spatial utils', () => {
+
+  test('formatDimension hits all branches', () => {
+    // < 0.5 miles
+    expect(spatial.formatDimension(500)).toMatch(/m$/)
+
+    // Singular mile (exactly 1.0) - hits value === 1 branch
+    expect(spatial.formatDimension(1609.344)).toBe('1 mile')
+
+    // 5 miles
+    const metersSmallMiles = 5 * 1609.344
+    expect(spatial.formatDimension(metersSmallMiles)).toMatch(/^5\s*miles$/)
+
+    // >= WHOLE_MILE_THRESHOLD
+    const metersLarge = 15 * 1609.344
+    expect(spatial.formatDimension(metersLarge)).toBe('15 miles')
+  })
+
+  test('array bounds triggers all branches', () => {
+    const dims = spatial.getAreaDimensions([[0, 0], [0.01, 0.02]])
+    expect(dims).toMatch(/by/)
+  })
+
+  test('LngLatBounds object triggers getWest/getSouth branch', () => {
+    const fakeBounds = { getWest: () => 0, getSouth: () => 0, getEast: () => 0.01, getNorth: () => 0.02 }
+    expect(spatial.getAreaDimensions(fakeBounds)).toMatch(/by/)
+  })
+
+  test('invalid bounds returns empty string', () => {
+    expect(spatial.getAreaDimensions(null)).toBe('')
+    expect(spatial.getAreaDimensions([])).toBe('')
+  })
+
+  test('north/south/east/west moves', () => {
+    expect(spatial.getCardinalMove([0,0],[0,0.5])).toMatch(/north/)
+    expect(spatial.getCardinalMove([0,0],[0,-0.5])).toMatch(/south/)
+    expect(spatial.getCardinalMove([0,0],[0.5,0])).toMatch(/east/)
+    expect(spatial.getCardinalMove([0,0],[-0.5,0])).toMatch(/west/)
+    expect(spatial.getCardinalMove([0,0],[0.5,0.5])).toMatch(/north.*east|east.*north/)
+    expect(spatial.getCardinalMove([0,0],[0.00001,0.00001])).toBe('')
+  })
+
+  test('spatialNavigate all directions and fallback', () => {
+    const pixels = [[0,0],[0,-1],[1,0],[0,1],[-1,0]]
+    expect(spatial.spatialNavigate('ArrowUp',[0,0],pixels)).toBe(1)
+    expect(spatial.spatialNavigate('ArrowDown',[0,0],pixels)).toBe(3)
+    expect(spatial.spatialNavigate('ArrowLeft',[0,0],pixels)).toBe(4)
+    expect(spatial.spatialNavigate('ArrowRight',[0,0],pixels)).toBe(2)
+    expect(spatial.spatialNavigate('InvalidDir',[0,0],pixels)).toBe(0)
+  })
+
+  test('spatialNavigate finds closer candidates (hits dist < minDist)', () => {
+    const start = [0,0]
+    const pixels = [[0,0],[10,0],[2,0]] 
+    expect(spatial.spatialNavigate('ArrowRight', start, pixels)).toBe(2)
+  })
+
+  test('spatialNavigate skips farther candidate (dist >= minDist false branch)', () => {
+    // Closer candidate first → second candidate fails dist < minDist
+    const pixels = [[0,0],[2,0],[10,0]]
+    expect(spatial.spatialNavigate('ArrowRight', [0,0], pixels)).toBe(1)
+  })
+
+  test('spatialNavigate diagonal with dx>dy', () => {
+    const start = [0,0]
+    const pixels = [[0,0],[3,1],[1,0]] // dx>dy
+    expect(spatial.spatialNavigate('ArrowRight', start, pixels)).toBe(2)
+  })
+
+  test('getResolution returns positive value', () => {
+    expect(spatial.getResolution({lat:0},1)).toBeGreaterThan(0)
+  })
+
+  test('getPaddedBounds returns bounds', () => {
+    const map = {
+      getContainer: () => ({ getBoundingClientRect: () => ({ width:100,height:200 }) }),
+      getPadding: () => ({ top:1,right:2,bottom:3,left:4 }),
+      unproject: p => ({ x:p[0], y:p[1] })
+    }
+    const LngLatBounds = function(sw,ne){
+      return {sw,ne}
+    }
+    const bounds = spatial.getPaddedBounds(LngLatBounds,map)
+    expect(bounds.sw).toBeDefined()
+    expect(bounds.ne).toBeDefined()
+  })
+})