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

package/plugins/datasets/src/reducers/datasetsToMenu.test.js

@@ -3,7 +3,7 @@ import {
   datasetsWithGroups, expectedDatasetsMenuConfigWithGroups
 } from './__data__/demoDatasets.js'
 
-import { datasetsToMenu } from './datasetsToMenu'
+import { datasetsToMenu, addDatasetToMenu, removeDatasetsFromMenu } from './datasetsToMenu'
 
 describe('datasetsToMenu', () => {
   describe('Missing or empty datasets', () => {
@@ -80,5 +80,58 @@ describe('datasetsToMenu', () => {
       const result = datasetsToMenu({ datasets: [sublayerDataset(true, false)] })
       expect(result).toEqual([{ id: 'test', items: [{ id: 'test', label: 'Test' }], type: 'checkbox', visibleWhen: true }])
     })
+
+    it('skips a parent with showInMenu:false when no sublayers are visible', () => {
+      // Contrived: a getter that returns true on the first access (outer filter's `some`)
+      // and false on subsequent accesses (inner filter), hitting the early-return guard.
+      let calls = 0
+      const dataset = {
+        id: 'tricky',
+        label: 'Tricky',
+        showInMenu: false,
+        sublayers: [{ id: 'tricky-a', label: 'A', get showInMenu () { return calls++ === 0 } }]
+      }
+      const result = datasetsToMenu({ datasets: [dataset] })
+      expect(result).toEqual([])
+    })
+  })
+})
+
+describe('addDatasetToMenu', () => {
+  it('appends to an existing menu group with matching groupLabel', () => {
+    const state = {
+      menu: [{ id: 'Layers', groupLabel: 'Layers', type: 'checkbox', visibleWhen: true, items: [{ id: 'roads', label: 'Roads' }] }]
+    }
+    const dataset = { id: 'rivers', label: 'Rivers', showInMenu: true, groupLabel: 'Layers' }
+    const result = addDatasetToMenu(state, dataset)
+    expect(result[0].items).toHaveLength(2)
+    expect(result[0].items[1]).toEqual({ id: 'rivers', label: 'Rivers' })
+  })
+
+  it('pushes a new group when no matching groupLabel exists', () => {
+    const state = { menu: [] }
+    const dataset = { id: 'parks', label: 'Parks', showInMenu: true }
+    const result = addDatasetToMenu(state, dataset)
+    expect(result).toHaveLength(1)
+    expect(result[0].items[0].id).toBe('parks')
+  })
+})
+
+describe('removeDatasetsFromMenu', () => {
+  it('keeps groups that still have items after filtering', () => {
+    const menu = [
+      { id: 'Layers', items: [{ id: 'roads' }, { id: 'rivers' }] }
+    ]
+    const result = removeDatasetsFromMenu(menu, ['roads'])
+    expect(result).toHaveLength(1)
+    expect(result[0].items).toEqual([{ id: 'rivers' }])
+  })
+
+  it('removes groups that are left with no items', () => {
+    const menu = [
+      { id: 'Layers', items: [{ id: 'roads' }] }
+    ]
+    const result = removeDatasetsFromMenu(menu, ['roads'])
+    expect(result).toHaveLength(0)
   })
 })

package/plugins/datasets/src/reducers/pluginState.js

@@ -1,5 +1,4 @@
 import { addDatasetToMenu, removeDatasetsFromMenu } from './datasetsToMenu.js'
-import { buildMenuState } from './menuStateReducer.js'
 import { mappedDatasetsReducer } from './mappedDatasetsReducer.js'
 import { logger } from '../../../../src/services/logger.js'
 
@@ -19,8 +18,7 @@ const initialState = {
   mappedDatasets: {},
   orderedDatasets: [],
   actionsArray: [],
-  menu: [],
-  menuState: {}
+  menu: []
 }
 
 const validateDatasetExists = (state, datasetId, prefix, suffix = 'not found') => {
@@ -46,21 +44,11 @@ const setGlobalState = (state, payload) => {
   })
 }
 
-const updateMenuState = (state, payload) => {
-  return addAction('applyGlobalVisibility', [], {
-    ...state,
-    menuState: { ...state.menuState, ...payload }
-  })
-}
-
 const setMenu = (state, payload) => {
   const { menu } = payload
-  // build the initial menuState for radios from the menu
-  const menuState = buildMenuState(menu)
   return {
     ...state,
-    menu,
-    menuState
+    menu
   }
 }
 
