@defra/interactive-map 0.0.16-alpha → 0.0.18-alpha

package/plugins/beta/datasets/src/adapters/maplibre/maplibreLayerAdapter.js

@@ -0,0 +1,440 @@
+import { applyExclusionFilter } from '../../utils/filters.js'
+import { getSourceId, getLayerIds, getSublayerLayerIds, getAllLayerIds } from './layerIds.js'
+import { addDatasetLayers, addSublayerLayers } from './layerBuilders.js'
+import { getPatternConfigs } from './patternImages.js'
+import { getSymbolConfigs, getSymbolImageId } from './symbolImages.js'
+import { mergeSublayer } from '../../utils/mergeSublayer.js'
+import { scaleFactor } from '../../../../../../src/config/appConfig.js'
+
+/**
+ * MapLibre GL JS implementation of the LayerAdapter interface for the datasets plugin.
+ *
+ * Owns all map-framework-specific concerns:
+ * - Source and layer creation (delegated to layerBuilders)
+ * - Pattern image registration (delegated to patternRegistry)
+ * - Visibility toggling, feature filtering, style changes
+ * - Style-change recovery (re-adding layers after basemap swap)
+ *
+ * Symbol image rasterisation is delegated to the map provider via
+ * `mapProvider.registerSymbols()`, keeping this adapter free of provider internals.
+ */
+export default class MaplibreLayerAdapter {
+  /**
+   * @param {Object} mapProvider - Map provider instance (e.g. MapLibreProvider)
+   * @param {Object} symbolRegistry
+   * @param {Object} patternRegistry
+   */
+  constructor (mapProvider, symbolRegistry, patternRegistry) {
+    this._mapProvider = mapProvider
+    this._map = mapProvider.map
+    this._symbolRegistry = symbolRegistry
+    this._patternRegistry = patternRegistry
+    // datasetId → sourceId, used by setData to update the correct source
+    this._datasetSourceMap = new Map()
+    // Tracks all active symbol-type layer IDs so non-symbol layers can be kept below them
+    this._symbolLayerIds = new Set()
+  }
+
+  // ─── Lifecycle ──────────────────────────────────────────────────────────────
+
+  /**
+   * Initialise all datasets: register patterns, add layers, then wait for idle.
+   * @param {Object[]} datasets
+   * @param {Object} mapStyle
+   * @returns {Promise<void>} Resolves once the map has processed all layers.
+   */
+  async init (datasets, mapStyle) {
+    const mapStyleId = mapStyle.id
+    const pixelRatio = this._pixelRatio
+    await Promise.all([
+      this._mapProvider.registerPatterns(getPatternConfigs(datasets, this._patternRegistry), mapStyleId, this._patternRegistry),
+      this._mapProvider.registerSymbols(getSymbolConfigs(datasets), mapStyle, this._symbolRegistry)
+    ])
+    this._symbolLayerIds.clear()
+    datasets.forEach(dataset => this._addLayers(dataset, mapStyle, pixelRatio))
+    await new Promise(resolve => this._map.once('idle', resolve))
+  }
+
+  /**
+   * Remove all layers and sources for the given datasets.
+   * @param {Object[]} datasets
+   */
+  destroy (datasets) {
+    const removedSourceIds = new Set()
+    datasets.forEach(dataset => {
+      const sourceId = getSourceId(dataset)
+      this._getLayersUsingSource(sourceId).forEach(layerId => {
+        if (this._map.getLayer(layerId)) {
+          this._map.removeLayer(layerId)
+        }
+      })
+      if (!removedSourceIds.has(sourceId) && this._map.getSource(sourceId)) {
+        this._map.removeSource(sourceId)
+        removedSourceIds.add(sourceId)
+      }
+    })
+    this._datasetSourceMap.clear()
+  }
+
+  /**
+   * Re-register patterns and re-add all layers after a basemap style change,
+   * then reapply cached dynamic source data and hidden-feature filters.
+   * @param {Object[]} datasets
+   * @param {Object} newMapStyle
+   * @param {Object} hiddenFeatures - pluginState.hiddenFeatures
+   * @param {Map} dynamicSources - datasetId → dynamic source instance
+   * @returns {Promise<void>}
+   */
+  async onStyleChange (datasets, newMapStyle, hiddenFeatures, dynamicSources) {
+    // MapLibre wipes all sources/layers on style change — must wait for idle first
+    await new Promise(resolve => this._map.once('idle', resolve))
+
+    const newStyleId = newMapStyle.id
+    const pixelRatio = this._pixelRatio
+    await Promise.all([
+      this._mapProvider.registerPatterns(getPatternConfigs(datasets, this._patternRegistry), newStyleId, this._patternRegistry),
+      this._mapProvider.registerSymbols(getSymbolConfigs(datasets), newMapStyle, this._symbolRegistry)
+    ])
+    this._symbolLayerIds.clear()
+    datasets.forEach(dataset => this._addLayers(dataset, newMapStyle, pixelRatio))
+
+    // Re-push cached data for dynamic sources
+    dynamicSources.forEach(source => source.reapply())
+
+    // Reapply hidden feature filters
+    Object.entries(hiddenFeatures).forEach(([datasetId, { idProperty, ids }]) => {
+      const dataset = datasets.find(d => d.id === datasetId)
+      if (!dataset) {
+        return
+      }
+      this._applyFeatureFilter(dataset, idProperty, ids)
+    })
+  }
+
+  /**
+   * Re-register symbols at the new pixel ratio and update icon-image on all symbol layers.
+   * Called when the map size changes so symbols are rasterised at the correct resolution.
+   * @param {Object[]} datasets
+   * @param {Object} mapStyle
+   * @returns {Promise<void>}
+   */
+  async onSizeChange (datasets, mapStyle) {
+    await this._mapProvider.registerSymbols(getSymbolConfigs(datasets), mapStyle, this._symbolRegistry)
+    const pixelRatio = this._pixelRatio
+    datasets.forEach(dataset => {
+      getAllLayerIds(dataset).forEach(layerId => {
+        if (!this._symbolLayerIds.has(layerId) || !this._map.getLayer(layerId)) { return }
+        const imageId = getSymbolImageId(dataset, mapStyle, this._symbolRegistry, false, pixelRatio)
+        if (imageId) {
+          this._map.setLayoutProperty(layerId, 'icon-image', imageId)
+        }
+      })
+      dataset.sublayers?.forEach(sublayer => {
+        const { symbolLayerId } = getSublayerLayerIds(dataset.id, sublayer.id)
+        if (!this._map.getLayer(symbolLayerId)) { return }
+        const merged = mergeSublayer(dataset, sublayer)
+        const imageId = getSymbolImageId(merged, mapStyle, this._symbolRegistry, false, pixelRatio)
+        if (imageId) {
+          this._map.setLayoutProperty(symbolLayerId, 'icon-image', imageId)
+        }
+      })
+    })
+  }
+
+  // ─── Dataset operations ─────────────────────────────────────────────────────
+
+  /**
+   * Add a single dataset's source and layers to the map.
+   * @param {Object} dataset
+   * @param {Object} mapStyle
+   */
+  addDataset (dataset, mapStyle) {
+    this._addLayers(dataset, mapStyle, this._pixelRatio)
+  }
+
+  /**
+   * Remove a dataset's layers and source from the map.
+   * Shared sources (same tiles URL or geojson URL used by multiple datasets) are
+   * only removed when no other remaining dataset references them.
+   * @param {Object} dataset
+   * @param {Object[]} allDatasets - Full current dataset list, for shared-source check.
+   */
+  removeDataset (dataset, allDatasets) {
+    const sourceId = getSourceId(dataset)
+
+    getAllLayerIds(dataset).forEach(layerId => {
+      if (this._map.getLayer(layerId)) {
+        this._map.removeLayer(layerId)
+      }
+      this._symbolLayerIds.delete(layerId)
+    })
+
+    const sourceIsShared = allDatasets.some(d => d.id !== dataset.id && getSourceId(d) === sourceId)
+
+    if (!sourceIsShared && this._map.getSource(sourceId)) {
+      this._map.removeSource(sourceId)
+    }
+
+    this._datasetSourceMap.delete(dataset.id)
+  }
+
+  /**
+   * Make a dataset's layers visible.
+   * @param {string} datasetId
+   */
+  showDataset (datasetId) {
+    this._setDatasetVisibility(datasetId, 'visible')
+  }
+
+  /**
+   * Hide a dataset's layers.
+   * @param {string} datasetId
+   */
+  hideDataset (datasetId) {
+    this._setDatasetVisibility(datasetId, 'none')
+  }
+
+  /**
+   * Make a single sublayer's layers visible.
+   * @param {string} datasetId
+   * @param {string} sublayerId
+   */
+  showSublayer (datasetId, sublayerId) {
+    const { fillLayerId, strokeLayerId, symbolLayerId } = getSublayerLayerIds(datasetId, sublayerId)
+    ;[fillLayerId, strokeLayerId, symbolLayerId].forEach(layerId => {
+      if (this._map.getLayer(layerId)) {
+        this._map.setLayoutProperty(layerId, 'visibility', 'visible')
+      }
+    })
+  }
+
+  /**
+   * Hide a single sublayer's layers.
+   * @param {string} datasetId
+   * @param {string} sublayerId
+   */
+  hideSublayer (datasetId, sublayerId) {
+    const { fillLayerId, strokeLayerId, symbolLayerId } = getSublayerLayerIds(datasetId, sublayerId)
+    ;[fillLayerId, strokeLayerId, symbolLayerId].forEach(layerId => {
+      if (this._map.getLayer(layerId)) {
+        this._map.setLayoutProperty(layerId, 'visibility', 'none')
+      }
+    })
+  }
+
+  // ─── Feature operations ─────────────────────────────────────────────────────
+
+  /**
+   * Show previously hidden features by updating the layer exclusion filter.
+   * @param {Object} dataset
+   * @param {string} idProperty
+   * @param {Array} remainingHiddenIds - IDs that should remain hidden after this call.
+   */
+  showFeatures (dataset, idProperty, remainingHiddenIds) {
+    this._applyFeatureFilter(dataset, idProperty, remainingHiddenIds)
+  }
+
+  /**
+   * Hide features by updating the layer exclusion filter.
+   * @param {Object} dataset
+   * @param {string} idProperty
+   * @param {Array} allHiddenIds - Full set of IDs to hide (existing + new).
+   */
+  hideFeatures (dataset, idProperty, allHiddenIds) {
+    this._applyFeatureFilter(dataset, idProperty, allHiddenIds)
+  }
+
+  /**
+   * Update a dataset's style and re-render all its layers.
+   * @param {Object} dataset - Updated dataset (style changes already merged in)
+   * @param {Object} mapStyle
+   * @returns {Promise<void>}
+   */
+  async setStyle (dataset, mapStyle) {
+    const mapStyleId = mapStyle.id
+    const pixelRatio = this._pixelRatio
+    getAllLayerIds(dataset).forEach(layerId => {
+      if (this._map.getLayer(layerId)) {
+        this._map.removeLayer(layerId)
+      }
+      this._symbolLayerIds.delete(layerId)
+    })
+    await Promise.all([
+      this._mapProvider.registerPatterns(getPatternConfigs([dataset], this._patternRegistry), mapStyleId, this._patternRegistry),
+      this._mapProvider.registerSymbols(getSymbolConfigs([dataset]), mapStyle, this._symbolRegistry)
+    ])
+    this._addLayers(dataset, mapStyle, pixelRatio)
+  }
+
+  /**
+   * Update a single sublayer's style and re-render its layers.
+   * @param {Object} dataset - Updated dataset (sublayer style changes already merged in)
+   * @param {string} sublayerId
+   * @param {Object} mapStyle
+   * @returns {Promise<void>}
+   */
+  async setSublayerStyle (dataset, sublayerId, mapStyle) {
+    const mapStyleId = mapStyle.id
+    const pixelRatio = this._pixelRatio
+    const { fillLayerId, strokeLayerId, symbolLayerId } = getSublayerLayerIds(dataset.id, sublayerId)
+    ;[fillLayerId, strokeLayerId, symbolLayerId].forEach(layerId => {
+      if (this._map.getLayer(layerId)) {
+        this._map.removeLayer(layerId)
+      }
+      this._symbolLayerIds.delete(layerId)
+    })
+    const sublayer = dataset.sublayers?.find(s => s.id === sublayerId)
+    if (!sublayer) {
+      return
+    }
+    await Promise.all([
+      this._mapProvider.registerPatterns(getPatternConfigs([dataset], this._patternRegistry), mapStyleId, this._patternRegistry),
+      this._mapProvider.registerSymbols(getSymbolConfigs([dataset]), mapStyle, this._symbolRegistry)
+    ])
+    const sourceId = this._datasetSourceMap.get(dataset.id)
+    const sourceLayer = dataset.tiles?.length ? dataset.sourceLayer : undefined
+    addSublayerLayers(this._map, dataset, sublayer, sourceId, sourceLayer, { mapStyle, symbolRegistry: this._symbolRegistry, patternRegistry: this._patternRegistry, pixelRatio })
+    this._maintainSymbolOrdering(dataset)
+  }
+
+  /**
+   * Set opacity for all layers belonging to a dataset.
+   * Uses setPaintProperty directly — safe to call on every slider tick.
+   * @param {string} datasetId
+   * @param {number} opacity
+   */
+  setOpacity (datasetId, opacity) {
+    const style = this._map.getStyle()
+    if (!style?.layers) {
+      return
+    }
+    style.layers
+      .filter(layer => layer.id === datasetId || layer.id.startsWith(`${datasetId}-`))
+      .forEach(layer => this._setPaintOpacity(layer.id, opacity))
+  }
+
+  /**
+   * Set opacity for a single sublayer's fill and stroke layers.
+   * Uses setPaintProperty directly — safe to call on every slider tick.
+   * @param {string} datasetId
+   * @param {string} sublayerId
+   * @param {number} opacity
+   */
+  setSublayerOpacity (datasetId, sublayerId, opacity) {
+    const { fillLayerId, strokeLayerId } = getSublayerLayerIds(datasetId, sublayerId)
+    this._setPaintOpacity(fillLayerId, opacity)
+    this._setPaintOpacity(strokeLayerId, opacity)
+  }
+
+  /**
+   * Update the GeoJSON data for a dataset's source.
+   * @param {string} datasetId
+   * @param {Object} geojson - GeoJSON FeatureCollection
+   */
+  setData (datasetId, geojson) {
+    const sourceId = this._datasetSourceMap.get(datasetId)
+    if (!sourceId) {
+      return
+    }
+    const source = this._map.getSource(sourceId)
+    if (source && typeof source.setData === 'function') {
+      source.setData(geojson)
+    }
+  }
+
+  // ─── Private ─────────────────────────────────────────────────────────────────
+
+  get _pixelRatio () {
+    return this._mapProvider.map.getPixelRatio() * (scaleFactor[this._mapProvider.mapSize] || 1)
+  }
+
+  _addLayers (dataset, mapStyle, pixelRatio) {
+    const sourceId = addDatasetLayers(this._map, dataset, mapStyle, this._symbolRegistry, this._patternRegistry, pixelRatio)
+    this._datasetSourceMap.set(dataset.id, sourceId)
+    this._maintainSymbolOrdering(dataset)
+  }
+
+  _getFirstSymbolLayerId () {
+    const style = this._map.getStyle()
+    if (!style?.layers) {
+      return null
+    }
+    const layer = style.layers.find(l => this._symbolLayerIds.has(l.id))
+    return layer?.id ?? null
+  }
+
+  _maintainSymbolOrdering (dataset) {
+    const layerIds = getAllLayerIds(dataset).filter(id => id && this._map.getLayer(id))
+    layerIds.forEach(id => {
+      if (this._map.getLayer(id)?.type === 'symbol') {
+        this._symbolLayerIds.add(id)
+      } else {
+        this._symbolLayerIds.delete(id)
+      }
+    })
+    const firstSymbolId = this._getFirstSymbolLayerId()
+    if (!firstSymbolId) {
+      return
+    }
+    layerIds.forEach(id => {
+      if (!this._symbolLayerIds.has(id)) {
+        this._map.moveLayer(id, firstSymbolId)
+      }
+    })
+  }
+
+  _setDatasetVisibility (datasetId, visibility) {
+    const style = this._map.getStyle()
+    if (!style?.layers) {
+      return
+    }
+    // Covers base fill layer (datasetId) and all suffixed layers
+    // (-stroke, -${sublayerId}, -${sublayerId}-stroke) without needing the dataset object.
+    style.layers
+      .filter(layer =>
+        layer.id === datasetId ||
+        layer.id.startsWith(`${datasetId}-`)
+      )
+      .forEach(layer => this._map.setLayoutProperty(layer.id, 'visibility', visibility))
+  }
+
+  _applyFeatureFilter (dataset, idProperty, excludeIds) {
+    if (dataset.sublayers?.length) {
+      dataset.sublayers.forEach(sublayer => {
+        const { fillLayerId: subFillId, strokeLayerId: subStrokeId } = getSublayerLayerIds(dataset.id, sublayer.id)
+        const sublayerFilter = dataset.filter && sublayer.filter
+          ? ['all', dataset.filter, sublayer.filter]
+          : (sublayer.filter || dataset.filter || null)
+        applyExclusionFilter(this._map, subFillId, sublayerFilter, idProperty, excludeIds)
+        applyExclusionFilter(this._map, subStrokeId, sublayerFilter, idProperty, excludeIds)
+      })
+      return
+    }
+    const { fillLayerId, strokeLayerId, symbolLayerId } = getLayerIds(dataset)
+    const originalFilter = dataset.filter || null
+    const layerIds = [fillLayerId, strokeLayerId, symbolLayerId].filter(Boolean)
+    layerIds.forEach(layerId => {
+      applyExclusionFilter(this._map, layerId, originalFilter, idProperty, excludeIds)
+    })
+  }
+
+  _setPaintOpacity (layerId, opacity) {
+    const layer = this._map.getLayer(layerId)
+    if (!layer) {
+      return
+    }
+    const opacityProps = { line: 'line-opacity', symbol: 'icon-opacity' }
+    const prop = opacityProps[layer.type] || 'fill-opacity'
+    this._map.setPaintProperty(layerId, prop, opacity)
+  }
+
+  _getLayersUsingSource (sourceId) {
+    const style = this._map.getStyle()
+    if (!style?.layers) {
+      return []
+    }
+    return style.layers
+      .filter(layer => layer.source === sourceId)
+      .map(layer => layer.id)
+  }
+}

