@defra/interactive-map 0.0.50-alpha → 0.0.51-apha

package/providers/beta/openlayers/src/utils/highlightFeatures.test.js

@@ -5,20 +5,18 @@ import OlFeature from 'ol/Feature.js'
 import Point from 'ol/geom/Point.js'
 import Icon from 'ol/style/Icon.js'
 import { updateHighlightedFeatures } from './highlightFeatures.js'
-import { getOrCreateSymbolImage, clearSymbolImageCache } from './symbolImages.js'
+import { getOrCreateSymbolImage, getCachedSymbolImage, clearSymbolImageCache, registerSymbol } from './symbolImages.js'
 
 const HIGHLIGHT_MARKER = '_highlight'
 
-// Mirrors the map interface this module actually calls: getLayers().forEach(...) to find/
-// enumerate real ol/layer instances, and addLayer() to register new ones. Layers passed in
-// (or added during a test) are real ol/layer/Vector or ol/layer/VectorTile instances, same as
-// the rest of this codebase's OL tests use real ol classes over mocks for anything the
-// module under test actually instantiates or type-checks (instanceof).
+// Mirrors the map interface this module actually calls: getLayers().forEach(...)/getArray()
+// to find/enumerate real ol/layer instances, and addLayer() to register new ones. Layers
+// passed in (or added during a test) are real ol/layer/Vector or ol/layer/VectorTile instances.
 const createFakeMap = (layers = []) => {
   const list = [...layers]
   return {
     _layers: list,
-    getLayers: () => ({ forEach: (cb) => list.forEach(cb) }),
+    getLayers: () => ({ forEach: (cb) => list.forEach(cb), getArray: () => list }),
     addLayer: jest.fn((l) => list.push(l))
   }
 }
@@ -166,13 +164,160 @@ describe('updateHighlightedFeatures', () => {
       expect(getHighlightLayer(map).getSource().getFeatures()).toHaveLength(0)
     })
   })
