@defra/interactive-map 0.0.40-alpha → 0.0.42-alpha

package/plugins/datasets/src/adapters/esri/esriLayerAdapter.test.js

@@ -29,6 +29,12 @@ jest.mock('@arcgis/core/layers/GroupLayer.js', () =>
     }
   })
 )
+jest.mock('@arcgis/core/layers/FeatureLayer.js', () =>
+  jest.fn().mockImplementation((opts = {}) => ({
+    ...opts,
+    when: jest.fn().mockResolvedValue(undefined)
+  }))
+)
 
 // Uncovered: 124,145-149
 
@@ -290,4 +296,173 @@ describe('esriLayerAdapter', () => {
       expect(applyStyleLayerVisibilitySpy.mock.calls).toHaveLength(7)
     })
   })
+
+  // ─── _reorderLayers with sketch layers ───────────────────────────────────────
+
+  describe('_reorderLayers', () => {
+    it('reorders sketch layers to the top when allLayers is present', () => {
+      const sketchLayer = { id: 'ketchLayer-0' }
+      const normalLayer = { id: 'roads' }
+      map.allLayers = { items: [normalLayer, sketchLayer] }
+      map.reorder = jest.fn()
+
+      adapter._reorderLayers()
+
+      expect(map.reorder).toHaveBeenCalledWith(sketchLayer, 2)
+      expect(map.reorder).not.toHaveBeenCalledWith(normalLayer, expect.anything())
+    })
+  })
+
+  // ─── _addFeatureLayers ────────────────────────────────────────────────────────
+
+  describe('_addFeatureLayers', () => {
+    beforeEach(() => {
+      datasetRegistry.mockExtend({
+        'feature-service': {
+          id: 'feature-service',
+          type: 'FeatureService',
+          tiles: 'https://example.com/featureserver/0',
+          visible: true,
+          style: {}
+        }
+      })
+    })
+
+    it('adds a FeatureLayer to the map and populates internal state', async () => {
+      const dataset = datasetRegistry.getDataset('feature-service')
+      await adapter._addFeatureLayers(dataset)
+      expect(adapter._mapVisibilityLayers['feature-service']).toBeDefined()
+      expect(adapter._mapOpacityLayers['feature-service']).toBeDefined()
+      expect(map.add).toHaveBeenCalled()
+    })
+
+    it('logs an error and returns null when map.add throws', async () => {
+      const { logger } = require('../../../../../src/services/logger.js')
+      const error = new Error('map add failed')
+      map.add = jest.fn().mockImplementation(() => { throw error })
+
+      const dataset = datasetRegistry.getDataset('feature-service')
+      const result = await adapter._addFeatureLayers(dataset)
+
+      expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('feature-service'), error)
+      expect(result).toBeNull()
+    })
+  })
+
+  // ─── _addLayers for FeatureService ───────────────────────────────────────────
+
+  describe('_addLayers for FeatureService type', () => {
+    it('delegates to _addFeatureLayers when dataset type is FeatureService', async () => {
+      datasetRegistry.mockExtend({
+        'fs-dataset': {
+          id: 'fs-dataset',
+          type: 'FeatureService',
+          tiles: 'https://example.com/fs/0',
+          visible: true,
+          style: {}
+        }
+      })
+      const addFeatureLayersSpy = jest.spyOn(adapter, '_addFeatureLayers')
+      const dataset = datasetRegistry.getDataset('fs-dataset')
+      await adapter._addLayers(dataset)
+      expect(addFeatureLayersSpy).toHaveBeenCalledWith(dataset)
+    })
+  })
+
+  // ─── _applyRegistryDatasetVisibility – visible=false branch ──────────────────
+
+  describe('_applyRegistryDatasetVisibility visible=false', () => {
+    it('sets vectorTileLayer.visible to false and skips sublayer style update', async () => {
+      const dataset = datasetRegistry.getDataset('esri-grouped')
+      await adapter._addLayers(dataset)
+      await adapter._applyRegistryDatasetVisibility(dataset)
+      expect(adapter._mapVisibilityLayers['esri-grouped'].visible).toBe(false)
+    })
+
+    it('returns early when the vector tile layer is not yet in the adapter', () => {
+      const dataset = datasetRegistry.getDataset('esri-standalone')
+      // No layers added — _mapVisibilityLayers is empty
+      expect(() => adapter._applyRegistryDatasetVisibility(dataset)).not.toThrow()
+    })
+  })
+
+  // ─── _addLayers – no tiles ────────────────────────────────────────────────────
+
+  describe('_addLayers with no tiles', () => {
+    it('returns null when the dataset has no tiles', async () => {
+      datasetRegistry.mockExtend({
+        'no-tiles': { id: 'no-tiles', visible: true, style: {} }
+      })
+      const result = await adapter._addLayers(datasetRegistry.getDataset('no-tiles'))
+      expect(result).toBeNull()
+    })
+  })
+
+  // ─── stub methods ─────────────────────────────────────────────────────────────
+
+  describe('stub adapter methods', () => {
+    it('applyFeatureFilter logs and resolves', async () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      await adapter.applyFeatureFilter('roads')
+      expect(consoleSpy).toHaveBeenCalledWith('TODO: applyFeatureFilter', ['roads'])
+      consoleSpy.mockRestore()
+    })
+
+    it('setData logs and resolves', async () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      await adapter.setData('roads', {})
+      expect(consoleSpy).toHaveBeenCalledWith('TODO: setData', ['roads', {}])
+      consoleSpy.mockRestore()
+    })
+
+    it('applyStyle logs and resolves', async () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      await adapter.applyStyle('roads', {})
+      expect(consoleSpy).toHaveBeenCalledWith('TODO: applyStyle', ['roads', {}])
+      consoleSpy.mockRestore()
+    })
+  })
+
+  // ─── _applyStyleLayerPaintProperties – null paint properties ─────────────────
+
+  describe('_applyStyleLayerPaintProperties', () => {
+    it('does nothing when getPaintProperties returns null', async () => {
+      await adapter._addLayers(datasetRegistry.getDataset('esri-standalone'))
+      const vtl = adapter._mapVisibilityLayers['esri-standalone']
+      vtl.getPaintProperties = jest.fn().mockReturnValue(null)
+
+      adapter._applyStyleLayerPaintProperties(datasetRegistry.getDataset('esri-standalone'), vtl)
+
+      expect(vtl.setPaintProperties).not.toHaveBeenCalled()
+    })
+  })
+
+  // ─── onMapStyleChange for FeatureService ─────────────────────────────────────
+
+  describe('onMapStyleChange for FeatureService', () => {
+    it('sets renderer on FeatureLayer instead of applying style layer visibility', async () => {
+      datasetRegistry.mockExtend({
+        'fs-style': {
+          id: 'fs-style',
+          type: 'FeatureService',
+          tiles: 'https://example.com/fs/0',
+          visible: true,
+          style: {}
+        }
+      })
+      await adapter._addLayers(datasetRegistry.getDataset('fs-style'))
+      const featureLayer = adapter._mapVisibilityLayers['fs-style']
+      const setStyleLayerVisibilitySpy = jest.spyOn(adapter, '_applyStyleLayerVisibility')
+
+      await adapter.onMapStyleChange()
+
+      // The renderer property should be set (even if undefined for no-renderer datasets)
+      expect(Object.prototype.hasOwnProperty.call(featureLayer, 'renderer')).toBe(true)
+      // _applyStyleLayerVisibility should not be called for the FeatureService dataset
+      const fsCall = setStyleLayerVisibilitySpy.mock.calls.find(
+        ([ds]) => ds?.id === 'fs-style'
+      )
+      expect(fsCall).toBeUndefined()
+    })
+  })
 })

