@defra/interactive-map 0.0.39-alpha → 0.0.41-alpha

package/plugins/datasets/src/fetch/fetchGeoJSON.test.js

@@ -0,0 +1,83 @@
+import { fetchGeoJSON } from './fetchGeoJSON.js'
+
+const baseUrl = 'https://api.example.com/features'
+const context = { bbox: [-1, -1, 1, 1], zoom: 10 }
+const signal = { aborted: false }
+
+const mockResponse = ({ ok = true, status = 200, statusText = 'OK', body = {} } = {}) => ({
+  ok,
+  status,
+  statusText,
+  json: async () => body
+})
+
+beforeEach(() => {
+  global.fetch = jest.fn()
+})
+
+describe('fetchGeoJSON', () => {
+  it('calls transformRequest with the base URL and context, then fetches the returned url/headers', async () => {
+    const featureCollection = { type: 'FeatureCollection', features: [] }
+    global.fetch.mockResolvedValueOnce(mockResponse({ body: featureCollection }))
+    const transformRequest = jest.fn(() => ({ url: `${baseUrl}?bbox=${context.bbox.join(',')}`, headers: { Authorization: 'Bearer token' } }))
+
+    const result = await fetchGeoJSON(baseUrl, context, transformRequest, signal)
+
+    expect(transformRequest).toHaveBeenCalledWith(baseUrl, context)
+    expect(fetch).toHaveBeenCalledWith(
+      `${baseUrl}?bbox=-1,-1,1,1`,
+      { headers: { Authorization: 'Bearer token' }, signal }
+    )
+    expect(result).toBe(featureCollection)
+  })
+
+  it('supports transformRequest returning a plain URL string, defaulting headers to {}', async () => {
+    global.fetch.mockResolvedValueOnce(mockResponse({ body: { type: 'FeatureCollection', features: [] } }))
+    const transformRequest = () => baseUrl
+
+    await fetchGeoJSON(baseUrl, context, transformRequest, signal)
+
+    expect(fetch).toHaveBeenCalledWith(baseUrl, { headers: {}, signal })
+  })
+
+  it('defaults headers to {} when transformRequest returns an object without headers', async () => {
+    global.fetch.mockResolvedValueOnce(mockResponse({ body: { type: 'FeatureCollection', features: [] } }))
+    const transformRequest = () => ({ url: baseUrl })
+
+    await fetchGeoJSON(baseUrl, context, transformRequest, signal)
+
+    expect(fetch).toHaveBeenCalledWith(baseUrl, { headers: {}, signal })
+  })
+
+  it('throws when the response is not ok', async () => {
+    global.fetch.mockResolvedValueOnce(mockResponse({ ok: false, status: 500, statusText: 'Server Error' }))
+
+    await expect(fetchGeoJSON(baseUrl, context, () => baseUrl, signal))
+      .rejects.toThrow('Failed to fetch GeoJSON: 500 Server Error')
+  })
+
+  it('wraps a single Feature into a FeatureCollection', async () => {
+    const feature = { type: 'Feature', geometry: { type: 'Point', coordinates: [0, 0] } }
+    global.fetch.mockResolvedValueOnce(mockResponse({ body: feature }))
+
+    const result = await fetchGeoJSON(baseUrl, context, () => baseUrl, signal)
+
+    expect(result).toEqual({ type: 'FeatureCollection', features: [feature] })
+  })
+
+  it('wraps a bare array of features into a FeatureCollection', async () => {
+    const features = [{ type: 'Feature', geometry: { type: 'Point', coordinates: [0, 0] } }]
+    global.fetch.mockResolvedValueOnce(mockResponse({ body: features }))
+
+    const result = await fetchGeoJSON(baseUrl, context, () => baseUrl, signal)
+
+    expect(result).toEqual({ type: 'FeatureCollection', features })
+  })
+
+  it('throws for an unrecognized response shape', async () => {
+    global.fetch.mockResolvedValueOnce(mockResponse({ body: { type: 'NotGeoJSON' } }))
+
+    await expect(fetchGeoJSON(baseUrl, context, () => baseUrl, signal))
+      .rejects.toThrow('Invalid GeoJSON response')
+  })
+})

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