package/plugins/beta/datasets/src/adapters/maplibre/patternImages.js

@@ -0,0 +1,27 @@
+// Re-export pure pattern utilities from core — no map engine dependency.
+import { hasPattern } from '../../../../../../src/utils/patternUtils.js'
+import { mergeSublayer } from '../../utils/mergeSublayer.js'
+
+export { hasPattern, getPatternInnerContent, getPatternImageId, getKeyPatternPaths, injectColors } from '../../../../../../src/utils/patternUtils.js'
+
+/**
+ * Returns a flat list of datasets and merged sublayers that require pattern images.
+ * Handles sublayer merging so callers (e.g. mapProvider.registerPatterns) receive ready-to-use configs.
+ *
+ * @param {Object[]} datasets
+ * @param {Object} patternRegistry
+ * @returns {Object[]}
+ */
+export const getPatternConfigs = (datasets, patternRegistry) =>
+  datasets.flatMap(dataset => {
+    const configs = hasPattern(dataset) ? [dataset] : []
+    if (dataset.sublayers?.length) {
+      dataset.sublayers.forEach(sublayer => {
+        const merged = mergeSublayer(dataset, sublayer)
+        if (hasPattern(merged)) {
+          configs.push(merged)
+        }
+      })
+    }
+    return configs
+  })

