Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

fix: keep split map panels index-aligned when merging split maps (#3735)

Javier Andrés García156bdd388e83
diff --git a/src/reducers/src/vis-state-merger.ts b/src/reducers/src/vis-state-merger.ts
index 041ec32e5..4f354b2a7 100644
--- a/src/reducers/src/vis-state-merger.ts
+++ b/src/reducers/src/vis-state-merger.ts
@@ -7,6 +7,7 @@ import flattenDeep from 'es-toolkit/compat/flattenDeep';
import deepmerge from 'deepmerge';
import {
arrayInsert,
+ combineSplitMapsByIndex,
getInitialMapLayersForSplitMap,
applyFiltersToDatasets,
validateFiltersUpdateDatasets,
@@ -640,45 +641,53 @@ function replaceInteractionDatasetIds(interactionConfig, dataId: string, dataIdT
/**
* Merge splitMaps config with current visStete.
+ * Panels are matched by index: index i of `splitMaps`, `state.splitMaps` and
+ * `state.splitMapsToBeMerged` is the same map panel.
* 1. if current map is split, but splitMap DOESNOT contain maps
* : don't merge anything
* 2. if current map is NOT split, but splitMaps contain maps
- * : add to splitMaps, and add current layers to splitMaps
+ * : add to splitMaps, and add current layers to splitMaps.
+ * Panels are created once one of them can be merged: it has no layers, or one of its layers exists
+ * 3. layers that don't exist yet
+ * : save to splitMapsToBeMerged, in the panel at the same index
+ * A layer listed in splitMaps only shows in the panels that list it.
*/
export function mergeSplitMaps<S extends VisState>(
state: S,
splitMaps: NonNullable<ParsedConfig['visState']>['splitMaps'] = []
): S {
+ const layerExists = (id: string) => state.layers.some(l => l.id === id);
+ const createPanels =
+ state.splitMaps.length > 0 ||
+ splitMaps.some(sm => {
+ const ids = Object.keys(sm.layers);
+ return !ids.length || ids.some(layerExists);
+ });
+ const currentLayers = getInitialMapLayersForSplitMap(
+ state.layers.filter(l => !splitMaps.some(sm => l.id in sm.layers))
+ );
+
const merged = [...state.splitMaps];
- const unmerged = [];
+ const unmerged: typeof splitMaps = [];
splitMaps.forEach((sm, i) => {
const entries = Object.entries(sm.layers);
- if (entries.length > 0) {
- entries.forEach(([id, value]) => {
- // check if layer exists
- const pushTo = state.layers.find(l => l.id === id) ? merged : unmerged;
-
- // create map panel if current map is not split
- pushTo[i] = pushTo[i] || {
- // keep id
- ...sm,
- layers: pushTo === merged ? getInitialMapLayersForSplitMap(state.layers) : []
- };
- pushTo[i].layers = {
- ...pushTo[i].layers,
- [id]: value
- };
- });
- } else {
- // We are merging if there are no layers in both split map
- merged.push(sm);
+ if (createPanels) {
+ // create map panel if current map is not split, keep id
+ const panel = merged[i] || {...sm, layers: currentLayers};
+ merged[i] = {
+ ...panel,
+ layers: {...panel.layers, ...Object.fromEntries(entries.filter(([id]) => layerExists(id)))}
+ };
}
+ unmerged[i] = {...sm, layers: Object.fromEntries(entries.filter(([id]) => !layerExists(id)))};
});
return {
...state,
splitMaps: merged,
- splitMapsToBeMerged: [...state.splitMapsToBeMerged, ...unmerged]
+ splitMapsToBeMerged: unmerged.some(sm => Object.keys(sm.layers).length)
+ ? combineSplitMapsByIndex(state.splitMapsToBeMerged, unmerged)
+ : state.splitMapsToBeMerged
};
}
diff --git a/src/reducers/src/vis-state-updaters.ts b/src/reducers/src/vis-state-updaters.ts
index 1ea47ee9e..503e6f8a4 100644
--- a/src/reducers/src/vis-state-updaters.ts
+++ b/src/reducers/src/vis-state-updaters.ts
@@ -63,6 +63,7 @@ import {
applyTimeFilterEndFieldName,
applyFiltersToDatasets,
arrayInsert,
+ combineSplitMapsByIndex,
computeSplitMapLayers,
adjustValueToFilterDomain,
errorNotification,
@@ -3680,9 +3681,13 @@ function postMergeUpdater(mergedState: VisState, postMergerPayload: PostMergerPa
newLayers = mergedState.layers.filter(
l => l.config.dataId && newDataIds.includes(l.config.dataId)
);
+ // a layer already in a panel was merged from split maps, which decide the panels showing it
+ const layersNotInSplitMaps = newLayers.filter(
+ l => !mergedState.splitMaps.some(sm => l.id in sm.layers)
+ );
mergedState = {
...mergedState,
- splitMaps: addNewLayersToSplitMap(mergedState.splitMaps, newLayers)
+ splitMaps: addNewLayersToSplitMap(mergedState.splitMaps, layersNotInSplitMaps)
};
}
@@ -5660,8 +5665,13 @@ export function prepareStateForDatasetReplace<T extends VisState>(
// preserveLayerOrder
if (nextState.layerToBeMerged?.length) {
- // copy split maps to be merged, because it will be reset in remove layer
- nextState.splitMapsToBeMerged = serializedState?.splitMaps ?? [];
+ // copy split maps to be merged, because it will be reset in remove layer.
+ // Keep the ones of a dataset replaced a moment earlier and not merged back yet:
+ // its layers are no longer in the current split maps.
+ nextState.splitMapsToBeMerged = combineSplitMapsByIndex(
+ state.splitMapsToBeMerged,
+ serializedState?.splitMaps ?? []
+ );
nextState.layerOrder = [...preserveLayerOrder];
}
diff --git a/src/utils/src/split-map-utils.ts b/src/utils/src/split-map-utils.ts
index 969dcc434..f338b35c2 100644
--- a/src/utils/src/split-map-utils.ts
+++ b/src/utils/src/split-map-utils.ts
@@ -75,6 +75,20 @@ export function getInitialMapLayersForSplitMap(layers) {
);
}
+/**
+ * Combine the layers of the split map panels at the same index
+ * @param {Array<Object>} baseSplitMaps
+ * @param {Array<Object>} splitMaps layers override the ones of baseSplitMaps
+ * @returns {Array<Object>} new splitMaps, without holes
+ */
+export function combineSplitMapsByIndex(baseSplitMaps, splitMaps) {
+ return Array.from({length: Math.max(baseSplitMaps.length, splitMaps.length)}, (_, i) => ({
+ ...baseSplitMaps[i],
+ ...splitMaps[i],
+ layers: {...baseSplitMaps[i]?.layers, ...splitMaps[i]?.layers}
+ }));
+}
+
/**
* This method will get default splitMap settings based on existing layers
* @param {Array<Object>} layers
diff --git a/test/node/reducers/composer-state-test.js b/test/node/reducers/composer-state-test.js
index d2cd384f1..03e492e5d 100644
--- a/test/node/reducers/composer-state-test.js
+++ b/test/node/reducers/composer-state-test.js
@@ -11,11 +11,14 @@ import {processCsvData} from '@kepler.gl/processors';
import keplerGlReducer, {
addDataToMapUpdater,
replaceDataInMapUpdater,
+ combinedUpdaters,
fitBoundsUpdater,
INITIAL_UI_STATE,
visStateReducer,
mapStateReducer
} from '@kepler.gl/reducers';
+import {MapSplitMode} from '@kepler.gl/constants';
+import KeplerGlSchema from '@kepler.gl/schemas';
import {getTimeBins} from '@kepler.gl/utils';
import testCsvData, {sampleConfig, dataWithNulls} from 'test/fixtures/test-csv-data';
@@ -824,6 +827,148 @@ test('#composerStateReducer - replaceDataInMapUpdater: replacing a dataset with
t.end();
});
+test('#composerStateReducer - replaceDataInMapUpdater: replacing datasets back to back keeps the split map panels', t => {
+ const noLayersId = 'dataset_without_layers';
+ const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
+
+ let oldState = addDataToMapUpdater(state, {
+ payload: {
+ datasets: [
+ {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
+ {data: processCsvData(testCsvData), info: {id: noLayersId}}
+ ],
+ config: sampleConfig.config,
+ options: {autoCreateLayers: false}
+ }
+ });
+ oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
+ drainTasksForTesting();
+ const splitMaps = [
+ {layers: {'3zucml7': true, nob639j: false}},
+ {layers: {'3zucml7': false, nob639j: true}}
+ ];
+ t.deepEqual(oldState.visState.splitMaps, splitMaps, 'should start with one layer on each side');
+
+ // Refresh both datasets back to back, several times, the way an app refreshing
+ // every query does.
+ let nextState = oldState;
+ for (let refresh = 0; refresh < 3; refresh++) {
+ nextState = replaceDataInMapUpdater(nextState, {
+ payload: {
+ datasetToReplaceId: sampleConfig.dataId,
+ datasetToUse: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
+ options: {autoCreateLayers: false, centerMap: false}
+ }
+ });
+ nextState = replaceDataInMapUpdater(nextState, {
+ payload: {
+ datasetToReplaceId: noLayersId,
+ datasetToUse: {data: processCsvData(testCsvData), info: {id: noLayersId}},
+ options: {autoCreateLayers: false, centerMap: false}
+ }
+ });
+ nextState = {
+ ...nextState,
+ visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
+ };
+ drainTasksForTesting();
+
+ t.deepEqual(
+ nextState.visState.splitMaps,
+ splitMaps,
+ `should keep one layer on each side after refresh ${refresh + 1}`
+ );
+ }
+ t.end();
+});
+
+test('#composerStateReducer - replaceDataInMapUpdater: keeps the right panel of a dual map empty', t => {
+ const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
+ const config = {
+ ...sampleConfig.config,
+ config: {
+ ...sampleConfig.config.config,
+ visState: {...sampleConfig.config.config.visState, splitMaps: []},
+ mapState: {...sampleConfig.config.config.mapState, isSplit: false}
+ }
+ };
+
+ let oldState = addDataToMapUpdater(state, {
+ payload: {
+ datasets: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
+ config,
+ options: {autoCreateLayers: false}
+ }
+ });
+ oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
+ drainTasksForTesting();
+
+ // split the map: every layer on the left panel, nothing on the right one
+ oldState = combinedUpdaters.setMapSplitModeUpdater(oldState, {
+ payload: {mapSplitMode: MapSplitMode.DUAL_MAP}
+ });
+ const splitMaps = [{layers: {'3zucml7': true, nob639j: true}}, {layers: {}}];
+ t.deepEqual(oldState.visState.splitMaps, splitMaps, 'should split the map');
+
+ let nextState = replaceDataInMapUpdater(oldState, {
+ payload: {
+ datasetToReplaceId: sampleConfig.dataId,
+ datasetToUse: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
+ options: {autoCreateLayers: false, centerMap: false}
+ }
+ });
+ nextState = {
+ ...nextState,
+ visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
+ };
+ drainTasksForTesting();
+
+ t.deepEqual(nextState.visState.splitMaps, splitMaps, 'should keep the right panel empty');
+ t.end();
+});
+
+test('#composerStateReducer - addDataToMapUpdater: loads a dual map saved with an empty panel', t => {
+ const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
+ // saved from DUAL_MAP mode: every layer on the left panel, nothing on the right one
+ const splitMaps = [{layers: {'3zucml7': true, nob639j: true}}, {layers: {}}];
+ const config = {
+ ...sampleConfig.config,
+ config: {
+ ...sampleConfig.config.config,
+ visState: {...sampleConfig.config.config.visState, splitMaps}
+ }
+ };
+
+ let nextState = addDataToMapUpdater(state, {
+ payload: {
+ datasets: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
+ config,
+ options: {autoCreateLayers: false}
+ }
+ });
+
+ // the dataset is still loading, its layers are waiting to be merged
+ t.deepEqual(
+ nextState.visState.splitMaps,
+ [{layers: {}}, {layers: {}}],
+ 'should create both panels while the layers load'
+ );
+ const savedConfig = JSON.parse(JSON.stringify(KeplerGlSchema.getConfigToSave(nextState)));
+ t.doesNotThrow(
+ () => KeplerGlSchema.parseSavedConfig(savedConfig),
+ 'should save a config that loads while the layers load'
+ );
+
+ nextState = {
+ ...nextState,
+ visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
+ };
+ drainTasksForTesting();
+
+ t.deepEqual(nextState.visState.splitMaps, splitMaps, 'should keep the right panel empty');
+ t.end();
+});
+
test('#composerStateReducer - replaceDataInMapUpdater: syncedTimeFilter & match', t => {
const oldState = StateWSyncedTimeFilter;
const dataIdToReplace = 'dataset_to_replace';
diff --git a/test/node/reducers/vis-state-merger-test.js b/test/node/reducers/vis-state-merger-test.js
index 53157de4f..c71b6c528 100644
--- a/test/node/reducers/vis-state-merger-test.js
+++ b/test/node/reducers/vis-state-merger-test.js
@@ -1520,6 +1520,109 @@ test('VisStateMerger - mergeSplitMaps', t => {
'should create split maps panel, add current layer to splitMaps and merge split maps'
);
+ const emptySM = [{layers: {}}, {layers: {}}];
+ const testState5 = {
+ layers: [],
+ splitMaps: [],
+ splitMapsToBeMerged: []
+ };
+ t.deepEqual(
+ mergeSplitMaps(testState5, emptySM),
+ {
+ ...testState5,
+ splitMaps: emptySM,
+ splitMapsToBeMerged: []
+ },
+ 'should create split maps panel from split maps without layers'
+ );
+
+ const testState6 = {
+ layers: [{id: 'a', config: {isVisible: true}}],
+ splitMaps: [{layers: {a: true}}, {layers: {a: false}}],
+ splitMapsToBeMerged: []
+ };
+ t.deepEqual(
+ mergeSplitMaps(testState6, emptySM),
+ {
+ ...testState6,
+ splitMapsToBeMerged: []
+ },
+ 'should not add panels when merging split maps without layers into a split map'
+ );
+
+ t.end();
+});
+
+test('VisStateMerger - mergeSplitMaps -> keep panels index-aligned', t => {
+ const layerA = {id: 'a', config: {isVisible: true}};
+ const layerB = {id: 'b', config: {isVisible: true}};
+
+ // saved from DUAL_MAP mode: every layer on the left panel, nothing on the right one
+ const dualMap = [{layers: {a: true}}, {layers: {}}];
+ const loading = mergeSplitMaps({layers: [], splitMaps: [], splitMapsToBeMerged: []}, dualMap);
+ t.deepEqual(
+ loading.splitMaps,
+ [{layers: {}}, {layers: {}}],
+ 'should create both panels while layer a is not loaded, without a hole on the left'
+ );
+ t.deepEqual(loading.splitMapsToBeMerged, dualMap, 'should wait for layer a in the left panel');
+ t.deepEqual(
+ mergeSplitMaps(
+ {...loading, layers: [layerA], splitMapsToBeMerged: []},
+ loading.splitMapsToBeMerged
+ ).splitMaps,
+ dualMap,
+ 'should show layer a only in the left panel once loaded'
+ );
+
+ t.deepEqual(
+ mergeSplitMaps(
+ {
+ layers: [],
+ splitMaps: [{layers: {}}, {layers: {}}],
+ splitMapsToBeMerged: [{layers: {p: true}}, {layers: {p: false}}]
+ },
+ [{layers: {q: true}}, {layers: {q: false}}]
+ ).splitMapsToBeMerged,
+ [{layers: {p: true, q: true}}, {layers: {p: false, q: false}}],
+ 'should add layers waiting to be merged to the panel at the same index'
+ );
+
+ t.deepEqual(
+ mergeSplitMaps(
+ {layers: [layerA], splitMaps: [{layers: {}}, {layers: {}}], splitMapsToBeMerged: []},
+ [{layers: {a: true}}, {layers: {b: true}}]
+ ).splitMapsToBeMerged,
+ [{layers: {}}, {layers: {b: true}}],
+ 'should keep layer b waiting in the right panel, without a hole on the left'
+ );
+
+ t.deepEqual(
+ mergeSplitMaps({layers: [layerA], splitMaps: [], splitMapsToBeMerged: []}, [
+ {layers: {}},
+ {layers: {}}
+ ]).splitMaps,
+ [{layers: {a: true}}, {layers: {a: true}}],
+ 'should add current layers to panels created without layers'
+ );
+
+ t.deepEqual(
+ mergeSplitMaps({layers: [layerA, layerB], splitMaps: [], splitMapsToBeMerged: []}, [
+ {layers: {a: true, b: true}},
+ {layers: {b: true}}
+ ]).splitMaps,
+ [{layers: {a: true, b: true}}, {layers: {b: true}}],
+ 'should not add a layer of the merged split maps to a panel that does not list it'
+ );
+
+ const config = [{layers: {a: true}}, {layers: {}}];
+ const configBefore = cloneDeep(config);
+ const merged = mergeSplitMaps({layers: [layerA], splitMaps: [], splitMapsToBeMerged: []}, config);
+ const mergedBefore = cloneDeep(merged);
+ mergeSplitMaps(merged, [{layers: {a: false}}, {layers: {a: true}}]);
+ t.deepEqual(merged, mergedBefore, 'should not change the split maps of the previous state');
+ t.deepEqual(config, configBefore, 'should not change the merged split maps');
+
t.end();
});