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

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

@@ -1,159 +1,83 @@
 import { getValueForStyle } from '../../../../../../src/utils/getValueForStyle.js'
-import { hasPattern } from './patternImages.js'
-import { mergeSublayer } from '../../utils/mergeSublayer.js'
-import { getSourceId, getLayerIds, getSublayerLayerIds, isDynamicSource, MAX_TILE_ZOOM } from './layerIds.js'
-import { hasSymbol, getSymbolAnchor, anchorToMaplibre } from './symbolImages.js'
-
-// ─── Source ───────────────────────────────────────────────────────────────────
-
-export const addSource = (map, dataset, sourceId) => {
-  if (map.getSource(sourceId)) {
-    return
-  }
-  if (dataset.tiles) {
-    map.addSource(sourceId, {
-      type: 'vector',
-      tiles: dataset.tiles,
-      minzoom: dataset.minZoom || 0,
-      maxzoom: dataset.maxZoom || MAX_TILE_ZOOM
-    })
-    return
-  }
-  if (dataset.geojson) {
-    const initialData = isDynamicSource(dataset)
-      ? { type: 'FeatureCollection', features: [] }
-      : dataset.geojson
-    map.addSource(sourceId, { type: 'geojson', data: initialData, generateId: true })
-  }
-}
+import { getSymbolAnchor } from '../../../../../../src/utils/symbolUtils.js'
 
 // ─── Fill layer ───────────────────────────────────────────────────────────────
 