package/plugins/beta/datasets/src/adapters/maplibre/symbolImages.js

@@ -0,0 +1,31 @@
+// Re-export pure symbol resolution utilities from core — no map engine dependency.
+import { hasSymbol } from '../../../../../../src/utils/symbolUtils.js'
+import { mergeSublayer } from '../../utils/mergeSublayer.js'
+
+export { hasSymbol, getSymbolDef, getSymbolStyleColors, getSymbolViewBox, getSymbolAnchor } from '../../../../../../src/utils/symbolUtils.js'
+
+// Re-export MapLibre-specific symbol utilities from the provider.
+// This is the single cross-boundary import in the adapter; in a separate-package
+// setup this would be: '@interactive-map/maplibre-provider/utils/symbolImages'
+export { anchorToMaplibre, getSymbolImageId } from '../../../../../../providers/maplibre/src/utils/symbolImages.js'
+
+/**
+ * Returns a flat list of datasets and merged sublayers that require symbol images.
+ * Handles sublayer merging so callers (e.g. mapProvider.registerSymbols) receive ready-to-use configs.
+ *
+ * @param {Object[]} datasets
+ * @returns {Object[]}
+ */
+export const getSymbolConfigs = (datasets) =>
+  datasets.flatMap(dataset => {
+    const configs = hasSymbol(dataset) ? [dataset] : []
+    if (dataset.sublayers?.length) {
+      dataset.sublayers.forEach(sublayer => {
+        const merged = mergeSublayer(dataset, sublayer)
+        if (hasSymbol(merged)) {
+          configs.push(merged)
+        }
+      })
+    }
+    return configs
+  })

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

