From 26c259b9bf14217741b7e7229924cb2201894241 Mon Sep 17 00:00:00 2001 From: Thomas Halwax Date: Wed, 21 Oct 2026 09:49:18 +0200 Subject: [PATCH] fix: keep late-arriving features hidden when their layer is hidden Hiding a layer marks the layer key and every feature present at that moment with a hidden+ entry. Features created afterwards through store.import (NIDO WebSocket API, Matrix replication) carry no marker, and the visibility tracker only checked the feature's own key, so they appeared on the map inside a hidden layer. The tracker now also treats a feature as hidden when its layer key is in the hidden set. Covered by a new visibilityTracker test. Co-Authored-By: Claude Fable 5.1 --- .../model/sources/visibilityTracker.js | 10 +- .../model/sources/visibilityTracker-test.js | 96 +++++++++++++++++++ 2 files changed, 104 insertions(+), 2 deletions(-) create mode 100644 test/renderer/model/sources/visibilityTracker-test.js diff --git a/src/renderer/model/sources/visibilityTracker.js b/src/renderer/model/sources/visibilityTracker.js index ad9e91cf..68e9a568 100644 --- a/src/renderer/model/sources/visibilityTracker.js +++ b/src/renderer/model/sources/visibilityTracker.js @@ -8,8 +8,14 @@ import { filter } from './filter' */ export const visibilityTracker = async (source, store, emitter) => { const keySet = new Set() - const hidden = key => keySet.has(key) - const visible = key => !keySet.has(key) + + // A feature is hidden when it is hidden itself or when its layer is. + // Hiding a layer marks the features present at that moment, but features + // arriving later (NIDO WebSocket, Matrix replication) carry no marker of + // their own; they still must not show up in a hidden layer. + const hidden = key => keySet.has(key) || + (ID.isFeatureId(key) && keySet.has(ID.layerId(key))) + const visible = key => !hidden(key) await (async () => { emitter.on('feature/show', ({ ids }) => { diff --git a/test/renderer/model/sources/visibilityTracker-test.js b/test/renderer/model/sources/visibilityTracker-test.js new file mode 100644 index 00000000..90b48c3f --- /dev/null +++ b/test/renderer/model/sources/visibilityTracker-test.js @@ -0,0 +1,96 @@ +import assert from 'assert' +import VectorSource from 'ol/source/Vector' +import Feature from 'ol/Feature' +import Point from 'ol/geom/Point' +import Emitter from '../../../../src/shared/emitter' +import * as ID from '../../../../src/renderer/ids' +import { visibilityTracker } from '../../../../src/renderer/model/sources/visibilityTracker' + +const feature = id => { + const feature = new Feature(new Point([0, 0])) + feature.setId(id) + return feature +} + +/* Minimal store: emits 'batch' and answers keys() with the hidden markers. */ +const fakeStore = (hiddenKeys = []) => { + const store = new Emitter() + store.keys = async () => hiddenKeys + return store +} + +const ids = key => [key] + +/* Emitter delivers handlers via setImmediate. */ +const tick = () => new Promise(resolve => setImmediate(resolve)) + +describe('visibilityTracker', function () { + + it('shows features of a visible layer', async function () { + const source = new VectorSource() + const layerId = ID.layerId() + const { visibleSource } = await visibilityTracker(source, fakeStore(), new Emitter()) + source.addFeature(feature(ID.featureId(layerId))) + assert.equal(visibleSource.getFeatures().length, 1) + }) + + it('hides features arriving after the layer was hidden', async function () { + const source = new VectorSource() + const store = fakeStore() + const layerId = ID.layerId() + const { visibleSource, hiddenSource } = await visibilityTracker(source, store, new Emitter()) + + // Hide layer with one feature present (what Store.hide writes). + const first = ID.featureId(layerId) + source.addFeature(feature(first)) + store.emit('batch', { + operations: [ + { type: 'put', key: ID.hiddenId(layerId), value: true }, + { type: 'put', key: ID.hiddenId(first), value: true } + ] + }) + await tick() + assert.equal(visibleSource.getFeatures().length, 0) + assert.equal(hiddenSource.getFeatures().length, 1) + + // New feature arrives via store import (NIDO, replication): no own marker. + const late = ID.featureId(layerId) + source.addFeature(feature(late)) + assert.equal(visibleSource.getFeatures().length, 0, 'late feature must stay hidden') + assert.equal(hiddenSource.getFeatures().length, 2) + + // Showing the layer again reveals both. + store.emit('batch', { + operations: [ + { type: 'del', key: ID.hiddenId(layerId) }, + { type: 'del', key: ID.hiddenId(first) } + ] + }) + await tick() + assert.equal(visibleSource.getFeatures().length, 1, 'marked feature is touched back') + // The late feature was never marked; it reappears on the next touch. + source.dispatchEvent({ type: 'touchfeatures', keys: ids(late) }) + assert.equal(visibleSource.getFeatures().length, 2) + }) + + it('respects a layer hidden before the tracker started', async function () { + const source = new VectorSource() + const layerId = ID.layerId() + const store = fakeStore([ID.hiddenId(layerId)]) + const { visibleSource, hiddenSource } = await visibilityTracker(source, store, new Emitter()) + source.addFeature(feature(ID.featureId(layerId))) + assert.equal(visibleSource.getFeatures().length, 0) + assert.equal(hiddenSource.getFeatures().length, 1) + }) + + it('does not hide features of other layers', async function () { + const source = new VectorSource() + const hiddenLayer = ID.layerId() + const otherLayer = ID.layerId() + const store = fakeStore([ID.hiddenId(hiddenLayer)]) + const { visibleSource } = await visibilityTracker(source, store, new Emitter()) + source.addFeature(feature(ID.featureId(hiddenLayer))) + source.addFeature(feature(ID.featureId(otherLayer))) + assert.equal(visibleSource.getFeatures().length, 1) + }) +})