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

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

@@ -0,0 +1,386 @@
+import { initialState, actions } from './pluginState.js'
+import { logger } from '../../../../../src/services/logger.js'
+
+jest.mock('../../../../../src/services/logger.js', () => ({
+  logger: { error: jest.fn() }
+}))
+
+// Helper: build a minimal plugin state with some mapped datasets
+const makeState = (overrides = {}) => ({
+  ...initialState,
+  mappedDatasets: {},
+  orderedDatasets: [],
+  menu: [],
+  ...overrides
+})
+
+// Helper: build a state that already contains a dataset
+const makeStateWithDataset = (id = 'roads', extraDatasetProps = {}) => ({
+  ...makeState(),
+  mappedDatasets: {
+    [id]: { id, label: 'Roads', visible: true, style: {}, ...extraDatasetProps }
+  },
+  orderedDatasets: [id],
+  menu: [{ label: 'Default', items: [{ id, label: 'Roads', type: 'item' }] }]
+})
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+// ─── initialState ────────────────────────────────────────────────────────────
+
+describe('initialState', () => {
+  it('has default globals', () => {
+    expect(initialState.globals).toEqual({
+      visible: true,
+      opacity: 1,
+      opacityMode: 'dataset'
+    })
+  })
+
+  it('has an empty key', () => {
+    expect(initialState.key).toEqual({ items: [], hasGroups: false })
+  })
+
+  it('has an empty actionsArray', () => {
+    expect(initialState.actionsArray).toEqual([])
+  })
+})
+
+// ─── SET_DATASETS ─────────────────────────────────────────────────────────────
+
+describe('SET_DATASETS', () => {
+  it('sets mappedDatasets, orderedDatasets and menu from payload', () => {
+    const state = makeState()
+    const payload = {
+      datasets: [{ id: 'parks', label: 'Parks', showInMenu: true }],
+      mappedDatasets: { parks: { id: 'parks', label: 'Parks' } },
+      orderedDatasets: ['parks'],
+      menu: [{ id: 'parks', label: 'Parks', type: 'item' }]
+    }
+    const result = actions.SET_DATASETS(state, payload)
+    expect(result.mappedDatasets).toEqual(payload.mappedDatasets)
+    expect(result.orderedDatasets).toEqual(payload.orderedDatasets)
+    expect(result.menu).toEqual(payload.menu)
+  })
+
+  it('derives menu from datasets when menu is not in payload', () => {
+    const state = makeState()
+    const payload = {
+      datasets: [{ id: 'parks', label: 'Parks', showInMenu: true }],
+      mappedDatasets: { parks: { id: 'parks', label: 'Parks' } },
+      orderedDatasets: ['parks']
+    }
+    const result = actions.SET_DATASETS(state, payload)
+    // Menu is derived; it should be an array
+    expect(Array.isArray(result.menu)).toBe(true)
+  })
+
+  it('does not add to actionsArray', () => {
+    const state = makeState()
+    const payload = {
+      datasets: [],
+      mappedDatasets: {},
+      orderedDatasets: []
+    }
+    const result = actions.SET_DATASETS(state, payload)
+    expect(result.actionsArray).toEqual([])
+  })
+})
+
+// ─── ADD_DATASET ──────────────────────────────────────────────────────────────
+
+describe('ADD_DATASET', () => {
+  it('adds a new dataset and queues an addDataset action', () => {
+    const state = makeState()
+    const dataset = { id: 'rivers', label: 'Rivers', showInMenu: true }
+    const mapStyle = { layers: [] }
+
+    const result = actions.ADD_DATASET(state, { dataset, mapStyle })
+
+    expect(result.mappedDatasets).toHaveProperty('rivers')
+    expect(result.orderedDatasets).toContain('rivers')
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({
+      method: 'addDataset',
+      parameters: ['rivers', mapStyle]
+    })
+  })
+
+  it('logs error and returns unchanged state when dataset already exists', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.ADD_DATASET(state, { dataset: { id: 'roads', label: 'Roads' }, mapStyle: {} })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'roads'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── REMOVE_DATASET ───────────────────────────────────────────────────────────
+
+describe('REMOVE_DATASET', () => {
+  it('removes the dataset from mappedDatasets, orderedDatasets and menu', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.REMOVE_DATASET(state, { id: 'roads' })
+
+    expect(result.mappedDatasets).not.toHaveProperty('roads')
+    expect(result.orderedDatasets).not.toContain('roads')
+  })
+
+  it('removes sublayers when parent is removed', () => {
+    const state = makeState({
+      mappedDatasets: {
+        parks: { id: 'parks', label: 'Parks', sublayerIds: ['parks-zone-a'] },
+        'parks-zone-a': { id: 'parks-zone-a', parentId: 'parks' }
+      },
+      orderedDatasets: ['parks', 'parks-zone-a'],
+      menu: []
+    })
+    const result = actions.REMOVE_DATASET(state, { id: 'parks' })
+
+    expect(result.mappedDatasets).not.toHaveProperty('parks')
+    expect(result.mappedDatasets).not.toHaveProperty('parks-zone-a')
+    expect(result.orderedDatasets).toEqual([])
+  })
+
+  it('logs error and returns unchanged state when dataset does not exist', () => {
+    const state = makeState()
+    const result = actions.REMOVE_DATASET(state, { id: 'unknown' })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── SET_DATASET_VISIBILITY ───────────────────────────────────────────────────
+
+describe('SET_DATASET_VISIBILITY', () => {
+  it('updates dataset visibility and queues applyDatasetVisibility action', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.SET_DATASET_VISIBILITY(state, { datasetId: 'roads', visible: false })
+
+    expect(result.mappedDatasets.roads.visible).toBe(false)
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({
+      method: 'applyDatasetVisibility',
+      parameters: ['roads', false]
+    })
+  })
+
+  it('logs error and returns unchanged state when dataset does not exist', () => {
+    const state = makeState()
+    const result = actions.SET_DATASET_VISIBILITY(state, { datasetId: 'unknown', visible: false })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── SET_GLOBAL_VISIBILITY ────────────────────────────────────────────────────
+
+describe('SET_GLOBAL_VISIBILITY', () => {
+  it('updates globals.visible and queues applyGlobalVisibility action', () => {
+    const state = makeState()
+    const result = actions.SET_GLOBAL_VISIBILITY(state, { visible: false })
+
+    expect(result.globals.visible).toBe(false)
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({
+      method: 'applyGlobalVisibility',
+      parameters: [false]
+    })
+  })
+})
+
+// ─── SET_DATASET_STYLE ────────────────────────────────────────────────────────
+
+describe('SET_DATASET_STYLE', () => {
+  it('merges style changes and queues applyStyle action', () => {
+    const state = makeStateWithDataset('roads', { style: { stroke: 'red' } })
+    const mapStyle = { layers: [] }
+    const result = actions.SET_DATASET_STYLE(state, {
+      datasetId: 'roads',
+      styleChanges: { fill: 'blue' },
+      mapStyle
+    })
+
+    expect(result.mappedDatasets.roads.style).toMatchObject({ stroke: 'red', fill: 'blue' })
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({
+      method: 'applyStyle',
+      parameters: ['roads', mapStyle]
+    })
+  })
+
+  it('logs error and returns unchanged state when dataset does not exist', () => {
+    const state = makeState()
+    const result = actions.SET_DATASET_STYLE(state, { datasetId: 'unknown', styleChanges: {}, mapStyle: {} })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── SET_OPACITY ──────────────────────────────────────────────────────────────
+
+describe('SET_OPACITY', () => {
+  it('sets opacity in dataset style and queues applyDatasetOpacity action', () => {
+    const state = makeStateWithDataset('roads', { style: {} })
+    const result = actions.SET_OPACITY(state, { datasetId: 'roads', opacity: 0.5 })
+
+    expect(result.mappedDatasets.roads.style.opacity).toBe(0.5)
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({
+      method: 'applyDatasetOpacity',
+      parameters: ['roads']
+    })
+  })
+
+  it('logs error and returns unchanged state when dataset does not exist', () => {
+    const state = makeState()
+    const result = actions.SET_OPACITY(state, { datasetId: 'unknown', opacity: 0.5 })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── SET_GLOBAL_OPACITY ───────────────────────────────────────────────────────
+
+describe('SET_GLOBAL_OPACITY', () => {
+  it('updates globals.opacity and queues applyGlobalOpacity action', () => {
+    const state = makeState()
+    const result = actions.SET_GLOBAL_OPACITY(state, { opacity: 0.7 })
+
+    expect(result.globals.opacity).toBe(0.7)
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({
+      method: 'applyGlobalOpacity',
+      parameters: []
+    })
+  })
+})
+
+// ─── SET_GLOBAL_STATE ─────────────────────────────────────────────────────────
+
+describe('SET_GLOBAL_STATE', () => {
+  it('merges payload into globals and queues applyGlobalOpacity action', () => {
+    const state = makeState()
+    const result = actions.SET_GLOBAL_STATE(state, { opacityMode: 'global' })
+
+    expect(result.globals.opacityMode).toBe('global')
+    expect(result.actionsArray).toHaveLength(1)
+    expect(result.actionsArray[0]).toMatchObject({ method: 'applyGlobalOpacity' })
+  })
+})
+
+// ─── HIDE_FEATURES ────────────────────────────────────────────────────────────
+
+describe('HIDE_FEATURES', () => {
+  it('starts from empty hiddenFeatures when none are set', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.HIDE_FEATURES(state, { datasetId: 'roads', featureIds: [5] })
+    expect(result.mappedDatasets.roads.hiddenFeatures).toEqual([5])
+  })
+
+  it('adds feature ids to hiddenFeatures and queues applyFeatureFilter', () => {
+    const state = makeStateWithDataset('roads', { hiddenFeatures: [1] })
+    const result = actions.HIDE_FEATURES(state, { datasetId: 'roads', featureIds: [2, 3] })
+
+    expect(result.mappedDatasets.roads.hiddenFeatures).toEqual([1, 2, 3])
+    expect(result.actionsArray[0]).toMatchObject({ method: 'applyFeatureFilter', parameters: ['roads'] })
+  })
+
+  it('deduplicates feature ids', () => {
+    const state = makeStateWithDataset('roads', { hiddenFeatures: [1, 2] })
+    const result = actions.HIDE_FEATURES(state, { datasetId: 'roads', featureIds: [2, 3] })
+
+    expect(result.mappedDatasets.roads.hiddenFeatures).toEqual([1, 2, 3])
+  })
+
+  it('logs error and returns unchanged state when dataset does not exist', () => {
+    const state = makeState()
+    const result = actions.HIDE_FEATURES(state, { datasetId: 'unknown', featureIds: [1] })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── SHOW_FEATURES ────────────────────────────────────────────────────────────
+
+describe('SHOW_FEATURES', () => {
+  it('handles dataset with no existing hiddenFeatures', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.SHOW_FEATURES(state, { datasetId: 'roads', featureIds: [99] })
+    expect(result.mappedDatasets.roads.hiddenFeatures).toEqual([-1])
+  })
+
+  it('removes feature ids from hiddenFeatures and queues applyFeatureFilter', () => {
+    const state = makeStateWithDataset('roads', { hiddenFeatures: [1, 2, 3] })
+    const result = actions.SHOW_FEATURES(state, { datasetId: 'roads', featureIds: [2] })
+
+    expect(result.mappedDatasets.roads.hiddenFeatures).toEqual([1, 3])
+    expect(result.actionsArray[0]).toMatchObject({ method: 'applyFeatureFilter', parameters: ['roads'] })
+  })
+
+  it('sets hiddenFeatures to [-1] when all features are shown', () => {
+    const state = makeStateWithDataset('roads', { hiddenFeatures: [1] })
+    const result = actions.SHOW_FEATURES(state, { datasetId: 'roads', featureIds: [1] })
+
+    expect(result.mappedDatasets.roads.hiddenFeatures).toEqual([-1])
+  })
+
+  it('logs error and returns unchanged state when dataset does not exist', () => {
+    const state = makeState()
+    const result = actions.SHOW_FEATURES(state, { datasetId: 'unknown', featureIds: [1] })
+
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("'unknown'"))
+    expect(result).toBe(state)
+  })
+})
+
+// ─── REMOVE_ADAPTER_ACTIONS ───────────────────────────────────────────────────
+
+describe('REMOVE_ADAPTER_ACTIONS', () => {
+  it('removes completed actions from actionsArray', () => {
+    const action1 = { method: 'addDataset', parameters: ['roads'], actionId: 0 }
+    const action2 = { method: 'applyStyle', parameters: ['roads', {}], actionId: 1 }
+    const state = { ...makeState(), actionsArray: [action1, action2] }
+
+    const result = actions.REMOVE_ADAPTER_ACTIONS(state, [action1])
+
+    expect(result.actionsArray).toEqual([action2])
+  })
+
+  it('returns unchanged state when completedActions is empty', () => {
+    const state = makeState()
+    const result = actions.REMOVE_ADAPTER_ACTIONS(state, [])
+    expect(result).toBe(state)
+  })
+
+  it('returns unchanged state when completedActions is undefined', () => {
+    const state = makeState()
+    const result = actions.REMOVE_ADAPTER_ACTIONS(state, undefined)
+    expect(result).toBe(state)
+  })
+})
+
+// ─── actionId counter behaviour ───────────────────────────────────────────────
+
+describe('actionId counter', () => {
+  it('resets actionId to 0 when actionsArray is empty', () => {
+    const state = makeStateWithDataset('roads')
+    const result = actions.SET_DATASET_VISIBILITY(state, { datasetId: 'roads', visible: false })
+    expect(result.actionsArray[0].actionId).toBe(0)
+  })
+
+  it('increments actionId for each successive queued action', () => {
+    const state = makeStateWithDataset('roads')
+    const state1 = actions.SET_DATASET_VISIBILITY(state, { datasetId: 'roads', visible: false })
+    const state2 = actions.SET_DATASET_VISIBILITY(state1, { datasetId: 'roads', visible: true })
+
+    expect(state2.actionsArray[1].actionId).toBe(1)
+  })
+})

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

@@ -0,0 +1,29 @@
+import { mappedDatasetsReducer } from '../../reducers/mappedDatasetsReducer.js'
+import { datasets as datasetDefinitions } from '../../reducers/__data__/demoDatasets.js'
+import { attachGlobalState } from '../globalDataset.js'
+const { datasetRegistry } = jest.requireActual('../datasetRegistry.js')
+const { mappedDatasets, orderedDatasets } = mappedDatasetsReducer({ datasets: datasetDefinitions })
+
+const globalState = {
+  opacityMode: 'dataset',
+  opacity: 1,
+  visible: true
+}
+
+// By adding jest.mock('<path-to>/datasetRegistry.js')
+// to a test file, any import of datasetRegistry from that file will get this
+// version with the demo datasets attached for testing.
+// If we need to test against a different set of datasets
+// we can import that config from demoDatasets.js (or roll our own)
+// and attach it in the specific test
+beforeEach(() => {
+  datasetRegistry.attach(mappedDatasets, orderedDatasets)
+  attachGlobalState(globalState)
+})
+
+datasetRegistry.mockExtend = (extraDatasets) => datasetRegistry.attach(
+  { ...mappedDatasets, ...extraDatasets },
+  [...orderedDatasets, ...Object.keys(extraDatasets)]
+)
+
+export { datasetRegistry }

package/plugins/beta/datasets/src/registry/createDataset.js

@@ -0,0 +1,5 @@
+import { Dataset } from './dataset.js'
+
+export const createDataset = (datasetDefinition) => {
+  return new Dataset(datasetDefinition)
+}

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

@@ -0,0 +1,172 @@
+import { datasetRegistry } from './datasetRegistry.js'
+import { hasCustomVisualStyle } from '../initialise/defaults.js'
+import { hasPattern } from '../../../../../src/utils/patternUtils.js'
+import { DynamicGeoJson } from './dynamicGeoJson.js'
+import { calculateOpacity, getGlobalVisibility } from './globalDataset.js'
+
+export class Dataset {
+  constructor (dataset) {
+    this._datasetDefinition = dataset
+  }
+
+  get id () { return this._datasetDefinition.id }
+  get label () { return this._datasetDefinition.label }
+  get hasSymbol () { return !this.hasSublayers && Boolean(this.style?.symbol) }
+  get hasPattern () { return !this.hasSublayers && !this.hasSymbol && hasPattern(this.style) }
+  get hasFill () { return !this.hasSublayers && !this.hasSymbol && (this.hasPattern || (this.style?.fill && this.style?.fill !== 'transparent')) }
+  get hasStroke () { return !this.hasSublayers && !this.hasSymbol && Boolean(this.style?.stroke) }
+  get tiles () { return this._datasetDefinition.tiles }
+  get geojson () { return this._datasetDefinition.geojson }
+  get idProperty () { return this._datasetDefinition.idProperty }
+  // TODO - handle transformRequest for non-dynamicGeoJSON as well (e.g. to add auth headers) --- IGNORE ---
+  // get transformRequest () { return this._datasetDefinition.transformRequest }
+  get parentId () { return this._datasetDefinition.parentId }
+  get minZoom () { return this._datasetDefinition.minZoom || this.parent?.minZoom }
+  get maxZoom () { return this._datasetDefinition.maxZoom || this.parent?.maxZoom }
+  get showInKey () { return this._datasetDefinition.showInKey || this.parent?.showInKey || false }
+  get groupLabel () { return this._datasetDefinition.groupLabel }
+
+  get opacity () {
+    const myOpacity = this.style?.opacity
+    const parentOpacity = this.parent?.style?.opacity
+    return calculateOpacity(myOpacity, parentOpacity)
+  }
+
+  get hasDynamicGeoJSON () {
+    return Boolean(this._datasetDefinition.dynamicGeoJSON)
+  }
+
+  get dynamicGeoJSON () {
+    return new DynamicGeoJson({
+      ...this._datasetDefinition.dynamicGeoJSON,
+      id: this.id,
+      minZoom: this.minZoom
+    })
+  }
+
+  get hiddenFeatures () { return this._datasetDefinition.hiddenFeatures }
+  get hasHiddenFeatures () { return Boolean(this.hiddenFeatures?.length > 0 || this.parent?.hasHiddenFeatures) }
+
+  get filter () {
+    return null // TODO - implement filter construction for esri and openLayers adapters
+  }
+
+  // Returns true if either the parent (if it has one) or global visibility is hidden , otherwise returns true.
+  // This is used to determine whether to show a tooltip
+  // TODO: also work out how to convey datasets hidden by zoom filter.
+  get isHiddenByInheritance () {
+    if (this.isSublayer) {
+      return !this.parent?.visible
+    }
+    return !getGlobalVisibility()
+  }
+
+  // Returns true if this dataset is visible based on its own visibility setting,
+  // even if globalVisibility is false or its parent is not visible.
+  // This is used to determine whether the dataset is rendered as checked when
+  // disabled in the layers menu.
+  get isLocallyVisible () {
+    if (this.isVisible) {
+      return true
+    }
+    return this._datasetDefinition.visible
+  }
+
+  get visible () {
+    if (this.isSublayer) {
+      return this._datasetDefinition.visible && (this.parent?.visible)
+    }
+    return this._datasetDefinition.visible && getGlobalVisibility()
+  }
+
+  get symbolAnchor () {
+    if (this.style?.symbolAnchor) {
+      return this.style.symbolAnchor
+    }
+    return this.parent?.symbolAnchor
+  }
+
+  get sourceLayer () {
+    if (this.isSublayer) {
+      return this.parent.sourceLayer
+    }
+    if (this.tiles) {
+      return this._datasetDefinition.sourceLayer
+    }
+    return undefined
+  }
+
+  get isSublayer () {
+    return Boolean(this._datasetDefinition.parentId)
+  }
+
+  get hasSublayers () {
+    return this._datasetDefinition.sublayerIds?.length > 0
+  }
+
+  get sublayerIds () {
+    return this._datasetDefinition.sublayerIds
+  }
+
+  get sublayers () {
+    const { sublayerIds } = this
+    if (sublayerIds) {
+      return sublayerIds.map(id => datasetRegistry.getDataset(id))
+    }
+    return undefined
+  }
+
+  get parent () {
+    if (this._datasetDefinition.parentId) {
+      return datasetRegistry.getDataset(this._datasetDefinition.parentId)
+    }
+    return undefined
+  }
+
+  get style () {
+    const parentStyle = this.parent?.style
+    if (parentStyle) {
+      // Here - we must set the merge styles opacity to undefined before the specific child opacity
+      // so that we can correctly calculate opacity in the Dataset.opacity getter
+      // - otherwise if opacity mode multiply is set,
+      // any child with a parent opacity only would be multiplied by itself
+      return {
+        ...parentStyle,
+        opacity: undefined,
+        ...this._datasetDefinition.style,
+        symbolDescription: this.symbolDescription
+      }
+    }
+    return this._datasetDefinition.style || {}
+  }
+
+  get hasCustomVisualStyle () {
+    return hasCustomVisualStyle(this._datasetDefinition.style || {})
+  }
+
+  get symbolDescription () {
+    if (this._datasetDefinition.style?.symbolDescription) {
+      return this._datasetDefinition.style.symbolDescription
+    }
+    if (this.hasCustomVisualStyle) {
+      return undefined
+    }
+    return this.parent?.symbolDescription
+  }
+
+  get patternConfigs () {
+    const stylePatterns = this.hasPattern ? [this.style] : []
+    if (this.hasSublayers) {
+      return [...stylePatterns, ...this.sublayers.flatMap(sublayer => sublayer.patternConfigs)]
+    }
+    return stylePatterns
+  }
+
+  get symbolConfigs () {
+    const styleSymbols = this.hasSymbol ? [this.style] : []
+    if (this.hasSublayers) {
+      return [...styleSymbols, ...this.sublayers.flatMap(sublayer => sublayer.symbolConfigs)]
+    }
+    return styleSymbols
+  }
+}