@@ -1,12 +1,6 @@
 import { datasetDefaults } from '../defaults.js'
-import { addMapLayers } from '../mapLayers.js'
 
-export const addDataset = ({ mapProvider, mapState, pluginState }, dataset) => {
-  const map = mapProvider.map
-
-  // Add source and layers to the map
-  addMapLayers(map, mapState.mapStyle.id, { ...datasetDefaults, ...dataset })
-
-  // Update state
+export const addDataset = ({ pluginState, mapState }, dataset) => {
+  pluginState.layerAdapter?.addDataset({ ...datasetDefaults, ...dataset }, mapState.mapStyle)
   pluginState.dispatch({ type: 'ADD_DATASET', payload: { dataset, datasetDefaults } })
 }

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

@@ -0,0 +1,17 @@
+export const getOpacity = ({ pluginState }, options) => {
+  const { datasetId, sublayerId } = options || {}
+
+  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
+  }
+
+  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
+}

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

@@ -0,0 +1,13 @@
+export const getStyle = ({ pluginState }, { datasetId, sublayerId } = {}) => {
+  const dataset = pluginState.datasets?.find(d => d.id === datasetId)
+  if (!dataset) {
+    return null
+  }
+
+  if (sublayerId) {
+    const sublayer = dataset.sublayers?.find(s => s.id === sublayerId)
+    return sublayer?.style ?? null
+  }
+
+  return dataset.style ?? null
+}

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