-export const addFillLayer = (map, config, layerId, sourceId, sourceLayer, visibility, { mapStyleId, patternRegistry, pixelRatio = 1 }) => {
-  if (!layerId || map.getLayer(layerId)) {
+export const addFillLayer = (map, registryDataset, mapStyleId, patternRegistry, pixelRatio = 1) => {
+  const { hasFill, fillLayerId } = registryDataset
+  if (!(hasFill && fillLayerId) || map.getLayer(fillLayerId)) {
     return
   }
-  if (!config.fill && !hasPattern(config)) {
-    return
-  }
-  const patternImageId = hasPattern(config) ? patternRegistry.getPatternImageId(config, mapStyleId, pixelRatio) : null
+  const patternImageId = patternRegistry.getPatternImageId(registryDataset.style, mapStyleId, pixelRatio)
   const paint = patternImageId
-    ? { 'fill-pattern': patternImageId, 'fill-opacity': config.opacity || 1 }
-    : { 'fill-color': getValueForStyle(config.fill, mapStyleId), 'fill-opacity': config.opacity || 1 }
-  map.addLayer({
-    id: layerId,
-    type: 'fill',
-    source: sourceId,
-    'source-layer': sourceLayer,
-    minzoom: config.minZoom,
-    maxzoom: config.maxZoom,
-    layout: { visibility },
-    paint,
-    ...(config.filter ? { filter: config.filter } : {})
-  })
+    ? { 'fill-pattern': patternImageId, 'fill-opacity': registryDataset.opacity }
+    : { 'fill-color': getValueForStyle(registryDataset.style.fill, mapStyleId), 'fill-opacity': registryDataset.opacity }
+  map.addLayer(registryDataset.getFillSource(paint))
 }
 
 // ─── Stroke layer ─────────────────────────────────────────────────────────────
 
-export const addStrokeLayer = (map, config, layerId, sourceId, sourceLayer, visibility, mapStyleId) => {
-  if (!layerId || !config.stroke || map.getLayer(layerId)) {
+export const addStrokeLayer = (map, registryDataset, mapStyleId) => {
+  const { hasStroke, strokeLayerId } = registryDataset
+
+  if (!hasStroke || map.getLayer(strokeLayerId)) {
     return
   }
-  map.addLayer({
-    id: layerId,
-    type: 'line',
-    source: sourceId,
-    'source-layer': sourceLayer,
-    minzoom: config.minZoom,
-    maxzoom: config.maxZoom,
-    layout: { visibility },
-    paint: {
-      'line-color': getValueForStyle(config.stroke, mapStyleId),
-      'line-width': config.strokeWidth || 1,
-      'line-opacity': config.opacity || 1,
-      ...(config.strokeDashArray ? { 'line-dasharray': config.strokeDashArray } : {})
-    },
-    ...(config.filter ? { filter: config.filter } : {})
-  })
+  const paint = {
+    'line-color': getValueForStyle(registryDataset.style.stroke, mapStyleId),
+    'line-width': registryDataset.style.strokeWidth || 1,
+    'line-opacity': registryDataset.opacity,
+    ...(registryDataset.style.strokeDashArray ? { 'line-dasharray': registryDataset.style.strokeDashArray } : {})
+  }
+  const strokeSource = registryDataset.getStrokeSource(paint)
+  map.addLayer(strokeSource)
 }
 
 // ─── Symbol layer ─────────────────────────────────────────────────────────────
 
-export const addSymbolLayer = (map, dataset, layerId, sourceId, sourceLayer, visibility, { mapStyle, symbolRegistry, pixelRatio }) => {
-  if (!layerId || map.getLayer(layerId)) { return }
-  const symbolDef = symbolRegistry.getSymbolDef(dataset)
+export const addSymbolLayer = (map, registryDataset, mapStyle, symbolRegistry, pixelRatio) => {
+  const { hasSymbol, symbolLayerId } = registryDataset
+  if (!hasSymbol || !symbolRegistry || !symbolLayerId || map.getLayer(symbolLayerId)) { return }
+  const symbolDef = symbolRegistry.getSymbolDef(registryDataset.style)
   if (!symbolDef) { return }
-  const imageId = symbolRegistry.getSymbolImageId(dataset, mapStyle, false, pixelRatio)
+  const imageId = symbolRegistry.getSymbolImageId(registryDataset.style, mapStyle, false, pixelRatio)
   if (!imageId) { return }
-  const anchor = getSymbolAnchor(dataset, symbolDef)
-  map.addLayer({
-    id: layerId,
-    type: 'symbol',
-    source: sourceId,
-    'source-layer': sourceLayer,
-    minzoom: dataset.minZoom,
-    maxzoom: dataset.maxZoom,
-    layout: {
-      visibility,
-      'icon-image': imageId,
-      'icon-anchor': anchorToMaplibre(anchor),
-      'icon-allow-overlap': true
-    },
-    ...(dataset.filter ? { filter: dataset.filter } : {})
-  })
+  const anchor = getSymbolAnchor(registryDataset.style, symbolDef)
+  map.addLayer(registryDataset.getSymbolSource(imageId, anchor, symbolDef))
 }
 
 // ─── Dataset layers ───────────────────────────────────────────────────────────
 
-export const addSublayerLayers = (map, dataset, sublayer, sourceId, sourceLayer, { mapStyle, symbolRegistry, patternRegistry, pixelRatio }) => {
-  const mapStyleId = mapStyle.id
-  const merged = mergeSublayer(dataset, sublayer)
-  const { fillLayerId, strokeLayerId, symbolLayerId } = getSublayerLayerIds(dataset.id, sublayer.id)
-  const parentHidden = dataset.visibility === 'hidden'
-  const sublayerHidden = dataset.sublayerVisibility?.[sublayer.id] === 'hidden'
-  const visibility = (parentHidden || sublayerHidden) ? 'none' : 'visible'
-  if (hasSymbol(merged) && symbolRegistry) {
-    addSymbolLayer(map, merged, symbolLayerId, sourceId, sourceLayer, visibility, { mapStyle, symbolRegistry, pixelRatio })
-    return
-  }
-  addFillLayer(map, merged, fillLayerId, sourceId, sourceLayer, visibility, { mapStyleId, patternRegistry, pixelRatio })
-  addStrokeLayer(map, merged, strokeLayerId, sourceId, sourceLayer, visibility, mapStyleId)
-}
-
 /**
  * Add all layers (and source if needed) for a dataset.
  * Returns the sourceId so the caller can track the datasetId → sourceId mapping.
  * @param {Object} map - MapLibre map instance
- * @param {Object} dataset
+ * @param {Object} registryDataset
  * @param {Object} mapStyle - Current map style config (provides id, selectedColor, haloColor)
- * @param {Object} [symbolRegistry]
- * @param {Object} [patternRegistry]
- * @param {number} [pixelRatio] - Device pixel ratio × map size scale factor
+ * @param {Object} symbolRegistry
+ * @param {Object} patternRegistry
+ * @param {number} pixelRatio - Device pixel ratio × map size scale factor
  * @returns {string} sourceId
  */
-export const addDatasetLayers = (map, dataset, mapStyle, symbolRegistry, patternRegistry, pixelRatio) => {
+export const addDatasetLayers = (map, registryDataset, mapStyle, symbolRegistry, patternRegistry, pixelRatio) => {
+  const { sourceId, source } = registryDataset
+  if (source && !map.getSource(sourceId)) {
+    map.addSource(sourceId, source)
+  }
   const mapStyleId = mapStyle.id
-  const sourceId = getSourceId(dataset)
-  addSource(map, dataset, sourceId)
-
-  const sourceLayer = dataset.tiles?.length ? dataset.sourceLayer : undefined
+  addSymbolLayer(map, registryDataset, mapStyle, symbolRegistry, pixelRatio)
+  addFillLayer(map, registryDataset, mapStyleId, patternRegistry, pixelRatio)
+  addStrokeLayer(map, registryDataset, mapStyleId)
 
-  if (dataset.sublayers?.length) {
-    dataset.sublayers.forEach(sublayer => {
-      addSublayerLayers(map, dataset, sublayer, sourceId, sourceLayer, { mapStyle, symbolRegistry, patternRegistry, pixelRatio })
+  if (registryDataset.sublayers?.length) {
+    registryDataset.sublayers.forEach(sublayer => {
+      addDatasetLayers(map, sublayer, mapStyle, symbolRegistry, patternRegistry, pixelRatio)
     })
     return sourceId
   }
 
-  const { fillLayerId, strokeLayerId, symbolLayerId } = getLayerIds(dataset)
-  const visibility = dataset.visibility === 'hidden' ? 'none' : 'visible'
-
-  if (hasSymbol(dataset) && symbolRegistry) {
-    addSymbolLayer(map, dataset, symbolLayerId, sourceId, sourceLayer, visibility, { mapStyle, symbolRegistry, pixelRatio })
-    return sourceId
+  if (registryDataset.isSublayer) {
+    return undefined
   }
-
-  addFillLayer(map, dataset, fillLayerId, sourceId, sourceLayer, visibility, { mapStyleId, patternRegistry, pixelRatio })
-  addStrokeLayer(map, dataset, strokeLayerId, sourceId, sourceLayer, visibility, mapStyleId)
   return sourceId
 }