@@ -0,0 +1,36 @@
+import createPlugin from './index.js'
+
+jest.mock('./datasets.scss', () => {})
+jest.mock('./manifest.js', () => ({
+  manifest: { InitComponent: jest.fn(), reducer: {} }
+}))
+
+describe('createPlugin', () => {
+  it('returns a plugin with id "datasets"', () => {
+    const plugin = createPlugin()
+    expect(plugin.id).toBe('datasets')
+  })
+
+  it('applies default noKeyItemText', () => {
+    const plugin = createPlugin()
+    expect(plugin.noKeyItemText).toBe('No features displayed')
+  })
+
+  it('merges provided options (options override defaults, id stays fixed)', () => {
+    const plugin = createPlugin({ noKeyItemText: 'Custom text', extra: true })
+    expect(plugin.noKeyItemText).toBe('Custom text')
+    expect(plugin.extra).toBe(true)
+    expect(plugin.id).toBe('datasets')
+  })
+
+  it('exposes a load function', () => {
+    const plugin = createPlugin()
+    expect(typeof plugin.load).toBe('function')
+  })
+
+  it('load() resolves to the manifest', async () => {
+    const plugin = createPlugin()
+    const result = await plugin.load()
+    expect(result).toBeDefined()
+  })
+})

package/plugins/datasets/src/initialise/DatasetsInit.jsx

@@ -3,15 +3,27 @@ import { useEffect, useRef } from 'react'
 import { EVENTS } from '../../../../src/config/events.js'
 import { initialiseDatasets } from './initialiseDatasets.js'
 import { datasetRegistry } from '../registry/datasetRegistry.js'
-import { setMenuState } from '../registry/isVisibleWhen.js'
 import { attachGlobalState } from '../registry/globalDataset.js'
 import { loadLayerAdapter, layerAdapter } from '../adapters/loadLayerAdapter.js'
 