+
+  describe('symbol-styled points (dataset)', () => {
+    const LAYER_ID = 'historic-monuments-prehistoric'
+
+    // A dataset symbol point has no symbolSelectedImageId/symbolActiveImageId of its own (see
+    // symbolProperties above) — the layer itself is tagged with the one base imageId every
+    // feature shares instead (see layerBuilders.js's createDatasetLayer / OpenLayersDataset.
+    // symbolMeta), and the variant is resolved from that via symbolImages.js's reverse-map.
+    const datasetSymbolLayer = (features, symbolMeta) => {
+      const source = new VectorSource()
+      features.forEach(([id, properties]) => {
+        const f = new OlFeature({ geometry: new Point([1, 2]), ...properties })
+        f.setId(id)
+        source.addFeature(f)
+      })
+      const layer = new VectorLayer({ source })
+      layer.set('layerId', LAYER_ID)
+      layer.set('layerType', 'vector')
+      if (symbolMeta) {
+        layer.set('symbolMeta', symbolMeta)
+      }
+      return layer
+    }
+
+    const registerDatasetSymbol = async () => {
+      const symbolRegistry = {
+        getSymbolImageId: jest.fn((style, mapStyle, active) => (active ? 'ds-symbol-active' : 'ds-symbol-normal')),
+        rasteriseSymbolImage: jest.fn(async (style, mapStyle, variant) => ({
+          imageId: variant === 'active' ? 'ds-symbol-active' : variant === 'selected' ? 'ds-symbol-selected' : 'ds-symbol-normal',
+          imageData: { width: 30, height: 30 }
+        }))
+      }
+      await registerSymbol({ symbol: 'square' }, {}, symbolRegistry, 3)
+    }
+
+    test('renders the selected-variant Icon for a dataset symbol point', async () => {
+      await registerDatasetSymbol()
+      const selectedCanvas = getCachedSymbolImage('ds-symbol-selected')
+      const map = createFakeMap([datasetSymbolLayer([['f1', {}]], { imageId: 'ds-symbol-normal', anchor: [0.5, 1] })])
+
+      updateHighlightedFeatures(map, [{ layerId: LAYER_ID, featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], [], {})
+      const [hlFeature] = getHighlightLayer(map).getSource().getFeatures()
+      const [style] = hlFeature.getStyle()
+      expect(style.getImage()).toBeInstanceOf(Icon)
+      expect(style.getImage().getImage(1)).toBe(selectedCanvas)
+    })
+
+    test('renders the active-variant Icon for the keyboard-cursor item', async () => {
+      await registerDatasetSymbol()
+      const activeCanvas = getCachedSymbolImage('ds-symbol-active')
+      const map = createFakeMap([datasetSymbolLayer([['f1', {}]], { imageId: 'ds-symbol-normal', anchor: [0.5, 1] })])
+
+      updateHighlightedFeatures(map, [], [{ layerId: LAYER_ID, featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], {})
+      const [hlFeature] = getHighlightLayer(map).getSource().getFeatures()
+      const [style] = hlFeature.getStyle()
+      expect(style.getImage().getImage(1)).toBe(activeCanvas)
+    })
+
+    test('falls back to no highlight when the layer has no symbolMeta (not a symbol dataset)', () => {
+      const map = createFakeMap([datasetSymbolLayer([['f1', {}]])])
+      updateHighlightedFeatures(map, [{ layerId: LAYER_ID, featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], [], {})
+      expect(getHighlightLayer(map).getSource().getFeatures()).toHaveLength(0)
+    })
+
+    test('falls back to no highlight when the variant has not been rasterised/cached yet', () => {
+      const map = createFakeMap([datasetSymbolLayer([['f1', {}]], { imageId: 'ds-symbol-never-registered', anchor: [0.5, 1] })])
+      updateHighlightedFeatures(map, [{ layerId: LAYER_ID, featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], [], {})
+      expect(getHighlightLayer(map).getSource().getFeatures()).toHaveLength(0)
+    })
+  })
 })
 
-describe('VectorTileLayer style-wrap (smoke test — pre-existing, undocumented path)', () => {
+describe('VectorTileLayer style-wrap', () => {
   test('does not throw when a VT layer is present alongside a draw VectorLayer', () => {
     const vt = new VectorTileLayer({})
     vt.set('layerType', 'vectorTile')
     const map = createFakeMap([vt, drawLayer()])
     expect(() => updateHighlightedFeatures(map, [], [], {})).not.toThrow()
   })
+
+  const vtStylesMap = { 'existing-fields': { stroke: '#000', selectionStroke: '#111', fill: 'transparent', strokeWidth: 2, activeStrokeWidth: 2 } }
+
+  // Two different vector-tile producers share the 'vectorTile' layerType tag: draw-ol's
+  // basemap MVT tiles (a 'mapbox-layer' object per feature) and the datasets plugin's own
+  // tiles-backed datasets (no 'mapbox-layer' at all — the id lives on the OL layer itself, as
+  // 'layerId'). This feature has neither a mapbox-layer property nor any live 'get' beyond the
+  // default, matching a real datasets-plugin MVT feature.
+  const datasetVtFeature = (id) => {
+    const feature = new OlFeature({ geometry: new Point([1, 2]) })
+    feature.setId(id)
+    return feature
+  }
+
+  test('highlights a datasets-plugin tiles-backed feature via the layer\'s own layerId', () => {
+    const vt = new VectorTileLayer({ style: { 'fill-color': '#0000ff' } })
+    vt.set('layerType', 'vectorTile')
+    vt.set('layerId', 'existing-fields')
+    const map = createFakeMap([vt])
+    const feature = datasetVtFeature('f1')
+
+    updateHighlightedFeatures(map, [{ layerId: 'existing-fields', featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], [], vtStylesMap)
+
+    const styles = vt.getStyle()(feature, 1)
+    expect(Array.isArray(styles)).toBe(true)
+    expect(styles.some(s => s.getStroke()?.getColor() === '#111')).toBe(true) // selectionStroke applied
+  })
+
+  test('leaves a non-matching datasets-plugin tiles-backed feature unhighlighted', () => {
+    const vt = new VectorTileLayer({ style: { 'fill-color': '#0000ff' } })
+    vt.set('layerType', 'vectorTile')
+    vt.set('layerId', 'existing-fields')
+    const map = createFakeMap([vt])
+    const feature = datasetVtFeature('f2') // not the selected f1
+
+    updateHighlightedFeatures(map, [{ layerId: 'existing-fields', featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], [], vtStylesMap)
+
+    const base = vt._highlightOriginalStyle(feature, 1)
+    const styled = vt.getStyle()(feature, 1)
+    expect(styled).toEqual(base)
+  })
+
+  test('picks up a restyle made while a selection stays active, instead of wrapping a stale pre-restyle style forever', () => {
+    // Simulates a map style/theme switch: _setLayerStyle calls layer.setStyle(...) directly on
+    // a dataset layer while a feature on it is still selected (e.g. via useHighlightSync's
+    // re-apply after MAP_STYLE_CHANGE) — the highlight wrap must notice its own wrap was
+    // replaced and re-capture the new live style, not keep calling the old one underneath.
+    const vt = new VectorTileLayer({ style: { 'fill-color': '#0000ff' } })
+    vt.set('layerType', 'vectorTile')
+    vt.set('layerId', 'existing-fields')
+    const map = createFakeMap([vt])
+    const selection = [{ layerId: 'existing-fields', featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }]
+
+    updateHighlightedFeatures(map, selection, [], vtStylesMap)
+
+    // Something outside the highlight module (a theme switch) restyles the layer directly.
+    vt.setStyle({ 'fill-color': '#ff0000' })
+
+    updateHighlightedFeatures(map, selection, [], vtStylesMap)
+
+    const otherFeature = datasetVtFeature('not-selected')
+    const [styled] = vt.getStyle()(otherFeature, 1)
+    expect(styled.getFill().getColor()).toEqual([255, 0, 0, 1])
+  })
+
+  test('restores the original style function once nothing is selected/active', () => {
+    const vt = new VectorTileLayer({ style: { 'fill-color': '#0000ff' } })
+    vt.set('layerType', 'vectorTile')
+    vt.set('layerId', 'existing-fields')
+    const map = createFakeMap([vt])
+
+    updateHighlightedFeatures(map, [{ layerId: 'existing-fields', featureId: 'f1', geometry: { type: 'Point', coordinates: [1, 2] } }], [], vtStylesMap)
+    expect(vt._highlightOriginalStyle).toBeDefined()
+
+    updateHighlightedFeatures(map, [], [], vtStylesMap)
+    expect(vt._highlightOriginalStyle).toBeUndefined()
+  })
 })

package/providers/beta/openlayers/src/utils/hoverCursor.js

@@ -7,7 +7,11 @@ const HIT_TOLERANCE = 8
 // ol, so a class reference from this bundle never matches an instance built by another.
 const isInteractiveFeature = (feature, layer, layerSet) => {
   if (layer.get('layerType') === 'vectorTile') {
-    const styleLayerId = feature.get('mapbox-layer')?.id
+    // Two different vector-tile producers share this tag: draw-ol's basemap MVT tiles (a
+    // 'mapbox-layer' object per feature) and the datasets plugin's own tiles-backed datasets
+    // (no 'mapbox-layer' — the id lives on the OL layer itself, as 'layerId'). See
+    // plugins/datasets/src/adapters/openlayers/layerBuilders.js's createDatasetLayer.
+    const styleLayerId = feature.get('mapbox-layer')?.id ?? layer.get('layerId')
     return Boolean(styleLayerId && layerSet.has(styleLayerId))
   }
   if (layer.get('layerType') === 'vector' && !layer.get(HIGHLIGHT_MARKER)) {

package/providers/beta/openlayers/src/utils/hoverCursor.test.js

@@ -30,6 +30,20 @@ const makeVTLayer = () => {
   return layer
 }
 
+// A datasets-plugin tiles-backed layer: 'vectorTile' layerType, but no 'mapbox-layer' on the
+// feature — its layerId lives on the layer itself instead.
+const makeDatasetVTLayer = (layerId) => {
+  const layer = new VectorTileLayer()
+  layer.get = (key) => {
+    if (key === 'layerType') return 'vectorTile'
+    if (key === 'layerId') return layerId
+    return undefined
+  }
+  return layer
+}
+
+const makeDatasetVTFeature = () => ({ get: () => undefined })
+
 const makeVectorLayer = (layerId, isHighlight = false) => {
   const layer = new VectorLayer()
   layer.get = (key) => {
@@ -154,6 +168,32 @@ describe('setupHoverCursor', () => {
     expect(map.getViewport().style.cursor).toBe('')
   })
 
+  /* ------------------------------------------------------------------ */
+  /* Feature matching — datasets-plugin tiles-backed VT layer            */
+  /* ------------------------------------------------------------------ */
+
+  it('matches a dataset tiles-backed feature via the layer\'s own layerId', () => {
+    const map = makeMap()
+    const feature = makeDatasetVTFeature()
+    const layer = makeDatasetVTLayer('existing-fields')
+    map.forEachFeatureAtPixel.mockImplementation((pixel, cb) => cb(feature, layer))
+
+    const handler = setupHoverCursor(map, ['existing-fields'], null)
+    move(handler)
+    expect(map.getViewport().style.cursor).toBe('pointer')
+  })
+
+  it('does not match a dataset tiles-backed feature whose layerId is not watched', () => {
+    const map = makeMap()
+    const feature = makeDatasetVTFeature()
+    const layer = makeDatasetVTLayer('existing-fields')
+    map.forEachFeatureAtPixel.mockImplementation((pixel, cb) => cb(feature, layer))
+
+    const handler = setupHoverCursor(map, ['hedge-control'], null)
+    move(handler)
+    expect(map.getViewport().style.cursor).toBe('')
+  })
+
   /* ------------------------------------------------------------------ */
   /* Feature matching — Vector layer                                    */
   /* ------------------------------------------------------------------ */

package/providers/beta/openlayers/src/utils/queryFeatures.js

@@ -1,6 +1,7 @@
 import GeoJSON from 'ol/format/GeoJSON.js'
 import TileState from 'ol/TileState.js'
 import { renderFeatureToGeoJSON } from './vtTileFragments.js'
+import { buildFilterEvaluator } from './filterEvaluator.js'
 
 const CRS = 'EPSG:27700'
 
@@ -23,6 +24,57 @@ const getVtFeatureId = (feature) => {
   return JSON.stringify(props)
 }
 
+// Shared result shape for a real ol/Feature identified by an OL layer's own layerId — used by
+// plain 'vector' layers and by tiles-backed datasets, as opposed to draw-ol's basemap MVT tiles
+// (RenderFeatures identified via a 'mapbox-layer' object instead).
+const pushLayerIdResult = (results, seenKeys, layerId, feature) => {
+  if (!layerId) {
+    return
+  }
+  // Property-hash fallback so distinct id-less features sharing a source don't collide.
+  const key = `${layerId}:${getVtFeatureId(feature)}`
+  if (seenKeys.has(key)) {
+    return
+  }
+  seenKeys.add(key)
+  results.push({
+    id: feature.getId(),
+    layer: { id: layerId },
+    geometry: geoJsonFormat.writeGeometryObject(feature.getGeometry()),
+    properties: feature.getProperties()
+  })
+}
+
+const pushMapboxLayerResult = (results, seenKeys, mapboxLayer, feature) => {
+  const styleLayerId = mapboxLayer?.id
+  // background-type layers have no features in MapLibre — skip to match behaviour
+  if (!styleLayerId || mapboxLayer?.type === 'background') {
+    return
+  }
+  const key = `${styleLayerId}:${getVtFeatureId(feature)}`
+  if (seenKeys.has(key)) {
+    return
+  }
+  seenKeys.add(key)
+  results.push({
+    id: feature.getId(),
+    layer: { id: styleLayerId },
+    geometry: renderFeatureToGeoJSON(feature),
+    properties: feature.getProperties()
+  })
+}
+
+// Two different vector-tile producers share the 'vectorTile' layerType tag: draw-ol's basemap
+// MVT tiles (carry a 'mapbox-layer' object) and tiles-backed datasets (carry 'layerId' instead).
+const pushVectorTileResult = (results, seenKeys, layer, feature) => {
+  const mapboxLayer = feature.get('mapbox-layer')
+  if (mapboxLayer) {
+    pushMapboxLayerResult(results, seenKeys, mapboxLayer, feature)
+    return
+  }
+  pushLayerIdResult(results, seenKeys, layer.get('layerId'), feature)
+}
+
 export const queryFeatures = (map, point, options = {}) => {
   if (!point) {
     return []
@@ -36,42 +88,11 @@ export const queryFeatures = (map, point, options = {}) => {
     pixel,
     (feature, layer) => {
       if (layer.get('layerType') === 'vectorTile') {
-        const mapboxLayer = feature.get('mapbox-layer')
-        const styleLayerId = mapboxLayer?.id
-        // background-type layers have no features in MapLibre — skip to match behaviour
-        if (!styleLayerId || mapboxLayer?.type === 'background') {
-          return
-        }
-        const key = `${styleLayerId}:${getVtFeatureId(feature)}`
-        if (seenKeys.has(key)) {
-          return
-        }
-        seenKeys.add(key)
-        results.push({
-          id: feature.getId(),
-          layer: { id: styleLayerId },
-          geometry: renderFeatureToGeoJSON(feature),
-          properties: feature.getProperties()
-        })
-      } else if (layer.get('layerType') === 'vector') {
-        const layerId = layer.get('layerId')
-        if (!layerId || layer.get('_highlight')) {
-          return
-        }
-        const featureId = feature.getId()
-        const key = `${layerId}:${featureId}`
-        if (seenKeys.has(key)) {
-          return
-        }
-        seenKeys.add(key)
-        results.push({
-          id: featureId,
-          layer: { id: layerId },
-          geometry: geoJsonFormat.writeGeometryObject(feature.getGeometry()),
-          properties: feature.getProperties()
-        })
+        pushVectorTileResult(results, seenKeys, layer, feature)
+      } else if (layer.get('layerType') === 'vector' && !layer.get('_highlight')) {
+        pushLayerIdResult(results, seenKeys, layer.get('layerId'), feature)
       } else {
-        // other layer types (e.g. TileLayer) — skip
+        // other layer types (e.g. TileLayer), or a highlight overlay — skip
       }
     },
     { hitTolerance: radius }
@@ -93,6 +114,10 @@ export const queryFeatures = (map, point, options = {}) => {
  * separate extent check. A single logical feature can be split across tile boundaries, so
  * fragments are deduplicated the same way queryFeatures() does above.
  * VectorLayer features come directly from the source's current-viewport extent.
+ *
+ * Both branches also apply each layer's own tagged filter (see buildFilterEvaluator), since
+ * reading straight off the source/tiles has no other way to isolate a shared source's sibling
+ * sublayers.
  */
 export const getVisibleFeatures = (map, layerIds) => {
   const wanted = new Set(layerIds)
@@ -106,28 +131,23 @@ export const getVisibleFeatures = (map, layerIds) => {
       if (!sourceTiles) {
         return
       }
+      const layerId = mapLayer.get('layerId')
+      const matchesFilter = buildFilterEvaluator(mapLayer.get('filter'))
       Object.values(sourceTiles).forEach(tile => {
         if (tile.getState() !== TileState.LOADED) {
           return
         }
         tile.getFeatures().forEach(feature => {
           const mapboxLayer = feature.get('mapbox-layer')
-          const styleLayerId = mapboxLayer?.id
-          // background-type layers have no features in MapLibre — skip to match behaviour
-          if (!styleLayerId || !wanted.has(styleLayerId) || mapboxLayer?.type === 'background') {
+          if (mapboxLayer) {
+            if (wanted.has(mapboxLayer.id)) {
+              pushMapboxLayerResult(results, seenKeys, mapboxLayer, feature)
+            }
             return
           }
-          const key = `${styleLayerId}:${getVtFeatureId(feature)}`
-          if (seenKeys.has(key)) {
-            return
+          if (wanted.has(layerId) && (!matchesFilter || matchesFilter(feature))) {
+            pushLayerIdResult(results, seenKeys, layerId, feature)
           }
-          seenKeys.add(key)
-          results.push({
-            id: feature.getId(),
-            layer: { id: styleLayerId },
-            geometry: renderFeatureToGeoJSON(feature),
-            properties: feature.getProperties()
-          })
         })
       })
     } else if (mapLayer.get('layerType') === 'vector') {
@@ -135,13 +155,11 @@ export const getVisibleFeatures = (map, layerIds) => {
       if (!layerId || !wanted.has(layerId) || mapLayer.get('_highlight')) {
         return
       }
+      const matchesFilter = buildFilterEvaluator(mapLayer.get('filter'))
       mapLayer.getSource()?.getFeaturesInExtent(extent).forEach(feature => {
-        results.push({
-          id: feature.getId(),
-          layer: { id: layerId },
-          geometry: geoJsonFormat.writeGeometryObject(feature.getGeometry()),
-          properties: feature.getProperties()
-        })
+        if (!matchesFilter || matchesFilter(feature)) {
+          pushLayerIdResult(results, seenKeys, layerId, feature)
+        }
       })
     } else {
       // other layer types (e.g. TileLayer) — skip

package/providers/beta/openlayers/src/utils/queryFeatures.test.js

@@ -26,6 +26,23 @@ const makeMap = (hits = []) => ({
 
 const makeVTLayer = () => Object.assign(new VectorTileLayer(), { get: (key) => key === 'layerType' ? 'vectorTile' : undefined })
 
+// A datasets-plugin tiles-backed layer: 'vectorTile' layerType, but a real ol/Feature with no
+// 'mapbox-layer' property, and a layerId set on the layer itself (not the feature).
+const makeDatasetVTLayer = (layerId) => Object.assign(new VectorTileLayer(), {
+  get: (key) => {
+    if (key === 'layerType') return 'vectorTile'
+    if (key === 'layerId') return layerId
+    return undefined
+  }
+})
+
+const makeDatasetVTFeature = (id, geom = { type: 'Point' }, props = {}) => ({
+  getId: () => id,
+  get: () => undefined, // no 'mapbox-layer'
+  getGeometry: () => geom,
+  getProperties: () => props
+})
+
 const makeVTFeature = ({ id = undefined, styleLayerId = 'roads', type = 'fill', props = {} } = {}) => ({
   getId: () => id,
   get: (key) => {
@@ -50,6 +67,16 @@ const makeVectorFeature = (id = 'f1', geom = { type: 'Point' }, props = {}) => (
   getProperties: () => props
 })
 
+// A feature with no native id, e.g. a plain geojson dataset with no id/idProperty — getId()
+// genuinely returns undefined for these, not a default like makeVectorFeature('f1', ...) would.
+// getType() is real ol/geom/Geometry API — needed here (unlike makeVectorFeature's plain shape
+// object) since these features are used with a filter, and buildFilterEvaluator's context reads it.
+const makeIdlessVectorFeature = (props, geom = { getType: () => 'Point' }) => ({
+  getId: () => undefined,
+  getGeometry: () => geom,
+  getProperties: () => props
+})
+
 describe('queryFeatures', () => {
   beforeEach(() => jest.clearAllMocks())
 
@@ -135,6 +162,31 @@ describe('queryFeatures', () => {
     expect(queryFeatures(map, { x: 0, y: 0 })).toHaveLength(1)
   })
 
+  /* ------------------------------------------------------------------ */
+  /* Datasets-plugin tiles-backed VectorTile layer features             */
+  /* ------------------------------------------------------------------ */
+
+  it('returns a result for a dataset tiles-backed feature, keyed by the layer\'s own layerId', () => {
+    const feature = makeDatasetVTFeature('f1', { type: 'Point' }, { sbi: 123 })
+    const map = makeMap([[feature, makeDatasetVTLayer('existing-fields')]])
+    const results = queryFeatures(map, { x: 0, y: 0 })
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({ id: 'f1', layer: { id: 'existing-fields' }, properties: { sbi: 123 } })
+    expect(renderFeatureToGeoJSON).not.toHaveBeenCalled()
+  })
+
+  it('skips a dataset tiles-backed feature when the layer has no layerId', () => {
+    const feature = makeDatasetVTFeature('f1')
+    const map = makeMap([[feature, makeDatasetVTLayer(undefined)]])
+    expect(queryFeatures(map, { x: 0, y: 0 })).toEqual([])
+  })
+
+  it('deduplicates dataset tiles-backed features with the same layerId and feature id', () => {
+    const feature = makeDatasetVTFeature('f1')
+    const map = makeMap([[feature, makeDatasetVTLayer('existing-fields')], [feature, makeDatasetVTLayer('existing-fields')]])
+    expect(queryFeatures(map, { x: 0, y: 0 })).toHaveLength(1)
+  })
+
   /* ------------------------------------------------------------------ */
   /* Vector layer features                                              */
   /* ------------------------------------------------------------------ */
@@ -204,13 +256,14 @@ describe('getVisibleFeatures', () => {
     getSource: () => ({ sourceTiles_: tiles })
   })
 
-  const makeVectorLayerWithFeatures = (layerId, features, isHighlight = false) => {
+  const makeVectorLayerWithFeatures = (layerId, features, isHighlight = false, filter = undefined) => {
     const source = { getFeaturesInExtent: jest.fn(() => features) }
     return Object.assign(new VectorLayer(), {
       get: (key) => {
         if (key === 'layerType') return 'vector'
         if (key === 'layerId') return layerId
         if (key === '_highlight') return isHighlight || undefined
+        if (key === 'filter') return filter
         return undefined
       },
       getSource: () => source
@@ -258,6 +311,48 @@ describe('getVisibleFeatures', () => {
     expect(getVisibleFeatures(makeExtentMap([layer]), ['roads'])).toEqual([])
   })
 
+  /* ------------------------------------------------------------------ */
+  /* Datasets-plugin tiles-backed VectorTile layer features             */
+  /* ------------------------------------------------------------------ */
+
+  const makeDatasetVTLayerWithTiles = (layerId, tiles, filter = undefined) => Object.assign(new VectorTileLayer(), {
+    get: (key) => {
+      if (key === 'layerType') return 'vectorTile'
+      if (key === 'layerId') return layerId
+      if (key === 'filter') return filter
+      return undefined
+    },
+    getSource: () => ({ sourceTiles_: tiles })
+  })
+
+  it('returns a loaded dataset tiles-backed feature matching the layer\'s own layerId', () => {
+    const feature = makeDatasetVTFeature('f1')
+    const layer = makeDatasetVTLayerWithTiles('existing-fields', { a: makeTile([feature]) })
+    const results = getVisibleFeatures(makeExtentMap([layer]), ['existing-fields'])
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({ id: 'f1', layer: { id: 'existing-fields' } })
+  })
+
+  it('skips a dataset tiles-backed layer whose layerId is not requested', () => {
+    const feature = makeDatasetVTFeature('f1')
+    const layer = makeDatasetVTLayerWithTiles('existing-fields', { a: makeTile([feature]) })
+    expect(getVisibleFeatures(makeExtentMap([layer]), ['hedge-control'])).toEqual([])
+  })
+
+  it('applies the layer\'s own filter when reading a shared VT source (e.g. sibling sourceLayers)', () => {
+    const geom = { getType: () => 'Point' }
+    const matching = makeDatasetVTFeature('f1', geom, { layer: 'field_parcels_osgb36' })
+    const other = makeDatasetVTFeature('f2', geom, { layer: 'hedge_control' })
+    const layer = makeDatasetVTLayerWithTiles(
+      'existing-fields',
+      { a: makeTile([matching, other]) },
+      ['==', ['get', 'layer'], 'field_parcels_osgb36']
+    )
+    const results = getVisibleFeatures(makeExtentMap([layer]), ['existing-fields'])
+    expect(results).toHaveLength(1)
+    expect(results[0].id).toBe('f1')
+  })
+
   /* ------------------------------------------------------------------ */
   /* Vector layer features                                              */
   /* ------------------------------------------------------------------ */
@@ -288,6 +383,53 @@ describe('getVisibleFeatures', () => {
     expect(getVisibleFeatures(makeExtentMap([layer]), ['draw'])).toEqual([])
   })
 
+  // Regression coverage for a real bug: sibling sublayers of one dataset (e.g. a symbol
+  // dataset's per-category sublayers) share one OL source — reading straight off it, with no
+  // rendering step involved, previously ignored each sublayer's own filter entirely, so every
+  // sibling reported every feature in the shared source. Combined with id-less features (no
+  // id/idProperty configured, common for demo/small datasets) all colliding on the same
+  // `${layerId}:undefined` dedup key, this collapsed every sibling down to whichever feature
+  // happened to be first in the source, regardless of which one it actually was.
+  it('applies each sibling sublayer\'s own filter when reading one shared Vector source', () => {
+    const prehistoric = makeIdlessVectorFeature({ category: 'prehistoric', name: 'Prehistoric feature' })
+    const roman = makeIdlessVectorFeature({ category: 'roman', name: 'Roman feature' })
+    const medieval = makeIdlessVectorFeature({ category: 'medieval', name: 'Medieval feature' })
+    const sharedSourceFeatures = [prehistoric, roman, medieval]
+
+    const layers = ['prehistoric', 'roman', 'medieval'].map(category =>
+      makeVectorLayerWithFeatures(
+        `historic-monuments-${category}`,
+        sharedSourceFeatures,
+        false,
+        ['==', ['get', 'category'], category]
+      )
+    )
+    const layerIds = layers.map(l => l.get('layerId'))
+
+    const results = getVisibleFeatures(makeExtentMap(layers), layerIds)
+
+    expect(results).toHaveLength(3)
+    layers.forEach((layer, i) => {
+      const layerId = layerIds[i]
+      const own = results.find(r => r.layer.id === layerId)
+      expect(own?.properties.name).toBe(sharedSourceFeatures[i].getProperties().name)
+    })
+  })
+
+  it('does not dedupe distinct id-less features sharing a layer/source', () => {
+    const a = makeIdlessVectorFeature({ name: 'A' })
+    const b = makeIdlessVectorFeature({ name: 'B' })
+    const layer = makeVectorLayerWithFeatures('draw', [a, b])
+    const results = getVisibleFeatures(makeExtentMap([layer]), ['draw'])
+    expect(results).toHaveLength(2)
+    expect(results.map(r => r.properties.name).sort()).toEqual(['A', 'B'])
+  })
+
+  it('a Vector layer with no filter tag still returns every feature in the source (untagged = unfiltered)', () => {
+    const layer = makeVectorLayerWithFeatures('draw', [makeVectorFeature('f1'), makeVectorFeature('f2')])
+    expect(getVisibleFeatures(makeExtentMap([layer]), ['draw'])).toHaveLength(2)
+  })
+
   /* ------------------------------------------------------------------ */
   /* Mixed / other layers                                               */
   /* ------------------------------------------------------------------ */