package/plugins/datasets/src/adapters/esri/registry/esriDataset.test.js

@@ -70,4 +70,59 @@ describe('EsriDataset', () => {
       expect(datasetRegistry.getDataset('land-covers-other').useServerStyle).toBe(false)
     })
   })
+
+  // ─── renderer ───────────────────────────────────────────────────────────────
+
+  describe('renderer', () => {
+    beforeEach(() => {
+      datasetRegistry.mockExtend({
+        'fs-no-renderer': { id: 'fs-no-renderer', type: 'FeatureService' },
+        'fs-with-renderer': {
+          id: 'fs-with-renderer',
+          type: 'FeatureService',
+          style: { renderer: { type: 'simple', symbol: { type: 'simple-fill' } } }
+        },
+        'fs-with-color': {
+          id: 'fs-with-color',
+          type: 'FeatureService',
+          style: {
+            renderer: {
+              type: 'simple',
+              symbol: {
+                color: { outdoor: '#ff0000', dark: '#ffffff' },
+                outline: { color: { outdoor: '#000000', dark: '#888888' } }
+              }
+            }
+          }
+        },
+        'non-feature-service': { id: 'non-feature-service', type: 'VectorTileService' }
+      })
+    })
+
+    it('returns undefined for non-FeatureService datasets', () => {
+      expect(datasetRegistry.getDataset('non-feature-service').renderer).toBeUndefined()
+    })
+
+    it('returns undefined for FeatureService dataset with no renderer definition', () => {
+      expect(datasetRegistry.getDataset('fs-no-renderer').renderer).toBeUndefined()
+    })
+
+    it('returns cloned renderer object for dataset with renderer', () => {
+      const ds = datasetRegistry.getDataset('fs-with-renderer')
+      const renderer = ds.renderer
+      expect(renderer).toEqual({ type: 'simple', symbol: { type: 'simple-fill' } })
+    })
+
+    it('resolves symbol.color via getValueForStyle', () => {
+      const ds = datasetRegistry.getDataset('fs-with-color')
+      const renderer = ds.renderer
+      expect(renderer.symbol.color).toBe('#ff0000')
+    })
+
+    it('resolves symbol.outline.color via getValueForStyle', () => {
+      const ds = datasetRegistry.getDataset('fs-with-color')
+      const renderer = ds.renderer
+      expect(renderer.symbol.outline.color).toBe('#000000')
+    })
+  })
 })

