@defra/interactive-map 0.0.30-alpha → 0.0.32-alpha

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

@@ -0,0 +1,84 @@
+import {
+  datasets, expectedDatasetsMenuConfig,
+  datasetsWithGroups, expectedDatasetsMenuConfigWithGroups
+} from './__data__/demoDatasets.js'
+
+import { datasetsToMenu } from './datasetsToMenu'
+
+describe('datasetsToMenu', () => {
+  describe('Missing or empty datasets', () => {
+    it('handles empty datasets', async () => {
+      expect(datasetsToMenu({ datasets: [] }))
+        .toEqual([])
+    })
+
+    it('handles missing datasets', async () => {
+      expect(datasetsToMenu({}))
+        .toEqual([])
+    })
+  })
+
+  describe('Datasets without groups', () => {
+    it('transforms datasets to menu config', async () => {
+      expect(datasetsToMenu({ datasets }))
+        .toEqual(expectedDatasetsMenuConfig)
+    })
+  })
+
+  describe('Datasets with groups', () => {
+    it('transforms datasets with groups to menu config', async () => {
+      const datasetsWithGroupsMenuConfig = datasetsToMenu({ datasets: datasetsWithGroups })
+      expect(datasetsWithGroupsMenuConfig)
+        .toEqual(expectedDatasetsMenuConfigWithGroups)
+    })
+  })
+
+  describe('showInMenu inheritance for sublayers', () => {
+    const sublayerDataset = (datasetShowInMenu, sublayerShowInMenu) => ({
+      id: 'test',
+      label: 'Test',
+      showInMenu: datasetShowInMenu,
+      sublayers: [
+        { id: 'a', label: 'A', ...(sublayerShowInMenu !== undefined && { showInMenu: sublayerShowInMenu }) },
+        { id: 'b', label: 'B', ...(sublayerShowInMenu !== undefined && { showInMenu: sublayerShowInMenu }) }
+      ]
+    })
+
+    it('sublayers inherit showInMenu: true from the dataset when not explicitly set', () => {
+      const result = datasetsToMenu({ datasets: [sublayerDataset(true, undefined)] })
+      expect(result[0].items).toHaveLength(2)
+    })
+
+    it('sublayer can opt out with showInMenu: false when dataset has showInMenu: true', () => {
+      const dataset = {
+        id: 'test',
+        label: 'Test',
+        showInMenu: true,
+        sublayers: [
+          { id: 'a', label: 'A', showInMenu: false },
+          { id: 'b', label: 'B' }
+        ]
+      }
+      const result = datasetsToMenu({ datasets: [dataset] })
+      expect(result[0].items).toEqual([{ id: 'test-b', label: 'B' }])
+    })
+
+    it('sublayers with showInMenu: true appear when dataset does not have showInMenu set', () => {
+      const dataset = {
+        id: 'test',
+        label: 'Test',
+        sublayers: [
+          { id: 'a', label: 'A', showInMenu: true },
+          { id: 'b', label: 'B' }
+        ]
+      }
+      const result = datasetsToMenu({ datasets: [dataset] })
+      expect(result[0].items).toEqual([{ id: 'test-a', label: 'A' }])
+    })
+
+    it('does not add a menu entry when dataset has showInMenu: true but all sublayers opt out', () => {
+      const result = datasetsToMenu({ datasets: [sublayerDataset(true, false)] })
+      expect(result).toHaveLength(0)
+    })
+  })
+})

package/plugins/beta/datasets/src/reducers/mappedDatasetsReducer.js