@@ -223,8 +211,7 @@ const actions = {
   SHOW_FEATURES: showFeatures,
   REMOVE_ADAPTER_ACTIONS: removeAdapterActions,
   SET_GLOBAL_STATE: setGlobalState,
-  SET_MENU: setMenu,
-  UPDATE_MENU_STATE: updateMenuState
+  SET_MENU: setMenu
 }
 
 export {

package/plugins/datasets/src/reducers/pluginState.test.js

@@ -172,6 +172,29 @@ describe('SET_DATASET_VISIBILITY', () => {
     expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
     expect(result).toBe(state)
   })
+
+  it('returns unchanged state when visibility already matches', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.SET_DATASET_VISIBILITY(state, { datasetId: 'roads', visible: true })
+    expect(result).toBe(state)
+  })
+})
+
+// ─── SET_MENU ────────────────────────────────────────────────────────────────
+
+describe('SET_MENU', () => {
+  it('sets menu from payload', () => {
+    const state = makeState()
+    const menu = [{ id: 'layers', items: [] }]
+    const result = actions.SET_MENU(state, { menu })
+    expect(result.menu).toBe(menu)
+  })
+
+  it('does not add to actionsArray', () => {
+    const state = makeState()
+    const result = actions.SET_MENU(state, { menu: [] })
+    expect(result.actionsArray).toEqual([])
+  })
 })
 
 // ─── SET_GLOBAL_VISIBILITY ────────────────────────────────────────────────────

package/plugins/datasets/src/registry/dataset.js

@@ -108,7 +108,7 @@ export class Dataset {
   }
 
   get keyVisibility () {
-    return this.visibility === 'visible' && this.showInKey
+    return this.showInKey && this.visibility === 'visible'
   }
 
   get symbolAnchor () {
@@ -201,4 +201,16 @@ export class Dataset {
     }
     return styleSymbols
   }
+
+  get keyDefinition () {
+    return {
+      id: this.id,
+      type: 'dataset',
+      label: this.label,
+      hasSymbol: this.hasSymbol,
+      hasPattern: this.hasPattern,
+      style: this.style,
+      symbolDescription: this.symbolDescription
+    }
+  }
 }

package/plugins/datasets/src/registry/dataset.test.js

@@ -494,4 +494,65 @@ describe('Dataset class', () => {
       expect(new Dataset(childDef).sourceLayer).toBe('parent_layer')
     })
   })
+
+  describe('isHiddenByInheritance', () => {
+    it('returns true for a sublayer whose parent is not visible', () => {
+      const parentDef = { id: 'parent', visible: false, style: {} }
+      const childDef = { id: 'child', parentId: 'parent', visible: true, style: {} }
+      datasetRegistry.attach({ parent: parentDef, child: childDef })
+      expect(new Dataset(childDef).isHiddenByInheritance).toBe(true)
+    })
+
+    it('returns false for a sublayer whose parent is visible', () => {
+      const parentDef = { id: 'parent', visible: true, style: {} }
+      const childDef = { id: 'child', parentId: 'parent', visible: true, style: {} }
+      datasetRegistry.attach({ parent: parentDef, child: childDef })
+      expect(new Dataset(childDef).isHiddenByInheritance).toBe(false)
+    })
+
+    it('returns false for a top-level dataset when global visibility is true', () => {
+      const dataset = new Dataset({ id: 'top', visible: true, style: {} })
+      expect(dataset.isHiddenByInheritance).toBe(false)
+    })
+  })
+
+  describe('isLocallyVisible', () => {
+    it('returns the raw visible flag from the definition when not visible', () => {
+      const dataset = new Dataset({ visible: false })
+      expect(dataset.isLocallyVisible).toBe(false)
+    })
+
+    it('returns undefined when visible is not set and dataset is not visible', () => {
+      const dataset = new Dataset({})
+      expect(dataset.isLocallyVisible).toBeUndefined()
+    })
+
+    it('returns true when isVisible is truthy (subclass override scenario)', () => {
+      const dataset = new Dataset({ visible: false })
+      Object.defineProperty(dataset, 'isVisible', { get: () => true, configurable: true })
+      expect(dataset.isLocallyVisible).toBe(true)
+    })
+  })
+
+  describe('dynamicGeoJSON getter', () => {
+    it('returns a DynamicGeoJson with idProperty set', () => {
+      const dataset = new Dataset({
+        id: 'parcels',
+        dynamicGeoJSON: { url: 'http://example.com', idProperty: 'parcel_id' }
+      })
+      const dg = dataset.dynamicGeoJSON
+      expect(dg.source.promoteId).toBe('parcel_id')
+      expect(dg.source.generateId).toBeUndefined()
+    })
+
+    it('returns a DynamicGeoJson with generateId when no idProperty', () => {
+      const dataset = new Dataset({
+        id: 'parcels',
+        dynamicGeoJSON: { url: 'http://example.com' }
+      })
+      const dg = dataset.dynamicGeoJSON
+      expect(dg.source.generateId).toBe(true)
+      expect(dg.source.promoteId).toBeUndefined()
+    })
+  })
 })