package/plugins/datasets/src/adapters/loadLayerAdapter.test.js

@@ -0,0 +1,61 @@
+import { loadLayerAdapter, layerAdapter } from './loadLayerAdapter.js'
+
+const makeAdapterInstance = (type) => ({
+  type,
+  removeDataset: jest.fn(),
+  setData: jest.fn(),
+  applyStyle: jest.fn(),
+  applyDatasetVisibility: jest.fn(),
+  applyGlobalVisibility: jest.fn(),
+  applyDatasetOpacity: jest.fn(),
+  applyGlobalOpacity: jest.fn(),
+  addDataset: jest.fn(),
+  applyFeatureFilter: jest.fn(),
+  onMapStyleChange: jest.fn(),
+  onMapSizeChange: jest.fn()
+})
+
+jest.mock('./maplibre/maplibreLayerAdapter.js', () => ({
+  __esModule: true,
+  default: jest.fn().mockImplementation(() => makeAdapterInstance('maplibre'))
+}))
+jest.mock('./esri/esriLayerAdapter.js', () => ({
+  __esModule: true,
+  default: jest.fn().mockImplementation(() => makeAdapterInstance('esri'))
+}))
+
+const makeMapProvider = (name) => ({ name })
+const symbolRegistry = {}
+const patternRegistry = {}
+
+describe('loadLayerAdapter', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('loads the MapLibre adapter for MapLibreProvider', async () => {
+    const mapProvider = makeMapProvider('MapLibreProvider')
+    const adapter = await loadLayerAdapter(mapProvider, symbolRegistry, patternRegistry)
+    expect(adapter.type).toBe('maplibre')
+  })
+
+  it('loads the Esri adapter for EsriProvider', async () => {
+    const mapProvider = makeMapProvider('EsriProvider')
+    const adapter = await loadLayerAdapter(mapProvider, symbolRegistry, patternRegistry)
+    expect(adapter.type).toBe('esri')
+  })
+
+  it('throws for an unknown provider', async () => {
+    const mapProvider = makeMapProvider('UnknownProvider')
+    await expect(loadLayerAdapter(mapProvider, symbolRegistry, patternRegistry))
+      .rejects.toThrow('No layer adapter available for map provider UnknownProvider')
+  })
+
+  it('assigns adapter methods to the layerAdapter proxy object', async () => {
+    const mapProvider = makeMapProvider('MapLibreProvider')
+    await loadLayerAdapter(mapProvider, symbolRegistry, patternRegistry)
+    expect(typeof layerAdapter.addDataset).toBe('function')
+    expect(typeof layerAdapter.removeDataset).toBe('function')
+    expect(typeof layerAdapter.setData).toBe('function')
+  })
+})

package/plugins/datasets/src/adapters/maplibre/maplibreLayerAdapter.test.js

@@ -556,3 +556,17 @@ describe('onMapSizeChange', () => {
     expect(symbolUpdates).toHaveLength(0)
   })
 })
+
+// ─── onMapStyleChange – dynamic source reapply ────────────────────────────────
+
+describe('onMapStyleChange with dynamic sources', () => {
+  beforeEach(async () => { await adapter.init() })
+
+  it('calls reapply() on each attached dynamic source after style change', async () => {
+    const source = { reapply: jest.fn() }
+    const sources = new Map([['parcels', source]])
+    adapter.attachDynamicSources(sources)
+    await adapter.onMapStyleChange(MAP_STYLE, new Map())
+    expect(source.reapply).toHaveBeenCalled()
+  })
+})

package/plugins/datasets/src/api/setOpacity.test.js

@@ -28,4 +28,13 @@ describe('setOpacity', () => {
       payload: { opacity: 0.8 }
     })
   })
+
+  it('dispatches SET_GLOBAL_OPACITY when options argument is omitted', () => {
+    setOpacity({ pluginState: { dispatch } }, 0.5)
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'SET_GLOBAL_OPACITY',
+      payload: { opacity: 0.5 }
+    })
+  })
 })

package/plugins/datasets/src/components/LayersMenu/LayersMenu.jsx

@@ -1,7 +1,6 @@
 import React from 'react'
 import { setDatasetVisibility } from '../../api/setDatasetVisibility.js'
 import { LayersMenuCheckbox } from './LayersMenuCheckbox.jsx'