@@ -0,0 +1,41 @@
+import { applyDatasetDefaultsWithoutFlattening } from '../initialise/defaults.js'
+
+const flattenSublayer = (parentId, sublayer) => {
+  const id = `${parentId}-${sublayer.id}`
+  const sublayerId = sublayer.id
+  if (sublayer.visibility !== 'hidden') {
+    sublayer.visibility = 'visible'
+  }
+  return { ...sublayer, id, parentId, sublayerId }
+}
+
+const reduceDatasets = (acc, dataset) => {
+  const { id } = dataset
+  const processed = applyDatasetDefaultsWithoutFlattening(dataset)
+  // For sublayers, don't let defaults override the absence of showInKey/showInMenu —
+  // the Dataset class inherits these from the parent when not explicitly set by the user
+  if (dataset.parentId) {
+    if (!('showInKey' in dataset)) { delete processed.showInKey }
+    if (!('showInMenu' in dataset)) { delete processed.showInMenu }
+  }
+  acc[id] = processed
+  const { orderedDatasets } = acc
+  orderedDatasets.push(id)
+  const flattenedSublayers = dataset.sublayers?.map((sublayer) => flattenSublayer(id, sublayer))
+  if (flattenedSublayers?.length) {
+    const sublayerIds = flattenedSublayers?.map(sublayer => sublayer.id)
+    const sublayers = flattenedSublayers?.reduce(reduceDatasets, { orderedDatasets })
+    acc[id].sublayerIds = sublayerIds
+    delete acc[id].sublayers
+    return { ...acc, ...sublayers, orderedDatasets }
+  }
+  return { ...acc, orderedDatasets }
+}
+
+export const mappedDatasetsReducer = (state) => {
+  const datasets = state.datasets || []
+  const mappedDatasets = datasets.reduce(reduceDatasets, { orderedDatasets: [] })
+  const { orderedDatasets } = mappedDatasets
+  delete mappedDatasets.orderedDatasets
+  return { ...state, mappedDatasets, orderedDatasets }
+}

package/plugins/beta/datasets/src/reducers/mappedDatasetsReducer.test.js

@@ -0,0 +1,117 @@
+import { mappedDatasetsReducer } from './mappedDatasetsReducer'
+import { datasetDefaults } from '../initialise/defaults.js'
+
+describe('mappedDatasetsReducer', () => {
+  it('handles empty datasets', () => {
+    const result = mappedDatasetsReducer({ datasets: [] })
+    expect(result.mappedDatasets).toEqual({})
+    expect(result.orderedDatasets).toEqual([])
+  })
+
+  it('handles missing datasets', () => {
+    const result = mappedDatasetsReducer({})
+    expect(result.mappedDatasets).toEqual({})
+    expect(result.orderedDatasets).toEqual([])
+  })
+
+  it('maps a single dataset with no sublayers', () => {
+    const state = {
+      datasets: [{ id: 'roads', label: 'Roads', minZoom: 10 }]
+    }
+    const result = mappedDatasetsReducer(state)
+    expect(result.mappedDatasets).toEqual({
+      roads: { ...datasetDefaults, id: 'roads', label: 'Roads', minZoom: 10 }
+    })
+    expect(result.orderedDatasets).toEqual(['roads'])
+  })
+
+  it('maps multiple datasets preserving order', () => {
+    const state = {
+      datasets: [
+        { id: 'alpha', label: 'Alpha' },
+        { id: 'beta', label: 'Beta' },
+        { id: 'gamma', label: 'Gamma' }
+      ]
+    }
+    const result = mappedDatasetsReducer(state)
+    expect(result.orderedDatasets).toEqual(['alpha', 'beta', 'gamma'])
+    expect(Object.keys(result.mappedDatasets)).toEqual(['alpha', 'beta', 'gamma'])
+  })
+
+  it('preserves other state properties', () => {
+    const state = {
+      datasets: [],
+      someOtherProp: 'value',
+      nested: { foo: 'bar' }
+    }
+    const result = mappedDatasetsReducer(state)
+    expect(result.someOtherProp).toBe('value')
+    expect(result.nested).toEqual({ foo: 'bar' })
+  })
+
+  describe('with sublayers', () => {
+    const state = {
+      datasets: [{
+        id: 'land-covers',
+        label: 'Land covers',
+        sublayers: [
+          { id: 'grassland', label: 'Grassland' },
+          { id: 'woodland', label: 'Woodland', visibility: 'hidden' }
+        ]
+      }]
+    }
+
+    it('removes the sublayers property from the parent dataset', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers'].sublayers).toBeUndefined()
+    })
+
+    it('adds sublayerIds to the parent dataset', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers'].sublayerIds).toEqual([
+        'land-covers-grassland',
+        'land-covers-woodland'
+      ])
+    })
+
+    it('adds flattened sublayers to mappedDatasets', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers-grassland']).toBeDefined()
+      expect(result.mappedDatasets['land-covers-woodland']).toBeDefined()
+    })
+
+    it('sets compound id on flattened sublayer', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers-grassland'].id).toBe('land-covers-grassland')
+    })
+
+    it('sets parentId on flattened sublayer', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers-grassland'].parentId).toBe('land-covers')
+    })
+
+    it('sets sublayerId to the original sublayer id', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers-grassland'].sublayerId).toBe('grassland')
+    })
+
+    it('sets visibility to visible for sublayers without explicit visibility', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers-grassland'].visibility).toBe('visible')
+    })
+
+    it('preserves hidden visibility on sublayers', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.mappedDatasets['land-covers-woodland'].visibility).toBe('hidden')
+    })
+
+    it('includes sublayers in orderedDatasets after their parent', () => {
+      const result = mappedDatasetsReducer(state)
+      expect(result.orderedDatasets).toEqual([
+        'land-covers',
+        'land-covers-grassland',
+        'land-covers-woodland'
+      ])
+    })
+  })
+})

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