@@ -1,51 +1,9 @@
-import { getSourceId } from '../mapLayers.js'
-
-const getLayerIds = (dataset) => {
-  const hasFill = !!dataset.fill
-  const hasStroke = !!dataset.stroke
-
-  const fillLayerId = hasFill ? dataset.id : null
-  let strokeLayerId = null
-  if (hasStroke) {
-    if (hasFill) {
-      strokeLayerId = `${dataset.id}-stroke`
-    } else {
-      strokeLayerId = dataset.id
-    }
-  }
-
-  return { fillLayerId, strokeLayerId }
-}
-
-export const removeDataset = ({ mapProvider, pluginState }, datasetId) => {
-  const map = mapProvider.map
-
-  // Find the dataset
+export const removeDataset = ({ pluginState }, datasetId) => {
   const dataset = pluginState.datasets?.find(d => d.id === datasetId)
   if (!dataset) {
     return
   }
 
-  // Compute layer IDs
-  const { fillLayerId, strokeLayerId } = getLayerIds(dataset)
-  const sourceId = getSourceId(dataset)
-
-  // Remove layers first
-  const layerIdsToRemove = [strokeLayerId, fillLayerId]
-  layerIdsToRemove.forEach(layerId => {
-    if (layerId && map.getLayer(layerId)) {
-      map.removeLayer(layerId)
-    }
-  })
-
-  // Remove source if no other datasets use it
-  const otherDatasetsUseSource = pluginState.datasets?.some(
-    d => d.id !== datasetId && getSourceId(d) === sourceId
-  )
-  if (!otherDatasetsUseSource && map.getSource(sourceId)) {
-    map.removeSource(sourceId)
-  }
-
-  // Update plugin state
+  pluginState.layerAdapter?.removeDataset(dataset, pluginState.datasets)
   pluginState.dispatch({ type: 'REMOVE_DATASET', payload: { id: datasetId } })
 }

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

@@ -0,0 +1,10 @@
+import { logger } from '../../../../../src/services/logger.js'
+
+export const setData = ({ pluginState }, geojson, { datasetId }) => {
+  const dataset = pluginState.datasets?.find(d => d.id === datasetId)
+  if (dataset?.tiles) {
+    logger.warn(`setData called on vector tile dataset "${datasetId}" — has no effect`)
+    return
+  }
+  pluginState.layerAdapter?.setData(datasetId, geojson)
+}

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

@@ -0,0 +1,37 @@
+export const setDatasetVisibility = ({ pluginState }, visible, options = {}) => {
+  const { datasetId, sublayerId } = options
+
+  if (sublayerId) {
+    const visibility = visible ? 'visible' : 'hidden'
+    pluginState.layerAdapter?.[visible ? 'showSublayer' : 'hideSublayer'](datasetId, sublayerId)
+    pluginState.dispatch({ type: 'SET_SUBLAYER_VISIBILITY', payload: { datasetId, sublayerId, visibility } })
+    return
+  }
+
+  if (datasetId) {
+    pluginState.layerAdapter?.[visible ? 'showDataset' : 'hideDataset'](datasetId)
+    pluginState.dispatch({ type: 'SET_DATASET_VISIBILITY', payload: { id: datasetId, visibility: visible ? 'visible' : 'hidden' } })
+    if (visible) {
+      const dataset = pluginState.datasets?.find(d => d.id === datasetId)
+      Object.entries(dataset?.sublayerVisibility || {}).forEach(([subId, vis]) => {
+        if (vis === 'hidden') {
+          pluginState.layerAdapter?.hideSublayer(datasetId, subId)
+        }
+      })
+    }
+    return
+  }
+
+  // Global
+  pluginState.dispatch({ type: 'SET_GLOBAL_VISIBILITY', payload: { visibility: visible ? 'visible' : 'hidden' } })
+  pluginState.datasets?.forEach(dataset => {
+    pluginState.layerAdapter?.[visible ? 'showDataset' : 'hideDataset'](dataset.id)
+    if (visible) {
+      Object.entries(dataset.sublayerVisibility || {}).forEach(([subId, vis]) => {
+        if (vis === 'hidden') {
+          pluginState.layerAdapter?.hideSublayer(dataset.id, subId)
+        }
+      })
+    }
+  })
+}

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

@@ -0,0 +1,22 @@
+export const setFeatureVisibility = ({ pluginState }, visible, featureIds, { datasetId, idProperty = null } = {}) => {
+  const dataset = pluginState.datasets?.find(d => d.id === datasetId)
+  if (!dataset) {
+    return
+  }
+
+  if (visible) {
+    const existingHidden = pluginState.hiddenFeatures[datasetId]
+    if (!existingHidden) {
+      return
+    }
+    const remainingHiddenIds = existingHidden.ids.filter(id => !featureIds.includes(id))
+    pluginState.dispatch({ type: 'SHOW_FEATURES', payload: { layerId: datasetId, featureIds } })
+    pluginState.layerAdapter?.showFeatures(dataset, idProperty, remainingHiddenIds)
+  } else {
+    const existingHidden = pluginState.hiddenFeatures[datasetId]
+    const existingIds = existingHidden?.ids || []
+    const allHiddenIds = [...new Set([...existingIds, ...featureIds])]
+    pluginState.dispatch({ type: 'HIDE_FEATURES', payload: { layerId: datasetId, idProperty, featureIds } })
+    pluginState.layerAdapter?.hideFeatures(dataset, idProperty, allHiddenIds)
+  }
+}