-import { LayersRadioGroupWrapper } from './LayersRadioGroupWrapper.jsx'
 import { LayersMenuGroupWrapper } from './LayersMenuGroupWrapper.jsx'
 
 export const LayersMenu = ({ pluginState }) => {
@@ -17,32 +16,18 @@ export const LayersMenu = ({ pluginState }) => {
   return (
     <div className={containerClass}>
       {// Each menuGroup
-        menu.map(menuGroup => {
-          const { type } = menuGroup
-          if (type === 'checkbox') {
-            return (
-              <LayersMenuGroupWrapper key={menuGroup.id} menuGroup={menuGroup}> {
-                // Each menuGroupItem
-                menuGroup.items.map(menuGroupItem => (
-                  <LayersMenuCheckbox
-                    key={menuGroupItem.id}
-                    menuGroupItem={menuGroupItem}
-                    onChange={handleDatasetChange}
-                  />)
-                )
-              }
-              </LayersMenuGroupWrapper>
-            )
-          } else {
-            return (
-              <LayersRadioGroupWrapper
-                key={menuGroup.id}
-                menuGroup={menuGroup}
-                pluginState={pluginState}
-              />
+        menu.map(menuGroup => (
+          <LayersMenuGroupWrapper key={menuGroup.id} menuGroup={menuGroup}> {
+            // Each menuGroupItem
+            menuGroup.items.map(menuGroupItem => (
+              <LayersMenuCheckbox
+                key={menuGroupItem.id}
+                menuGroupItem={menuGroupItem}
+                onChange={handleDatasetChange}
+              />)
             )
           }
-        }
+          </LayersMenuGroupWrapper>)
         )
       }
     </div>

package/plugins/datasets/src/components/LayersMenu/LayersMenu.test.jsx

@@ -20,12 +20,6 @@ jest.mock('./LayersMenuCheckbox.jsx', () => ({
   }
 }))
 
-jest.mock('./LayersRadioGroupWrapper.jsx', () => ({
-  LayersRadioGroupWrapper: ({ menuGroup }) => (
-    <div data-testid='layers-radio-group-wrapper' data-group-id={menuGroup.id} />
-  )
-}))
-
 jest.mock('./LayersMenuGroupWrapper.jsx', () => ({
   LayersMenuGroupWrapper: ({ menuGroup, children }) => (
     <div data-testid='layers-menu-group-wrapper' data-group-id={menuGroup.id}>
@@ -108,42 +102,6 @@ describe('LayersMenu', () => {
     })
   })
 
-  describe('radio groups', () => {
-    it('renders a LayersRadioGroupWrapper for non-checkbox groups', () => {
-      const pluginState = makePluginState([
-        { id: 'r1', type: 'radio', items: [{ id: 'opt1' }, { id: 'opt2' }] }
-      ])
-      const { getAllByTestId } = render(<LayersMenu pluginState={pluginState} />)
-      expect(getAllByTestId('layers-radio-group-wrapper')).toHaveLength(1)
-    })
-
-    it('passes the correct group to LayersRadioGroupWrapper', () => {
-      const pluginState = makePluginState([
-        { id: 'radio-group-1', type: 'radio', items: [] }
-      ])
-      const { getByTestId } = render(<LayersMenu pluginState={pluginState} />)
-      expect(getByTestId('layers-radio-group-wrapper').dataset.groupId).toBe('radio-group-1')
-    })
-
-    it('does not render a LayersMenuGroupWrapper for radio groups', () => {
-      const pluginState = makePluginState([{ id: 'r1', type: 'radio', items: [] }])
-      const { queryByTestId } = render(<LayersMenu pluginState={pluginState} />)
-      expect(queryByTestId('layers-menu-group-wrapper')).toBeNull()
-    })
-  })
-
-  describe('mixed groups', () => {
-    it('renders both checkbox and radio wrappers when both types are present', () => {
-      const pluginState = makePluginState([
-        { id: 'c1', type: 'checkbox', items: [] },
-        { id: 'r1', type: 'radio', items: [] }
-      ])
-      const { getByTestId } = render(<LayersMenu pluginState={pluginState} />)
-      expect(getByTestId('layers-menu-group-wrapper')).toBeTruthy()
-      expect(getByTestId('layers-radio-group-wrapper')).toBeTruthy()
-    })
-  })
-
   describe('handleDatasetChange', () => {
     it('calls setDatasetVisibility with the correct arguments when a checkbox changes', () => {
       const pluginState = makePluginState([

package/plugins/datasets/src/datasets.scss

@@ -1,5 +1,4 @@
 // Components: specific UI components. Using 'CSS in Component' pattern
-@use './components/Key/Key.module';
 @use './components/LayersMenu/Layers.module';
 
 .im-c-datasets {