+const pluginConfigHasMenuItems = (pluginConfig) =>
+  pluginConfig.datasets
+    .some(dataset => dataset.showInMenu || dataset.sublayers?.some(sublayer => sublayer.showInMenu))
+
 export function DatasetsInit ({ pluginConfig, pluginState, appState, mapState, mapProvider, services }) {
   const { dispatch } = pluginState
   const { eventBus, symbolRegistry, patternRegistry } = services
   const isBaseMapReady = Boolean(mapProvider?.isBaseMapReady())
 
+  useEffect(() => {
+    const hasMenu = pluginConfig.hasMenu !== false && pluginConfigHasMenuItems(pluginConfig)
+
+    if (!hasMenu) {
+      eventBus.emit(EVENTS.APP_REMOVE_PANEL, 'datasetsLayers')
+      eventBus.emit(EVENTS.APP_TOGGLE_BUTTON_STATE, { id: 'datasetsLayers', prop: 'hidden', value: true })
+    }
+  }, [pluginConfig.hasMenu])
+
   // Keep a ref to the latest pluginState so event handlers can access current data
   const pluginStateRef = useRef(pluginState)
   pluginStateRef.current = pluginState
@@ -51,12 +63,10 @@ export function DatasetsInit ({ pluginConfig, pluginState, appState, mapState, m
   }, [isBaseMapReady, appState.mode])
 
   useEffect(() => {
-    setMenuState(pluginState.menuState)
-    datasetRegistry.invalidateKeyItems()
-  }, [pluginState.menuState])
-
-  useEffect(() => datasetRegistry.attach(pluginState.mappedDatasets, pluginState.orderedDatasets),
-    [pluginState.mappedDatasets, pluginState.orderedDatasets])
+    datasetRegistry.attach(pluginState.mappedDatasets, pluginState.orderedDatasets)
+    eventBus.emit('datasets:changed')
+  },
+  [pluginState.mappedDatasets, pluginState.orderedDatasets])
 
   useEffect(() => {
     datasetRegistry.attachMapStyle(mapState.mapStyle)

package/plugins/datasets/src/initialise/DatasetsInit.test.jsx

@@ -0,0 +1,262 @@
+import { render, act } from '@testing-library/react'
+import { DatasetsInit } from './DatasetsInit.jsx'
+import { datasetRegistry } from '../registry/datasetRegistry.js'
+import { attachGlobalState } from '../registry/globalDataset.js'
+import { loadLayerAdapter, layerAdapter } from '../adapters/loadLayerAdapter.js'
+import { initialiseDatasets } from './initialiseDatasets.js'
+import { EVENTS } from '../../../../src/config/events.js'
+
+jest.mock('../registry/datasetRegistry.js', () => ({
+  datasetRegistry: {
+    attach: jest.fn(),
+    attachMapStyle: jest.fn(),
+    attachCreateDataset: jest.fn()
+  }
+}))
+jest.mock('../registry/globalDataset.js', () => ({
+  attachGlobalState: jest.fn()
+}))
+jest.mock('../adapters/loadLayerAdapter.js', () => ({
+  loadLayerAdapter: jest.fn(),
+  layerAdapter: {}
+}))
+jest.mock('./initialiseDatasets.js')
+
+const makeEventBus = () => ({
+  emit: jest.fn(),
+  on: jest.fn(),
+  off: jest.fn()
+})
+
+const makeAdapter = () => ({
+  init: jest.fn().mockResolvedValue(undefined)
+})
+
+const makePluginState = (overrides = {}) => ({
+  dispatch: jest.fn(),
+  mappedDatasets: {},
+  orderedDatasets: [],
+  globals: { visible: true, opacity: 1 },
+  actionsArray: [],
+  ...overrides
+})
+
+const makeProps = (overrides = {}) => ({
+  pluginConfig: {
+    datasets: [{ id: 'roads', label: 'Roads', showInMenu: true }]
+  },
+  pluginState: makePluginState(),
+  appState: { mode: 'default' },
+  mapState: { mapStyle: { id: 'outdoor' } },
+  mapProvider: { isBaseMapReady: jest.fn().mockReturnValue(true) },
+  services: {
+    eventBus: makeEventBus(),
+    symbolRegistry: {},
+    patternRegistry: {}
+  },
+  ...overrides
+})
+
+describe('DatasetsInit', () => {
+  let adapter
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    adapter = makeAdapter()
+    loadLayerAdapter.mockResolvedValue(adapter)
+    initialiseDatasets.mockReturnValue({ remove: jest.fn() })
+  })
+
+  it('renders null', () => {
+    const { container } = render(<DatasetsInit {...makeProps()} />)
+    expect(container.firstChild).toBeNull()
+  })
+
+  // ─── hasMenu / panel removal ─────────────────────────────────────────────────
+
+  describe('menu panel management', () => {
+    it('removes the datasetsLayers panel when no datasets have showInMenu', async () => {
+      const props = makeProps({
+        pluginConfig: { datasets: [{ id: 'roads', label: 'Roads' }] }
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(props.services.eventBus.emit).toHaveBeenCalledWith(
+        EVENTS.APP_REMOVE_PANEL, 'datasetsLayers'
+      )
+      expect(props.services.eventBus.emit).toHaveBeenCalledWith(
+        EVENTS.APP_TOGGLE_BUTTON_STATE, { id: 'datasetsLayers', prop: 'hidden', value: true }
+      )
+    })
+
+    it('does not remove the panel when at least one dataset has showInMenu', async () => {
+      const props = makeProps()
+      await render(<DatasetsInit {...props} />)
+      expect(props.services.eventBus.emit).not.toHaveBeenCalledWith(
+        EVENTS.APP_REMOVE_PANEL, 'datasetsLayers'
+      )
+    })
+
+    it('removes the panel when hasMenu is explicitly false', async () => {
+      const props = makeProps({
+        pluginConfig: { hasMenu: false, datasets: [{ id: 'roads', label: 'Roads', showInMenu: true }] }
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(props.services.eventBus.emit).toHaveBeenCalledWith(
+        EVENTS.APP_REMOVE_PANEL, 'datasetsLayers'
+      )
+    })
+
+    it('includes datasets with sublayer showInMenu when checking for menu items', async () => {
+      const props = makeProps({
+        pluginConfig: {
+          datasets: [{
+            id: 'parent',
+            label: 'Parent',
+            sublayers: [{ id: 'child', showInMenu: true }]
+          }]
+        }
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(props.services.eventBus.emit).not.toHaveBeenCalledWith(
+        EVENTS.APP_REMOVE_PANEL, 'datasetsLayers'
+      )
+    })
+  })
+
+  // ─── initialisation ──────────────────────────────────────────────────────────
+
+  describe('initialisation', () => {
+    it('calls loadLayerAdapter and initialiseDatasets when base map is ready', async () => {
+      const props = makeProps()
+      await render(<DatasetsInit {...props} />)
+      expect(loadLayerAdapter).toHaveBeenCalledWith(
+        props.mapProvider, props.services.symbolRegistry, props.services.patternRegistry
+      )
+      expect(initialiseDatasets).toHaveBeenCalled()
+    })
+
+    it('does not initialise when base map is not ready', async () => {
+      const props = makeProps({
+        mapProvider: { isBaseMapReady: jest.fn().mockReturnValue(false) }
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(loadLayerAdapter).not.toHaveBeenCalled()
+    })
+
+    it('does not initialise when mode is not in includeModes', async () => {
+      const props = makeProps({
+        pluginConfig: { datasets: [], includeModes: ['edit'] },
+        appState: { mode: 'default' }
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(loadLayerAdapter).not.toHaveBeenCalled()
+    })
+
+    it('does not initialise when mode is in excludeModes', async () => {
+      const props = makeProps({
+        pluginConfig: { datasets: [], excludeModes: ['default'] },
+        appState: { mode: 'default' }
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(loadLayerAdapter).not.toHaveBeenCalled()
+    })
+
+    it('does not initialise twice when re-rendered', async () => {
+      const props = makeProps()
+      const { rerender } = render(<DatasetsInit {...props} />)
+      await act(async () => {})
+      rerender(<DatasetsInit {...props} mapState={{ mapStyle: { id: 'dark' } }} />)
+      await act(async () => {})
+      expect(loadLayerAdapter).toHaveBeenCalledTimes(1)
+    })
+
+    it('skips init when datasetsInstanceRef is already populated (mode change)', async () => {
+      const props = makeProps()
+      const { rerender } = render(<DatasetsInit {...props} />)
+      await act(async () => {})
+      // Change appState.mode — that's in the effect deps, so the effect re-runs
+      await act(async () => {
+        rerender(<DatasetsInit {...props} appState={{ mode: 'edit' }} />)
+      })
+      // loadLayerAdapter should only be called once despite the re-run
+      expect(loadLayerAdapter).toHaveBeenCalledTimes(1)
+    })
+
+    it('calls remove on cleanup when unmounted after init', async () => {
+      const removeFn = jest.fn()
+      initialiseDatasets.mockReturnValue({ remove: removeFn })
+      const props = makeProps()
+      const { unmount } = render(<DatasetsInit {...props} />)
+      await act(async () => {})
+      unmount()
+      expect(removeFn).toHaveBeenCalled()
+    })
+  })
+
+  // ─── registry / map style effects ────────────────────────────────────────────
+
+  describe('datasetRegistry attach effects', () => {
+    it('attaches mappedDatasets and orderedDatasets to the registry', async () => {
+      const mappedDatasets = { roads: { id: 'roads' } }
+      const orderedDatasets = ['roads']
+      const props = makeProps({
+        pluginState: makePluginState({ mappedDatasets, orderedDatasets })
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(datasetRegistry.attach).toHaveBeenCalledWith(mappedDatasets, orderedDatasets)
+    })
+
+    it('attaches the map style to the registry', async () => {
+      const props = makeProps()
+      await render(<DatasetsInit {...props} />)
+      expect(datasetRegistry.attachMapStyle).toHaveBeenCalledWith(props.mapState.mapStyle)
+    })
+
+    it('calls layerAdapter.onMapStyleChange when available', async () => {
+      const onMapStyleChange = jest.fn()
+      Object.assign(layerAdapter, { onMapStyleChange })
+      const props = makeProps()
+      await render(<DatasetsInit {...props} />)
+      expect(onMapStyleChange).toHaveBeenCalled()
+      delete layerAdapter.onMapStyleChange
+    })
+  })
+
+  // ─── globals effect ──────────────────────────────────────────────────────────
+
+  describe('globals effect', () => {
+    it('calls attachGlobalState with the current globals', async () => {
+      const globals = { visible: false, opacity: 0.5 }
+      const props = makeProps({ pluginState: makePluginState({ globals }) })
+      await render(<DatasetsInit {...props} />)
+      expect(attachGlobalState).toHaveBeenCalledWith(globals)
+    })
+  })
+
+  // ─── actionsArray effect ─────────────────────────────────────────────────────
+
+  describe('actionsArray effect', () => {
+    it('calls each queued adapter method and dispatches REMOVE_ADAPTER_ACTIONS', async () => {
+      const applyStyle = jest.fn()
+      Object.assign(layerAdapter, { applyStyle })
+      const actions = [{ method: 'applyStyle', parameters: ['roads', {}] }]
+      const dispatch = jest.fn()
+      const props = makeProps({
+        pluginState: makePluginState({ actionsArray: actions, dispatch })
+      })
+      await render(<DatasetsInit {...props} />)
+      expect(applyStyle).toHaveBeenCalledWith('roads', {})
+      expect(dispatch).toHaveBeenCalledWith({ type: 'REMOVE_ADAPTER_ACTIONS', payload: actions })
+      delete layerAdapter.applyStyle
+    })
+
+    it('skips dispatching when actionsArray is empty', async () => {
+      const dispatch = jest.fn()
+      const props = makeProps({ pluginState: makePluginState({ actionsArray: [], dispatch }) })
+      await render(<DatasetsInit {...props} />)
+      expect(dispatch).not.toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'REMOVE_ADAPTER_ACTIONS' })
+      )
+    })
+  })
+})

package/plugins/datasets/src/initialise/initialiseDatasets.js

@@ -3,8 +3,7 @@ import { createDynamicSource } from '../fetch/createDynamicSource.js'
 import { applyDatasetDefaults, datasetDefaults } from './defaults.js'
 import { mappedDatasetsReducer } from '../reducers/mappedDatasetsReducer.js'
 import { datasetRegistry } from '../registry/datasetRegistry.js'
-import { setMenuState } from '../registry/isVisibleWhen.js'
-import { buildMenuState } from '../reducers/menuStateReducer.js'
+import { attachMenuStateRef } from '../registry/isVisibleWhen.js'
 import { datasetsToMenu } from '../reducers/datasetsToMenu.js'
 
 export const initialiseDatasets = ({
@@ -30,8 +29,10 @@ export const initialiseDatasets = ({
     datasetRegistry.attachCreateDataset(adapter.createDataset)
   }
   datasetRegistry.attach(mappedDatasets, orderedDatasets, mapStyle)
-  const menu = pluginConfig.menu || datasetsToMenu({ datasets: processedDatasets })
-  setMenuState(buildMenuState(menu)) // Must be called before adapter.init so that menuState is set before any datasets are checked for visibility
+  const menu = datasetsToMenu({ datasets: processedDatasets })
+
+  eventBus.requestOnce('menu:state', attachMenuStateRef) // Request the menu state from the menu plugin
+
   dispatch({ type: 'SET_MENU', payload: { menu } })
   dispatch({ type: 'SET_DATASETS', payload: { mappedDatasets, orderedDatasets } })
 
@@ -49,7 +50,6 @@ export const initialiseDatasets = ({
       dynamicSources.set(registryDataset.id, dynamicSource)
     })
     adapter.attachDynamicSources(dynamicSources)
-    // TODO - apply dynamic source defaults here, and include in mappedDatasets
     eventBus.emit('datasets:ready')
   })
 
@@ -59,9 +59,20 @@ export const initialiseDatasets = ({
 
   eventBus.on(events.MAP_SIZE_CHANGE, onMapSizeChange)
 
+  // Add a listener for the datasets:registry event, which will be emitted
+  // whenever requested by other plugins, e.g. the menu and the mapKey plugin,
+  // so they can access the dataset registry.
+  const removeRegistryListener = eventBus.emitWhenRequested('datasets:registry', datasetRegistry)
+
+  eventBus.on('menu:changed', (menuState) => {
+    datasetRegistry.invalidateKeyItemsOnMenuStateChange(menuState)
+    adapter.applyGlobalVisibility()
+  })
+
   return {
     remove () {
       eventBus.off(events.MAP_SIZE_CHANGE, onMapSizeChange)
+      removeRegistryListener()
 
       // Clean up dynamic sources
       dynamicSources.forEach(source => source.destroy())

package/plugins/datasets/src/initialise/initialiseDatasets.test.js

@@ -8,6 +8,7 @@ jest.mock('../registry/datasetRegistry.js', () => ({
     attach: jest.fn(),
     attachCreateDataset: jest.fn(),
     forEachDataset: jest.fn(),
+    invalidateKeyItemsOnMenuStateChange: jest.fn(),
     _invalidateCache: jest.fn()
   }
 }))
@@ -20,6 +21,7 @@ const makeAdapter = (overrides = {}) => ({
   onMapStyleChange: jest.fn(),
   onMapSizeChange: jest.fn(),
   setData: jest.fn(),
+  applyGlobalVisibility: jest.fn(),
   destroy: jest.fn(),
   createDataset: jest.fn(),
   ...overrides
@@ -29,6 +31,8 @@ const makeEventBus = () => {
   const handlers = {}
   return {
     on: jest.fn((event, handler) => { handlers[event] = handler }),
+    requestOnce: jest.fn((event, handler) => { handlers[event] = handler }),
+    emitWhenRequested: jest.fn(() => () => {}),
     off: jest.fn(),
     emit: jest.fn(),
     _handlers: handlers
@@ -253,3 +257,41 @@ describe('returned API', () => {
     expect(() => instance.clearDatasetCache('unknown')).not.toThrow()
   })
 })
+
+// ─── onUpdate callback ────────────────────────────────────────────────────────
+
+describe('onUpdate callback', () => {
+  it('calls adapter.setData when the onUpdate callback fires', async () => {
+    const mockSource = { destroy: jest.fn(), refresh: jest.fn(), clear: jest.fn(), getFeatureCount: jest.fn() }
+    let capturedOnUpdate
+    createDynamicSource.mockImplementation(({ onUpdate }) => {
+      capturedOnUpdate = onUpdate
+      return mockSource
+    })
+    const mockDataset = { id: 'parcels', hasDynamicGeoJSON: true, dynamicGeoJSON: {} }
+    datasetRegistry.forEachDataset.mockImplementation(cb => cb(mockDataset))
+
+    const args = makeArgs()
+    initialiseDatasets(args)
+    await Promise.resolve()
+
+    const geojson = { type: 'FeatureCollection', features: [] }
+    capturedOnUpdate('parcels', geojson)
+    expect(args.adapter.setData).toHaveBeenCalledWith('parcels', geojson)
+  })
+})
+
+// ─── menu:changed handler ─────────────────────────────────────────────────────
+
+describe('menu:changed handler', () => {
+  it('calls invalidateKeyItemsOnMenuStateChange and applyGlobalVisibility', () => {
+    const args = makeArgs()
+    initialiseDatasets(args)
+
+    const menuState = { items: [{ id: 'roads', visible: true }] }
+    args.eventBus._handlers['menu:changed'](menuState)
+
+    expect(datasetRegistry.invalidateKeyItemsOnMenuStateChange).toHaveBeenCalledWith(menuState)
+    expect(args.adapter.applyGlobalVisibility).toHaveBeenCalled()
+  })
+})

package/plugins/datasets/src/manifest.js

@@ -2,7 +2,6 @@
 import { initialState, actions } from './reducers/pluginState.js'
 import { DatasetsInit } from './initialise/DatasetsInit.jsx'
 import { LayersMenu } from './components/LayersMenu/LayersMenu.jsx'
-import { Key } from './components/Key/Key.jsx'
 import { addDataset } from './api/addDataset.js'
 import { removeDataset } from './api/removeDataset.js'
 import { setDatasetVisibility } from './api/setDatasetVisibility.js'
@@ -44,22 +43,6 @@ export const manifest = {
       width: '280px'
     },
     render: LayersMenu
-  }, {
-    id: 'datasetsKey',
-    label: 'Key',
-    mobile: {
-      slot: 'drawer',
-      modal: true
-    },
-    tablet: {
-      slot: 'left-top',
-      width: '260px'
-    },
-    desktop: {
-      slot: 'left-top',
-      width: '280px'
-    },
-    render: Key
   }],
 
   buttons: [{
@@ -67,9 +50,6 @@ export const manifest = {
     label: 'Layers',
     panelId: 'datasetsLayers',
     iconId: 'layers',
-    excludeWhen: ({ pluginConfig }) => !pluginConfig.menu && !pluginConfig.datasets.some(l =>
-      l.showInMenu || l.sublayers?.some(r => r.showInMenu)
-    ),
     mobile: {
       slot: 'top-left',
       showLabel: true
@@ -82,24 +62,6 @@ export const manifest = {
       slot: 'top-left',
       showLabel: true
     }
-  }, {
-    id: 'datasetsKey',
-    label: 'Key',
-    panelId: 'datasetsKey',
-    iconId: 'key',
-    excludeWhen: ({ pluginConfig }) => !pluginConfig.datasets.some(l => l.showInKey),
-    mobile: {
-      slot: 'top-left',
-      showLabel: false
-    },
-    tablet: {
-      slot: 'top-left',
-      showLabel: true
-    },
-    desktop: {
-      slot: 'top-left',
-      showLabel: true
-    }
   }],
 
   icons: [{

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

@@ -0,0 +1,49 @@
+import { manifest } from './manifest.js'
+
+jest.mock('./reducers/pluginState.js', () => ({ initialState: {}, actions: {} }))
+jest.mock('./initialise/DatasetsInit.jsx', () => ({ DatasetsInit: jest.fn() }))
+jest.mock('./components/LayersMenu/LayersMenu.jsx', () => ({ LayersMenu: jest.fn() }))
+jest.mock('./api/addDataset.js', () => ({ addDataset: jest.fn() }))
+jest.mock('./api/removeDataset.js', () => ({ removeDataset: jest.fn() }))
+jest.mock('./api/setDatasetVisibility.js', () => ({ setDatasetVisibility: jest.fn() }))
+jest.mock('./api/setFeatureVisibility.js', () => ({ setFeatureVisibility: jest.fn() }))
+jest.mock('./api/setStyle.js', () => ({ setStyle: jest.fn() }))
+jest.mock('./api/getStyle.js', () => ({ getStyle: jest.fn() }))
+jest.mock('./api/setOpacity.js', () => ({ setOpacity: jest.fn() }))
+jest.mock('./api/getOpacity.js', () => ({ getOpacity: jest.fn() }))
+jest.mock('./api/setData.js', () => ({ setData: jest.fn() }))
+jest.mock('./api/setGlobals.js', () => ({ setGlobals: jest.fn() }))
+
+describe('manifest', () => {
+  it('exports a manifest object', () => {
+    expect(manifest).toBeDefined()
+    expect(typeof manifest).toBe('object')
+  })
+
+  it('has an InitComponent', () => {
+    expect(manifest.InitComponent).toBeDefined()
+  })
+
+  it('has a reducer with initialState and actions', () => {
+    expect(manifest.reducer).toBeDefined()
+    expect(manifest.reducer.initialState).toBeDefined()
+    expect(manifest.reducer.actions).toBeDefined()
+  })
+
+  it('has panels with a datasetsLayers panel', () => {
+    expect(Array.isArray(manifest.panels)).toBe(true)
+    expect(manifest.panels.find(p => p.id === 'datasetsLayers')).toBeDefined()
+  })
+
+  it('has a buttons array', () => {
+    expect(Array.isArray(manifest.buttons)).toBe(true)
+  })
+
+  it('has an api with all expected methods', () => {
+    expect(manifest.api.addDataset).toBeDefined()
+    expect(manifest.api.removeDataset).toBeDefined()
+    expect(manifest.api.setDatasetVisibility).toBeDefined()
+    expect(manifest.api.setOpacity).toBeDefined()
+    expect(manifest.api.getOpacity).toBeDefined()
+  })
+})