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

package/plugins/beta/datasets/src/adapters/maplibre/registry/mapLibreDataset.test.js

@@ -0,0 +1,483 @@
+import { MapLibreDataset } from './mapLibreDataset.js'
+import { datasetRegistry } from '../../../registry/datasetRegistry.js'
+import { logger } from '../../../../../../../src/services/logger.js'
+// Use the mock datasetRegistry with the demo datasets attached before each test
+// so we can test Dataset methods that depend on parent/sublayer relationships and styles
+jest.mock('../../../registry/datasetRegistry.js')
+jest.mock('../../../../../../../src/services/logger.js', () => ({
+  logger: { warn: jest.fn() }
+}))
+
+describe('MapLibreDataset', () => {
+  beforeEach(() => {
+    logger.warn.mockClear()
+    datasetRegistry.attachCreateDataset(def => new MapLibreDataset(def))
+    datasetRegistry.mockExtend({
+      // layerIds
+      'ds-fill-only': { id: 'ds-fill-only', visible: true, minZoom: 10, maxZoom: 24, style: { fill: 'blue' } },
+      'ds-pattern-only': { id: 'ds-pattern-only', style: { fillPattern: 'dots' } },
+      'ds-transparent-fill': { id: 'ds-transparent-fill', style: { fill: 'transparent' } },
+      // shared: no special properties — used by layerIds, sourceId, source, visibility,
+      //   _hiddenFeaturesIdExpression, _hiddenFeaturesFilter, and filter tests
+      'ds-bare': { id: 'ds-bare' },
+      'ds-no-id-prop': { id: 'ds-no-id-prop', geojson: 'https://example.com/data', transformRequest: () => {} },
+      'ds-no-transform': { id: 'ds-no-transform', geojson: 'https://example.com/data', idProperty: 'id' },
+      'ds-static-url': { id: 'ds-static-url', geojson: 'https://example.com/static.geojson' },
+      // shared: tiles with no zoom — used by source minzoom and maxzoom fallback tests
+      'ds-tiles-no-zoom': { id: 'ds-tiles-no-zoom', tiles: ['https://example.com/{z}/{x}/{y}'] },
+      // getSymbolSource/getFillSource/getStrokeSource 'has filter' tests use historic-monuments-prehistoric and existing-fields from demo data
+      // _hiddenFeaturesFilter — ds-hf-123 also reused in filter describe
+      'ds-hf-123': { id: 'ds-hf-123', hiddenFeatures: [1, 2, 3] },
+      'ds-hf-neg1': { id: 'ds-hf-neg1', hiddenFeatures: [-1, 5] },
+      'ds-hf-all-neg1': { id: 'ds-hf-all-neg1', hiddenFeatures: [-1] },
+      'ds-hf-empty': { id: 'ds-hf-empty', hiddenFeatures: [] },
+      // filter
+      'ds-combined': { id: 'ds-combined', filter: ['==', ['get', 'type'], 'foo'], hiddenFeatures: [5] },
+      // _geojsonIdStrategy string-id warning
+      'ds-string-ids': { id: 'ds-string-ids', geojson: { type: 'FeatureCollection', features: [{ type: 'Feature', id: 'feature-1', properties: {}, geometry: null }] } },
+      'ds-integer-ids': { id: 'ds-integer-ids', geojson: { type: 'FeatureCollection', features: [{ type: 'Feature', id: 1, properties: {}, geometry: null }] } }
+    })
+  })
+
+  describe('layerIds', () => {
+    it('returns [id] when dataset has a symbol (historic-monuments-prehistoric inherits symbol from parent)', () => {
+      const dataset = datasetRegistry.getDataset('historic-monuments-prehistoric')
+      expect(dataset.layerIds).toEqual(['historic-monuments-prehistoric'])
+    })
+
+    it('returns [id, id-stroke] when dataset has both fill and stroke (existing-fields)', () => {
+      const dataset = datasetRegistry.getDataset('existing-fields')
+      expect(dataset.layerIds).toEqual(['existing-fields', 'existing-fields-stroke'])
+    })
+
+    it('returns [id] when dataset has only fill', () => {
+      const dataset = datasetRegistry.getDataset('ds-fill-only')
+      expect(dataset.layerIds).toEqual(['ds-fill-only'])
+    })
+
+    it('returns [id] when dataset has only stroke (hedge-control)', () => {
+      const dataset = datasetRegistry.getDataset('hedge-control')
+      expect(dataset.layerIds).toEqual(['hedge-control'])
+    })
+
+    it('returns [id] when dataset has a fillPattern but no stroke', () => {
+      const dataset = datasetRegistry.getDataset('ds-pattern-only')
+      expect(dataset.layerIds).toEqual(['ds-pattern-only'])
+    })
+
+    it('returns [id, id-stroke] when dataset has fillPattern and stroke (land-covers-130-131)', () => {
+      const dataset = datasetRegistry.getDataset('land-covers-130-131')
+      expect(dataset.layerIds).toEqual(['land-covers-130-131', 'land-covers-130-131-stroke'])
+    })
+
+    it('returns null when fill is transparent and there is no stroke, symbol, or pattern', () => {
+      const dataset = datasetRegistry.getDataset('ds-transparent-fill')
+      expect(dataset.layerIds).toEqual([])
+    })
+
+    it('returns null when dataset has no fill, stroke, symbol, or pattern', () => {
+      const dataset = datasetRegistry.getDataset('ds-bare')
+      expect(dataset.layerIds).toEqual([])
+    })
+
+    it('returns the combined layerIds from all sublayers (historic-monuments)', () => {
+      const dataset = datasetRegistry.getDataset('historic-monuments')
+      expect(dataset.layerIds).toEqual([
+        'historic-monuments-prehistoric',
+        'historic-monuments-roman',
+        'historic-monuments-medieval'
+      ])
+    })
+
+    it('returns the combined layerIds from all sublayers (land-covers)', () => {
+      const dataset = datasetRegistry.getDataset('land-covers')
+      expect(dataset.layerIds).toEqual([
+        'land-covers-130-131', 'land-covers-130-131-stroke',
+        'land-covers-332', 'land-covers-332-stroke',
+        'land-covers-110', 'land-covers-110-stroke',
+        'land-covers-379', 'land-covers-379-stroke',
+        'land-covers-other', 'land-covers-other-stroke'
+      ])
+    })
+  })
+
+  describe('visibility', () => {
+    it('returns "visible" when visible is true', () => {
+      expect(datasetRegistry.getDataset('existing-fields').visibility).toBe('visible')
+    })
+
+    it('returns "none" when visible is false', () => {
+      expect(datasetRegistry.getDataset('hedge-control').visibility).toBe('none')
+    })
+  })
+
+  describe('getLayersWithVisibility', () => {
+    it('returns layerIds and visibility for a layer with sublayers', () => {
+      const registryDataset = datasetRegistry.getDataset('land-covers')
+      const layersWithVisibility = registryDataset.getLayersWithVisibility()
+      expect(layersWithVisibility).toEqual([
+        { layerIds: ['land-covers-130-131', 'land-covers-130-131-stroke'], visibility: 'visible' },
+        { layerIds: ['land-covers-332', 'land-covers-332-stroke'], visibility: 'visible' },
+        { layerIds: ['land-covers-110', 'land-covers-110-stroke'], visibility: 'visible' },
+        { layerIds: ['land-covers-379', 'land-covers-379-stroke'], visibility: 'none' },
+        { layerIds: ['land-covers-other', 'land-covers-other-stroke'], visibility: 'visible' }
+      ])
+    })
+  })
+
+  describe('getLayersWithOpacity', () => {
+    it('returns layerIds and opacity for a sublayer with no sublayers', () => {
+      const dataset = datasetRegistry.getDataset('existing-fields')
+      expect(dataset.getLayersWithOpacity()).toEqual([{ layerIds: ['existing-fields', 'existing-fields-stroke'], opacity: 1 }])
+    })
+
+    it('returns layerIds and opacity for a sublayer', () => {
+      const dataset = datasetRegistry.getDataset('land-covers-130-131')
+      const result = dataset.getLayersWithOpacity()
+      expect(result).toEqual([{ layerIds: ['land-covers-130-131', 'land-covers-130-131-stroke'], opacity: 1 }])
+    })
+
+    it('returns layerIds and opacity for a sublayer with sublayers with specific opacity', () => {
+      const parentDef = { id: 'parent-ds', sublayerIds: ['parent-ds-sub'] }
+      const subDef = { id: 'parent-ds-sub', parentId: 'parent-ds', style: { stroke: '#ff0000', fill: '#00ff00', opacity: 0.75 } }
+      datasetRegistry.attach({ 'parent-ds': parentDef, 'parent-ds-sub': subDef })
+      const dataset = datasetRegistry.getDataset('parent-ds')
+      const result = dataset.getLayersWithOpacity()
+      expect(result).toEqual([{ layerIds: ['parent-ds-sub', 'parent-ds-sub-stroke'], opacity: 0.75 }])
+    })
+
+    it('returns layerIds and opacity for all sublayers', () => {
+      const dataset = datasetRegistry.getDataset('historic-monuments')
+      expect(dataset.getLayersWithOpacity()).toEqual([
+        { layerIds: ['historic-monuments-prehistoric'], opacity: 1 },
+        { layerIds: ['historic-monuments-roman'], opacity: 1 },
+        { layerIds: ['historic-monuments-medieval'], opacity: 1 }
+      ])
+    })
+  })
+
+  describe('fillLayerId, strokeLayerId, symbolLayerId — hasSublayers returns null', () => {
+    it('fillLayerId returns null for a dataset with sublayers', () => {
+      const dataset = datasetRegistry.getDataset('land-covers')
+      expect(dataset.fillLayerId).toBeNull()
+    })
+
+    it('strokeLayerId returns null for a dataset with sublayers', () => {
+      const dataset = datasetRegistry.getDataset('land-covers')
+      expect(dataset.strokeLayerId).toBeNull()
+    })
+
+    it('symbolLayerId returns null for a dataset with sublayers', () => {
+      const dataset = datasetRegistry.getDataset('land-covers')
+      expect(dataset.symbolLayerId).toBeNull()
+    })
+  })
+
+  describe('getLayersWithFilters', () => {
+    it('returns an empty array when there are no hidden features and no sublayers', () => {
+      const dataset = datasetRegistry.getDataset('existing-fields')
+      expect(dataset.getLayersWithFilters()).toEqual([])
+    })
+
+    it('returns an entry with layerIds and filter when the dataset has hidden features', () => {
+      const dataset = datasetRegistry.getDataset('land-covers-130-131')
+      expect(dataset.getLayersWithFilters()).toEqual([{
+        layerIds: ['land-covers-130-131', 'land-covers-130-131-stroke'],
+        filter: ['all',
+          ['!', ['in', ['to-string', ['get', 'id']], ['literal', ['42']]]],
+          ['in', ['get', 'dominant_land_cover'], ['literal', ['130', '131']]]]
+      }])
+    })
+
+    it('includes sublayer entries when a sublayer has hidden features', () => {
+      const parentDef = { id: 'parent-ds', sublayerIds: ['parent-ds-sub'] }
+      const subDef = { id: 'parent-ds-sub', parentId: 'parent-ds', hiddenFeatures: [7], style: { stroke: '#ff0000', fill: '#00ff00' } }
+      datasetRegistry.attach({ 'parent-ds': parentDef, 'parent-ds-sub': subDef })
+      const dataset = datasetRegistry.getDataset('parent-ds')
+      expect(dataset.getLayersWithFilters()).toEqual([{
+        layerIds: ['parent-ds-sub', 'parent-ds-sub-stroke'],
+        filter: ['!', ['in', ['to-string', ['id']], ['literal', ['7']]]]
+      }])
+    })
+
+    it('returns an empty array when sublayers exist but none have hidden features', () => {
+      const dataset = datasetRegistry.getDataset('historic-monuments')
+      expect(dataset.getLayersWithFilters()).toEqual([])
+    })
+  })
+
+  describe('sourceId', () => {
+    it('returns the parent sourceId for a sublayer', () => {
+      const sublayer = datasetRegistry.getDataset('land-covers-130-131')
+      expect(sublayer.sourceId).toBe(datasetRegistry.getDataset('land-covers').sourceId)
+    })
+
+    it('returns a tiles-based id for a tile dataset (array tiles)', () => {
+      const dataset = datasetRegistry.getDataset('existing-fields')
+      expect(dataset.sourceId).toBe('tiles-3delfuv')
+    })
+
+    it('returns a tiles-based id when tiles is a plain string (line 76 non-array branch)', () => {
+      const dataset = datasetRegistry.getDataset('existing-fields')
+      expect(dataset.sourceId).toBe('tiles-3delfuv')
+    })
+
+    it('returns geojson-dynamic-{id} for a dynamic geojson source', () => {
+      expect(datasetRegistry.getDataset('land-covers').sourceId).toBe('geojson-dynamic-land-covers')
+    })
+
+    it('returns geojson-{hash} for a static string geojson url', () => {
+      expect(datasetRegistry.getDataset('ds-static-url').sourceId).toBe('geojson-1u4xay')
+    })
+
+    it('returns geojson-{id} for an object geojson source', () => {
+      const dataset = datasetRegistry.getDataset('historic-monuments')
+      expect(dataset.sourceId).toBe('geojson-historic-monuments')
+    })
+
+    it('returns source-{id} when there are no tiles and no geojson', () => {
+      expect(datasetRegistry.getDataset('ds-bare').sourceId).toBe('source-ds-bare')
+    })
+  })
+
+  describe('source', () => {
+    it('returns a vector source for a tile dataset', () => {
+      expect(datasetRegistry.getDataset('existing-fields').source).toEqual({
+        type: 'vector',
+        tiles: 'https://farming-tiles-702a60f45633.herokuapp.com/field_parcels_with_hedges/{z}/{x}/{y}',
+        minzoom: 10,
+        maxzoom: 24
+      })
+    })
+
+    it('falls back to 0/22 for minzoom/maxzoom when zoom is not set', () => {
+      expect(datasetRegistry.getDataset('ds-tiles-no-zoom').source).toEqual({
+        type: 'vector',
+        tiles: ['https://example.com/{z}/{x}/{y}'],
+        minzoom: 0,
+        maxzoom: 22
+      })
+    })
+
+    it('returns a geojson source with promoteId when the dynamic source has idProperty', () => {
+      expect(datasetRegistry.getDataset('land-covers').source).toEqual({
+        type: 'geojson',
+        data: { type: 'FeatureCollection', features: [] },
+        promoteId: 'id'
+      })
+    })
+
+    it('returns a geojson source with promoteId when static geojson has idProperty', () => {
+      expect(datasetRegistry.getDataset('ds-no-transform').source).toEqual({
+        type: 'geojson',
+        data: 'https://example.com/data',
+        promoteId: 'id'
+      })
+    })
+
+    it('returns a geojson source with generateId when generateIds is true', () => {
+      datasetRegistry.mockExtend({ 'ds-generate-ids': { id: 'ds-generate-ids', geojson: 'https://example.com/data', generateIds: true } })
+      expect(datasetRegistry.getDataset('ds-generate-ids').source).toEqual({
+        type: 'geojson',
+        data: 'https://example.com/data',
+        generateId: true
+      })
+    })
+
+    it('returns a plain geojson source with no id strategy when neither idProperty nor generateIds is set', () => {
+      const dataset = datasetRegistry.getDataset('historic-monuments')
+      expect(dataset.source).toEqual({ type: 'geojson', data: dataset.geojson })
+    })
+
+    it('returns null when there are no tiles and no geojson', () => {
+      expect(datasetRegistry.getDataset('ds-bare').source).toBeNull()
+    })
+
+    it('warns when geojson features have string native IDs and no id strategy is set', () => {
+      expect(datasetRegistry.getDataset('ds-string-ids').source).toEqual(expect.objectContaining({ type: 'geojson' }))
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('"ds-string-ids"'))
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('string native IDs'))
+    })
+
+    it('does not warn when geojson features have integer native IDs', () => {
+      expect(datasetRegistry.getDataset('ds-integer-ids').source).toEqual(expect.objectContaining({ type: 'geojson' }))
+      expect(logger.warn).not.toHaveBeenCalled()
+    })
+
+    it('does not warn when idProperty is set even if features have string native IDs', () => {
+      datasetRegistry.mockExtend({ 'ds-string-with-prop': { id: 'ds-string-with-prop', idProperty: 'myId', geojson: { type: 'FeatureCollection', features: [{ type: 'Feature', id: 'f-1', properties: { myId: 1 }, geometry: null }] } } })
+      expect(datasetRegistry.getDataset('ds-string-with-prop').source).toEqual(expect.objectContaining({ type: 'geojson' }))
+      expect(logger.warn).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('getSymbolSource', () => {
+    const prehistoricBase = {
+      id: 'historic-monuments-prehistoric',
+      type: 'symbol',
+      source: 'geojson-historic-monuments',
+      'source-layer': undefined,
+      minzoom: 6, // datasetDefaults.minZoom applied to sublayer (parent's 10 is not inherited)
+      maxzoom: 24,
+      filter: ['in', ['get', 'category'], 'prehistoric']
+    }
+
+    it('returns a symbol layer spec with the correct shape', () => {
+      expect(datasetRegistry.getDataset('historic-monuments-prehistoric').getSymbolSource('my-icon', null, null)).toEqual({
+        ...prehistoricBase,
+        layout: { visibility: 'visible', 'icon-image': 'my-icon', 'icon-anchor': 'center', 'icon-allow-overlap': true }
+      })
+    })
+
+    it('uses the provided anchor when given', () => {
+      expect(datasetRegistry.getDataset('historic-monuments-prehistoric').getSymbolSource('icon', [0.1, 0.9], null)).toEqual({
+        ...prehistoricBase,
+        layout: { visibility: 'visible', 'icon-image': 'icon', 'icon-anchor': 'bottom-left', 'icon-allow-overlap': true }
+      })
+    })
+
+    it('falls back to symbolDef.anchor when no anchor is provided', () => {
+      expect(datasetRegistry.getDataset('historic-monuments-prehistoric').getSymbolSource('icon', null, { anchor: [0.5, 0] })).toEqual({
+        ...prehistoricBase,
+        layout: { visibility: 'visible', 'icon-image': 'icon', 'icon-anchor': 'top', 'icon-allow-overlap': true }
+      })
+    })
+
+    it('does not include a filter property when filter is null', () => {
+      expect(datasetRegistry.getDataset('historic-monuments').getSymbolSource('icon', null, null)).toEqual({
+        id: null,
+        type: 'symbol',
+        source: 'geojson-historic-monuments',
+        'source-layer': undefined,
+        minzoom: 10,
+        maxzoom: 24,
+        layout: { visibility: 'visible', 'icon-image': 'icon', 'icon-anchor': 'center', 'icon-allow-overlap': true }
+      })
+    })
+
+    it('includes a filter property when the dataset has a filter', () => {
+      expect(datasetRegistry.getDataset('historic-monuments-prehistoric').getSymbolSource('icon', null, null)).toEqual({
+        ...prehistoricBase,
+        layout: { visibility: 'visible', 'icon-image': 'icon', 'icon-anchor': 'center', 'icon-allow-overlap': true }
+      })
+    })
+  })
+
+  describe('getFillSource', () => {
+    const fillBase = {
+      id: 'ds-fill-only',
+      type: 'fill',
+      source: 'source-ds-fill-only',
+      'source-layer': undefined,
+      minzoom: 10,
+      maxzoom: 24,
+      layout: { visibility: 'visible' }
+    }
+
+    it('returns a fill layer spec with the correct shape', () => {
+      expect(datasetRegistry.getDataset('ds-fill-only').getFillSource({ 'fill-color': '#ff0000' })).toEqual({
+        ...fillBase,
+        paint: { 'fill-color': '#ff0000' }
+      })
+    })
+
+    it('does not include a filter property when filter is null', () => {
+      expect(datasetRegistry.getDataset('ds-fill-only').getFillSource({})).toEqual({ ...fillBase, paint: {} })
+    })
+
+    it('includes a filter property when the dataset has a filter', () => {
+      expect(datasetRegistry.getDataset('existing-fields').getFillSource({})).toEqual({
+        id: 'existing-fields',
+        type: 'fill',
+        source: 'tiles-3delfuv',
+        'source-layer': 'field_parcels_filtered',
+        minzoom: 10,
+        maxzoom: 24,
+        layout: { visibility: 'visible' },
+        paint: {},
+        filter: ['all', ['==', ['get', 'sbi'], '106223377'], ['==', ['get', 'is_dominant_land_cover'], true]]
+      })
+    })
+  })
+
+  describe('getStrokeSource', () => {
+    it('returns a line layer spec with the correct shape', () => {
+      expect(datasetRegistry.getDataset('hedge-control')
+        .getStrokeSource({ 'line-color': '#ff0000', 'line-width': 2 }))
+        .toEqual({
+          id: 'hedge-control',
+          type: 'line',
+          source: 'tiles-3delfuv',
+          'source-layer': 'hedge_control',
+          minzoom: 10,
+          maxzoom: 24,
+          layout: { visibility: 'none' },
+          paint: { 'line-color': '#ff0000', 'line-width': 2 }
+        })
+    })
+
+    it('includes a filter property when the dataset has a filter', () => {
+      expect(datasetRegistry.getDataset('existing-fields')
+        .getStrokeSource({}))
+        .toEqual({
+          id: 'existing-fields-stroke',
+          type: 'line',
+          source: 'tiles-3delfuv',
+          'source-layer': 'field_parcels_filtered',
+          minzoom: 10,
+          maxzoom: 24,
+          layout: { visibility: 'visible' },
+          paint: {},
+          filter: ['all', ['==', ['get', 'sbi'], '106223377'], ['==', ['get', 'is_dominant_land_cover'], true]]
+        })
+    })
+  })
+
+  describe('_hiddenFeaturesIdExpression', () => {
+    it('uses get(idProperty) when idProperty is set', () => {
+      expect(datasetRegistry.getDataset('land-covers')._hiddenFeaturesIdExpression).toEqual(['to-string', ['get', 'id']])
+    })
+
+    it('uses the feature id when idProperty is not set', () => {
+      expect(datasetRegistry.getDataset('ds-bare')._hiddenFeaturesIdExpression).toEqual(['to-string', ['id']])
+    })
+  })
+
+  describe('filter', () => {
+    it('returns null when there is no filter and no hidden features', () => {
+      expect(datasetRegistry.getDataset('ds-bare').filter).toBeNull()
+    })
+
+    it('returns the own filter directly when it is the only filter', () => {
+      expect(datasetRegistry.getDataset('historic-monuments-prehistoric').filter)
+        .toEqual(['in', ['get', 'category'], 'prehistoric'])
+    })
+
+    it('returns ["all", parentFilter, ownFilter] when both parent and own filter are present', () => {
+      const parentFilter = ['==', ['get', 'cat'], 'a']
+      const childFilter = ['==', ['get', 'sub'], 'b']
+      const parentDef = { id: 'p-filter', filter: parentFilter, sublayerIds: ['p-filter-child'] }
+      const childDef = { id: 'p-filter-child', parentId: 'p-filter', filter: childFilter }
+      datasetRegistry.attach({ 'p-filter': parentDef, 'p-filter-child': childDef })
+      const dataset = datasetRegistry.getDataset('p-filter-child')
+      expect(dataset.filter).toEqual(['all', parentFilter, childFilter])
+    })
+
+    it('returns the hidden features filter directly when it is the only filter', () => {
+      expect(datasetRegistry.getDataset('ds-hf-123').filter)
+        .toEqual(['!', ['in', ['to-string', ['id']], ['literal', ['1', '2', '3']]]])
+    })
+
+    it('returns ["all", ...] when both own filter and hidden features filter are present', () => {
+      const { filter } = datasetRegistry.getDataset('ds-combined')
+      expect(filter).toEqual([
+        'all',
+        ['==', ['get', 'type'], 'foo'],
+        [
+          '!',
+          ['in', ['to-string', ['id']], ['literal', ['5']]]
+        ]
+      ])
+    })
+  })
+})

package/plugins/beta/datasets/src/api/addDataset.js

@@ -1,6 +1,3 @@
-import { datasetDefaults } from '../defaults.js'
-
-export const addDataset = ({ pluginState, mapState }, dataset) => {
-  pluginState.layerAdapter?.addDataset({ ...datasetDefaults, ...dataset }, mapState.mapStyle)
-  pluginState.dispatch({ type: 'ADD_DATASET', payload: { dataset, datasetDefaults } })
+export const addDataset = ({ pluginState: { dispatch }, mapState }, dataset) => {
+  dispatch({ type: 'ADD_DATASET', payload: { dataset, mapStyle: mapState.mapStyle } })
 }

package/plugins/beta/datasets/src/api/addDataset.test.js

@@ -0,0 +1,16 @@
+import { addDataset } from './addDataset.js'
+
+describe('addDataset', () => {
+  it('dispatches ADD_DATASET with the dataset and mapStyle', () => {
+    const dispatch = jest.fn()
+    const dataset = { id: 'my-dataset', label: 'My Dataset' }
+    const mapState = { mapStyle: { version: 8, layers: [] } }
+
+    addDataset({ pluginState: { dispatch }, mapState }, dataset)
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'ADD_DATASET',
+      payload: { dataset, mapStyle: mapState.mapStyle }
+    })
+  })
+})

package/plugins/beta/datasets/src/api/getOpacity.js

@@ -1,17 +1,17 @@
-export const getOpacity = ({ pluginState }, options) => {
-  const { datasetId, sublayerId } = options || {}
+import { logger } from '../../../../../src/services/logger.js'
+import { datasetRegistry } from '../registry/datasetRegistry.js'
 
-  if (sublayerId) {
-    const dataset = pluginState.datasets?.find(d => d.id === datasetId)
-    const sublayer = dataset?.sublayers?.find(s => s.id === sublayerId)
-    return sublayer?.style?.opacity ?? null
+export const getOpacity = ({ pluginState: { globals } }, options = {}) => {
+  const { datasetId, sublayerId } = options
+  const fullId = sublayerId ? `${datasetId}-${sublayerId}` : datasetId
+  if (fullId) {
+    const registryDataset = datasetRegistry.getDataset(fullId)
+    if (!registryDataset) {
+      logger.warn(`getOpacity: Dataset with id ${fullId} not found`)
+      return null
+    }
+    return registryDataset.opacity ?? null
   }
-
-  if (datasetId) {
-    const dataset = pluginState.datasets?.find(d => d.id === datasetId)
-    return dataset?.opacity ?? null
-  }
-
-  // Global — return first dataset's opacity
-  return pluginState.datasets?.[0]?.opacity ?? null
+  // Global
+  return globals.opacity ?? null
 }

package/plugins/beta/datasets/src/api/getOpacity.test.js

@@ -0,0 +1,72 @@
+import { getOpacity } from './getOpacity.js'
+import { datasetRegistry } from '../registry/datasetRegistry.js'
+import { logger } from '../../../../../src/services/logger.js'
+
+jest.mock('../registry/datasetRegistry.js', () => ({
+  datasetRegistry: { getDataset: jest.fn() }
+}))
+
+jest.mock('../../../../../src/services/logger.js', () => ({
+  logger: { warn: jest.fn() }
+}))
+
+describe('getOpacity', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('global (no datasetId)', () => {
+    it('returns globals.opacity when set', () => {
+      const ctx = { pluginState: { globals: { opacity: 0.5 } } }
+      expect(getOpacity(ctx)).toBe(0.5)
+    })
+
+    it('returns null when globals.opacity is undefined', () => {
+      const ctx = { pluginState: { globals: {} } }
+      expect(getOpacity(ctx)).toBeNull()
+    })
+  })
+
+  describe('with datasetId', () => {
+    it('returns opacity from the registry dataset', () => {
+      datasetRegistry.getDataset.mockReturnValue({ opacity: 0.7 })
+      const ctx = { pluginState: { globals: {} } }
+      expect(getOpacity(ctx, { datasetId: 'my-dataset' })).toBe(0.7)
+    })
+
+    it('returns null when the dataset has no opacity property', () => {
+      datasetRegistry.getDataset.mockReturnValue({})
+      const ctx = { pluginState: { globals: {} } }
+      expect(getOpacity(ctx, { datasetId: 'my-dataset' })).toBeNull()
+    })
+
+    it('returns null and warns when the dataset is not found', () => {
+      datasetRegistry.getDataset.mockReturnValue(undefined)
+      const ctx = { pluginState: { globals: {} } }
+      expect(getOpacity(ctx, { datasetId: 'missing' })).toBeNull()
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('missing'))
+    })
+  })
+
+  describe('with sublayerId', () => {
+    it('combines datasetId and sublayerId for the registry lookup', () => {
+      datasetRegistry.getDataset.mockReturnValue({ opacity: 0.3 })
+      const ctx = { pluginState: { globals: {} } }
+      getOpacity(ctx, { datasetId: 'parent', sublayerId: 'child' })
+      expect(datasetRegistry.getDataset).toHaveBeenCalledWith('parent-child')
+    })
+
+    it('returns opacity for the combined id', () => {
+      datasetRegistry.getDataset.mockReturnValue({ opacity: 0.3 })
+      const ctx = { pluginState: { globals: {} } }
+      expect(getOpacity(ctx, { datasetId: 'parent', sublayerId: 'child' })).toBe(0.3)
+    })
+
+    it('returns null and warns when the sublayer dataset is not found', () => {
+      datasetRegistry.getDataset.mockReturnValue(undefined)
+      const ctx = { pluginState: { globals: {} } }
+      expect(getOpacity(ctx, { datasetId: 'parent', sublayerId: 'missing' })).toBeNull()
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('parent-missing'))
+    })
+  })
+})

package/plugins/beta/datasets/src/api/getStyle.js

@@ -1,13 +1,12 @@
+import { logger } from '../../../../../src/services/logger.js'
+import { datasetRegistry } from '../registry/datasetRegistry.js'
+
 export const getStyle = ({ pluginState }, { datasetId, sublayerId } = {}) => {
-  const dataset = pluginState.datasets?.find(d => d.id === datasetId)
-  if (!dataset) {
+  datasetId = sublayerId ? `${datasetId}-${sublayerId}` : datasetId
+  const registryDataset = datasetRegistry.getDataset(datasetId)
+  if (!registryDataset) {
+    logger.warn(`getStyle: Dataset with id ${datasetId} not found`)
     return null
   }
-
-  if (sublayerId) {
-    const sublayer = dataset.sublayers?.find(s => s.id === sublayerId)
-    return sublayer?.style ?? null
-  }
-
-  return dataset.style ?? null
+  return registryDataset.style
 }