package/plugins/datasets/src/registry/datasetRegistry.js

@@ -83,7 +83,12 @@ const datasetRegistry = {
     }, { patternConfigs: [], symbolConfigs: [] })
   },
 
-  invalidateKeyItems () {
+  _lastMenuState: {},
+  invalidateKeyItemsOnMenuStateChange (menuState) {
+    if (menuState === this._lastMenuState) {
+      return
+    }
+    this._lastMenuState = menuState
     this._lastKeyItemsDatasets = null
   },
   _lastKeyItems: {},
@@ -101,8 +106,9 @@ const datasetRegistry = {
       }
       const groupObject = {
         type: 'group',
+        id: groupLabel.toLowerCase().replaceAll(/\s+/g, '-'),
         groupLabel,
-        datasets: []
+        keyDefinitions: []
       }
       groups.set(groupLabel, groupObject)
       _items.push(groupObject)
@@ -110,22 +116,22 @@ const datasetRegistry = {
     }
 
     this.forEach((dataset) => {
-      if (!(dataset.showInKey && dataset.keyVisibility)) {
+      if (!dataset.keyVisibility) {
         return
       }
       const isGroup = dataset.hasSublayers || dataset.groupLabel
       if (!isGroup) {
-        _items.push({ type: 'flat', dataset })
+        _items.push({ type: 'flat', id: dataset.id, keyDefinition: dataset.keyDefinition })
         return
       }
 
       const groupLabel = dataset.groupLabel || dataset.label
       const groupObject = getOrCreateGroup(groupLabel)
       if (!dataset.hasSublayers) {
-        groupObject.datasets.push(dataset)
+        groupObject.keyDefinitions.push(dataset.keyDefinition)
       }
     })
-    const items = _items.filter((item) => item.type === 'flat' || Boolean(item.datasets?.length))
+    const items = _items.filter((item) => item.type === 'flat' || Boolean(item.keyDefinitions?.length))
     const hasGroups = items.some(item => item.type === 'group')
     this._lastKeyItems = { items, hasGroups }
     return this._lastKeyItems

package/plugins/datasets/src/registry/datasetRegistry.test.js

@@ -148,6 +148,7 @@ describe('datasetRegistry', () => {
       const { mappedDatasets: singleHiddenSublayer, orderedDatasets } = mappedDatasetsReducer({
         datasets: [{
           id: 'single-sublayer-dataset',
+          label: 'Single Layer',
           showInKey: true,
           visible: true,
           style: {},
@@ -162,7 +163,7 @@ describe('datasetRegistry', () => {
     it('only includes visible sublayers in group items', () => {
       const { items } = datasetRegistry.keyItems()
       const landCoversItem = items.find(item => item.type === 'group' && item.groupLabel === 'Land covers')
-      const sublayerIds = landCoversItem.datasets.map(s => s.id)
+      const sublayerIds = landCoversItem.keyDefinitions.map(s => s.id)
       expect(sublayerIds).not.toContain('land-covers-379') // land-covers-379 has visible: false
     })
 
@@ -188,7 +189,7 @@ describe('datasetRegistry', () => {
       datasetRegistry.attach(grouped, orderedDatasets)
       const { items } = datasetRegistry.keyItems()
       const groupItem = items.find(item => item.type === 'group' && item.groupLabel === 'Test group')
-      const ids = groupItem.datasets.map(d => d.id)
+      const ids = groupItem.keyDefinitions.map(d => d.id)
       expect(ids).toContain('existing-fields')
       expect(ids).toContain('hedge-control')
     })
@@ -199,13 +200,24 @@ describe('datasetRegistry', () => {
       expect(result1).toBe(result2)
     })
 
-    it('recalculates caches the cached result when invalidateKeyItems is called', () => {
+    it('recalculates the keyItems when invalidateKeyItemsOnMenuStateChange is called with new menuState', () => {
+      const menuState = { someMenuKey: 'someValue' }
+      datasetRegistry.invalidateKeyItemsOnMenuStateChange({})
       const result1 = datasetRegistry.keyItems()
-      datasetRegistry.invalidateKeyItems()
+      datasetRegistry.invalidateKeyItemsOnMenuStateChange(menuState)
       const result2 = datasetRegistry.keyItems()
       expect(result1).not.toBe(result2)
     })
 
+    it('keeps the cached keyItems when invalidateKeyItemsOnMenuStateChange is called with the same menuState', () => {
+      const menuState = { someMenuKey: 'someOtherValue' }
+      datasetRegistry.invalidateKeyItemsOnMenuStateChange(menuState)
+      const result1 = datasetRegistry.keyItems()
+      datasetRegistry.invalidateKeyItemsOnMenuStateChange(menuState)
+      const result2 = datasetRegistry.keyItems()
+      expect(result1).toBe(result2)
+    })
+
     it('recomputes when the datasets ref changes', () => {
       const result1 = datasetRegistry.keyItems()
       datasetRegistry.attach({ simple: { id: 'simple', showInKey: true, visible: true, style: {} } }, ['simple'])

package/plugins/datasets/src/registry/isVisibleWhen.js

@@ -1,11 +1,14 @@
 import { datasetRegistry } from './datasetRegistry.js'
 
-let _menuState = {}
-export const setMenuState = (menuState) => { _menuState = menuState }
+let _menuStateRef = {}
+export const attachMenuStateRef = (menuStateRef) => {
+  _menuStateRef = menuStateRef
+}
 
 const _isVisibleWhenMenuCheck = (menuVisibleWhen) => {
+  const menuState = _menuStateRef?.current?.menuState || {}
   for (const [key, valueArray] of Object.entries(menuVisibleWhen)) {
-    const menuValue = _menuState[key]
+    const menuValue = menuState[key]
     if (!valueArray.includes(menuValue)) {
       return false
     }

package/plugins/datasets/src/registry/isVisibleWhen.test.js

@@ -1,6 +1,10 @@
-import { isVisibleWhen, setMenuState } from './isVisibleWhen.js'
+import { isVisibleWhen, attachMenuStateRef } from './isVisibleWhen.js'
 import { datasetRegistry } from './datasetRegistry.js'
 
+const setMenuState = (menuState) => {
+  attachMenuStateRef({ current: { menuState } })
+}
+
 describe('isVisibleWhen', () => {
   beforeEach(() => {
     // reset menu state before each test
@@ -64,4 +68,10 @@ describe('isVisibleWhen', () => {
     const visibleWhen = 'incorrectly-configured'
     expect(isVisibleWhen(visibleWhen)).toBe(true)
   })
+
+  it('returns false when menu condition is checked and menuState has not been set up', () => {
+    attachMenuStateRef({}) // current is undefined — exercises the || {} fallback
+    const visibleWhen = { menu: { datasets: ['floodZones'] } }
+    expect(isVisibleWhen(visibleWhen)).toBe(false)
+  })
 })

package/plugins/datasets/src/utils/bbox.test.js

@@ -0,0 +1,125 @@
+import { getBboxArray, bboxContains, expandBbox, bboxIntersects, getGeometryBbox } from './bbox.js'
+
+// ─── getBboxArray ─────────────────────────────────────────────────────────────
+
+describe('getBboxArray', () => {
+  it('returns [west, south, east, north] from a map bounds object', () => {
+    const map = {
+      getBounds: () => ({
+        getWest: () => -1,
+        getSouth: () => 50,
+        getEast: () => 1,
+        getNorth: () => 52
+      })
+    }
+    expect(getBboxArray(map)).toEqual([-1, 50, 1, 52])
+  })
+})
+
+// ─── bboxContains ─────────────────────────────────────────────────────────────
+
+describe('bboxContains', () => {
+  const outer = [-2, 49, 2, 53]
+
+  it('returns false when outer is null', () => {
+    expect(bboxContains(null, [-1, 50, 1, 52])).toBe(false)
+  })
+
+  it('returns false when inner is null', () => {
+    expect(bboxContains(outer, null)).toBe(false)
+  })
+
+  it('returns true when inner is fully inside outer', () => {
+    expect(bboxContains(outer, [-1, 50, 1, 52])).toBe(true)
+  })
+
+  it('returns false when inner extends outside outer', () => {
+    expect(bboxContains(outer, [-3, 50, 1, 52])).toBe(false)
+  })
+})
+
+// ─── expandBbox ───────────────────────────────────────────────────────────────
+
+describe('expandBbox', () => {
+  it('returns a copy of addition when existing is null', () => {
+    expect(expandBbox(null, [1, 2, 3, 4])).toEqual([1, 2, 3, 4])
+  })
+
+  it('returns the bounding union of existing and addition', () => {
+    expect(expandBbox([-1, 49, 1, 51], [-2, 50, 2, 52])).toEqual([-2, 49, 2, 52])
+  })
+})
+
+// ─── bboxIntersects ───────────────────────────────────────────────────────────
+
+describe('bboxIntersects', () => {
+  it('returns false when a is null', () => {
+    expect(bboxIntersects(null, [0, 0, 1, 1])).toBe(false)
+  })
+
+  it('returns false when b is null', () => {
+    expect(bboxIntersects([0, 0, 1, 1], null)).toBe(false)
+  })
+
+  it('returns true when bboxes overlap', () => {
+    expect(bboxIntersects([0, 0, 2, 2], [1, 1, 3, 3])).toBe(true)
+  })
+
+  it('returns false when bboxes do not overlap', () => {
+    expect(bboxIntersects([0, 0, 1, 1], [2, 2, 3, 3])).toBe(false)
+  })
+})
+
+// ─── getGeometryBbox ──────────────────────────────────────────────────────────
+
+describe('getGeometryBbox', () => {
+  it('handles a Point', () => {
+    expect(getGeometryBbox({ type: 'Point', coordinates: [10, 20] }))
+      .toEqual([10, 20, 10, 20])
+  })
+
+  it('handles a LineString', () => {
+    expect(getGeometryBbox({ type: 'LineString', coordinates: [[0, 0], [2, 4]] }))
+      .toEqual([0, 0, 2, 4])
+  })
+
+  it('handles a MultiPoint', () => {
+    expect(getGeometryBbox({ type: 'MultiPoint', coordinates: [[1, 2], [3, 4]] }))
+      .toEqual([1, 2, 3, 4])
+  })
+
+  it('handles a Polygon', () => {
+    const ring = [[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]]
+    expect(getGeometryBbox({ type: 'Polygon', coordinates: [ring] }))
+      .toEqual([0, 0, 5, 5])
+  })
+
+  it('handles a MultiLineString', () => {
+    expect(getGeometryBbox({
+      type: 'MultiLineString',
+      coordinates: [[[0, 0], [1, 1]], [[2, 2], [3, 3]]]
+    })).toEqual([0, 0, 3, 3])
+  })
+
+  it('handles a MultiPolygon', () => {
+    const poly1 = [[[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]]]
+    const poly2 = [[[3, 3], [3, 5], [5, 5], [5, 3], [3, 3]]]
+    expect(getGeometryBbox({ type: 'MultiPolygon', coordinates: [poly1, poly2] }))
+      .toEqual([0, 0, 5, 5])
+  })
+
+  it('handles a GeometryCollection', () => {
+    expect(getGeometryBbox({
+      type: 'GeometryCollection',
+      geometries: [
+        { type: 'Point', coordinates: [1, 2] },
+        { type: 'Point', coordinates: [5, 6] }
+      ]
+    })).toEqual([1, 2, 5, 6])
+  })
+
+  it('throws for an unsupported geometry type', () => {
+    expect(() => getGeometryBbox({ type: 'Triangle', coordinates: [] }))
+      .toThrow('Unsupported geometry type: Triangle')
+  })
+})