@@ -0,0 +1,206 @@
+import { datasetsToMenu, addDatasetToMenu, removeDatasetsFromMenu } from './datasetsToMenu.js'
+import { mappedDatasetsReducer } from './mappedDatasetsReducer.js'
+import { logger } from '../../../../../src/services/logger.js'
+
+const initialState = {
+  globals: {
+    visible: true,
+    opacity: 1,
+    opacityMode: 'dataset'
+    // 'dataset': registryDataset opacity is used instead if set;
+    // 'global': registryDataset opacity is ignored
+    // 'multiply': registryDataset opacity is multiplied by parent opacity and global opacity
+  },
+  key: {
+    items: [],
+    hasGroups: false
+  },
+  actionsArray: []
+}
+
+const validateDatasetExists = (state, datasetId, prefix, suffix = 'not found') => {
+  if (!state.mappedDatasets[datasetId]) {
+    logger.error(`${prefix}: Dataset with id '${datasetId}' ${suffix}`)
+    return false
+  }
+  return true
+}
+
+let actionId = 0
+const addAction = (method, parameters, state) => {
+  actionId = state.actionsArray.length ? actionId + 1 : 0
+  return { ...state, actionsArray: [...state.actionsArray, { method, parameters, actionId }] }
+}
+
+const setGlobalState = (state, payload) => {
+  // For now we only have opacityMode, but if we add more global state
+  // properties we may not require applyGlobalOpacity to be triggered here.
+  return addAction('applyGlobalOpacity', [], {
+    ...state,
+    globals: { ...state.globals, ...payload }
+  })
+}
+
+const setDatasets = (state, payload) => {
+  const { datasets, mappedDatasets, orderedDatasets } = payload
+  const menu = payload.menu || datasetsToMenu({ datasets })
+  return {
+    ...state,
+    mappedDatasets,
+    orderedDatasets,
+    menu
+  }
+}
+
+const addDataset = (state, payload) => {
+  const { dataset, mapStyle } = payload
+  if (state.mappedDatasets[dataset.id]) {
+    logger.error(`addDataset: Dataset with id '${dataset.id}' already exists`)
+    return state
+  }
+  const { mappedDatasets: newDatasets, orderedDatasets: newOrderedDatasets } = mappedDatasetsReducer({ datasets: [dataset] })
+  const menu = addDatasetToMenu(state, dataset)
+
+  return addAction('addDataset', [dataset.id, mapStyle], {
+    ...state,
+    mappedDatasets: { ...state.mappedDatasets, ...newDatasets },
+    orderedDatasets: [...state.orderedDatasets, ...newOrderedDatasets],
+    menu
+  })
+}
+
+const removeDataset = (state, payload) => {
+  const { id } = payload
+  if (!validateDatasetExists(state, id, 'removeDataset')) {
+    return state
+  }
+  const mappedDatasets = { ...state.mappedDatasets }
+  const datasetsToRemove = [id, ...(mappedDatasets[id]?.sublayerIds || [])]
+  datasetsToRemove.forEach((datasetId) => delete mappedDatasets[datasetId])
+  // Remove from orderedDatasets
+  const orderedDatasets = state.orderedDatasets.filter(datasetId => !datasetsToRemove.includes(datasetId))
+  // Remove from menu, and remove any menu groups that are left with no items
+  return {
+    ...state,
+    mappedDatasets,
+    orderedDatasets,
+    menu: removeDatasetsFromMenu(state.menu, datasetsToRemove)
+  }
+}
+
+const setDatasetVisibility = (state, payload) => {
+  const { datasetId, visible } = payload
+  if (!validateDatasetExists(state, datasetId, 'setDatasetVisibility')) {
+    return state
+  }
+
+  return addAction('applyDatasetVisibility', [datasetId, visible], {
+    ...state,
+    mappedDatasets: { ...state.mappedDatasets, [datasetId]: { ...state.mappedDatasets[datasetId], visible } }
+  })
+}
+
+const setGlobalVisibility = (state, payload) => {
+  const { visible } = payload
+
+  return addAction('applyGlobalVisibility', [visible], {
+    ...state,
+    globals: { ...state.globals, visible }
+  })
+}
+
+const hideFeatures = (state, payload) => {
+  const { datasetId, featureIds } = payload
+  if (!validateDatasetExists(state, datasetId, 'setFeatureVisibility - hideFeatures')) {
+    return state
+  }
+  const mappedDataset = { ...state.mappedDatasets[datasetId] }
+  const existingIds = mappedDataset.hiddenFeatures || []
+  const newIds = Array.from(new Set([...existingIds, ...featureIds]))
+  mappedDataset.hiddenFeatures = newIds
+
+  return addAction('applyFeatureFilter', [datasetId], {
+    ...state,
+    mappedDatasets: { ...state.mappedDatasets, [datasetId]: mappedDataset }
+  })
+}
+
+const showFeatures = (state, payload) => {
+  const { datasetId, featureIds } = payload
+  if (!validateDatasetExists(state, datasetId, 'setFeatureVisibility - showFeatures')) {
+    return state
+  }
+  const mappedDataset = { ...state.mappedDatasets[datasetId] }
+  const existingIds = mappedDataset.hiddenFeatures || []
+  const newIds = existingIds.filter(id => !featureIds.includes(id))
+  mappedDataset.hiddenFeatures = newIds.length ? newIds : [-1] // If no features are hidden, set to -1 to force a filter update
+
+  return addAction('applyFeatureFilter', [datasetId], {
+    ...state,
+    mappedDatasets: { ...state.mappedDatasets, [datasetId]: mappedDataset }
+  })
+}
+
+const removeAdapterActions = (state, completedActions) => {
+  if (!completedActions?.length) { return state }
+  return {
+    ...state,
+    actionsArray: state.actionsArray.filter((current) => !completedActions.includes(current))
+  }
+}
+
+const setDatasetStyle = (state, payload) => {
+  const { datasetId, styleChanges, mapStyle } = payload
+  if (!validateDatasetExists(state, datasetId, 'setDatasetStyle')) {
+    return state
+  }
+  const style = { ...state.mappedDatasets[datasetId].style, ...styleChanges }
+  const dataset = { ...state.mappedDatasets[datasetId], ...styleChanges, style }
+
+  return addAction('applyStyle', [datasetId, mapStyle], {
+    ...state,
+    mappedDatasets: { ...state.mappedDatasets, [datasetId]: dataset }
+  })
+}
+
+const setOpacity = (state, payload) => {
+  const { datasetId, opacity } = payload
+  if (!validateDatasetExists(state, datasetId, 'setOpacity')) {
+    return state
+  }
+  const style = { ...state.mappedDatasets[datasetId].style, opacity }
+  const dataset = { ...state.mappedDatasets[datasetId], style }
+
+  return addAction('applyDatasetOpacity', [datasetId], {
+    ...state,
+    mappedDatasets: { ...state.mappedDatasets, [datasetId]: dataset }
+  })
+}
+
+const setGlobalOpacity = (state, payload) => {
+  const { opacity } = payload
+  return addAction('applyGlobalOpacity', [], {
+    ...state,
+    globals: { ...state.globals, opacity }
+  })
+}
+
+const actions = {
+  SET_DATASETS: setDatasets,
+  ADD_DATASET: addDataset,
+  REMOVE_DATASET: removeDataset,
+  SET_DATASET_VISIBILITY: setDatasetVisibility,
+  SET_GLOBAL_VISIBILITY: setGlobalVisibility,
+  SET_DATASET_STYLE: setDatasetStyle,
+  SET_OPACITY: setOpacity,
+  SET_GLOBAL_OPACITY: setGlobalOpacity,
+  HIDE_FEATURES: hideFeatures,
+  SHOW_FEATURES: showFeatures,
+  REMOVE_ADAPTER_ACTIONS: removeAdapterActions,
+  SET_GLOBAL_STATE: setGlobalState
+}
+
+export {
+  initialState,
+  actions
+}