Skip to content

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

fix(layer-panel): isolate layer group actions (#3851)

Igor Dykhta2bb43c639212
diff --git a/src/components/src/dnd-context.tsx b/src/components/src/dnd-context.tsx
index c29218b06..0cc13f373 100644
--- a/src/components/src/dnd-context.tsx
+++ b/src/components/src/dnd-context.tsx
@@ -200,7 +200,11 @@ function DndContextFactory(
) : null}
{activeElementType === 'layerGroup' && activeElementObject ? (
<DragItem>
- <LayerGroupHeader layerGroup={activeElementObject as LayerOrderGroup} />
+ <LayerGroupHeader
+ layerGroup={activeElementObject as LayerOrderGroup}
+ updateLayerGroup={nop}
+ removeLayerGroup={nop}
+ />
</DragItem>
) : null}
</DragOverlay>
diff --git a/src/components/src/side-panel/layer-panel/layer-group-header.tsx b/src/components/src/side-panel/layer-panel/layer-group-header.tsx
index f50b2f1fc..efa3fce52 100644
--- a/src/components/src/side-panel/layer-panel/layer-group-header.tsx
+++ b/src/components/src/side-panel/layer-panel/layer-group-header.tsx
@@ -5,7 +5,7 @@ import React, {useCallback, useState, useEffect, useRef} from 'react';
import {useDispatch} from 'react-redux';
import styled from 'styled-components';
-import {updateLayerGroup, removeLayerGroup} from '@kepler.gl/actions';
+import {ActionHandler, VisStateActions} from '@kepler.gl/actions';
import {LayerOrderGroup} from '@kepler.gl/types';
import {getFlatLayerOrder} from '@kepler.gl/reducers';
@@ -129,6 +129,8 @@ export type LayerGroupHeaderProps = {
layerGroup: LayerOrderGroup;
isLayerGroupContentOpen?: boolean;
onToggleLayerGroupContent?: () => void;
+ updateLayerGroup?: ActionHandler<typeof VisStateActions.updateLayerGroup>;
+ removeLayerGroup?: ActionHandler<typeof VisStateActions.removeLayerGroup>;
listeners?: any;
className?: string;
};
@@ -142,6 +144,8 @@ function LayerGroupHeaderFactory(
layerGroup,
onToggleLayerGroupContent,
isLayerGroupContentOpen,
+ updateLayerGroup,
+ removeLayerGroup,
listeners,
className
}) => {
@@ -163,16 +167,38 @@ function LayerGroupHeaderFactory(
return () => document.removeEventListener('mousedown', handleClickOutside);
}, [showConfirmation]);
+ const updateGroup: ActionHandler<typeof VisStateActions.updateLayerGroup> = useCallback(
+ payload => {
+ if (updateLayerGroup) {
+ updateLayerGroup(payload);
+ } else {
+ dispatch(VisStateActions.updateLayerGroup(payload));
+ }
+ },
+ [dispatch, updateLayerGroup]
+ );
+
+ const removeGroup: ActionHandler<typeof VisStateActions.removeLayerGroup> = useCallback(
+ payload => {
+ if (removeLayerGroup) {
+ removeLayerGroup(payload);
+ } else {
+ dispatch(VisStateActions.removeLayerGroup(payload));
+ }
+ },
+ [dispatch, removeLayerGroup]
+ );
+
const onUpdateLabel = useCallback(
event => {
- dispatch(updateLayerGroup({id, options: {label: event.target.value}}));
+ updateGroup({id, options: {label: event.target.value}});
},
- [dispatch, id]
+ [id, updateGroup]
);
const onToggleVisibility = useCallback(() => {
- dispatch(updateLayerGroup({id, options: {isVisible: !layerGroup.isVisible}}));
- }, [dispatch, id, layerGroup.isVisible]);
+ updateGroup({id, options: {isVisible: !layerGroup.isVisible}});
+ }, [id, layerGroup.isVisible, updateGroup]);
const onDelete = useCallback(
(e: React.MouseEvent) => {
@@ -180,19 +206,19 @@ function LayerGroupHeaderFactory(
if (layerCount > 0) {
setShowConfirmation(true);
} else {
- dispatch(removeLayerGroup({id}));
+ removeGroup({id});
}
},
- [dispatch, id, layerCount]
+ [id, layerCount, removeGroup]
);
const onConfirmDelete = useCallback(
(e: React.MouseEvent) => {
e.stopPropagation();
- dispatch(removeLayerGroup({id}));
+ removeGroup({id});
setShowConfirmation(false);
},
- [dispatch, id]
+ [id, removeGroup]
);
const VisibilityIcon = layerGroup.isVisible ? EyeSeen : EyeUnseen;
diff --git a/src/components/src/side-panel/layer-panel/layer-list.tsx b/src/components/src/side-panel/layer-panel/layer-list.tsx
index c118ba97c..5e8a07a0d 100644
--- a/src/components/src/side-panel/layer-panel/layer-list.tsx
+++ b/src/components/src/side-panel/layer-panel/layer-list.tsx
@@ -222,8 +222,9 @@ function LayerListFactory(
layers: Layer[];
panelProps: any;
layerActions: any;
+ visStateActions: typeof VisStateActions;
disabled?: boolean;
- }> = ({layerGroup, layers, panelProps, layerActions, disabled}) => {
+ }> = ({layerGroup, layers, panelProps, layerActions, visStateActions, disabled}) => {
const {attributes, isDragging, listeners, setNodeRef, transform, transition} = useSortable({
id: layerGroup.id,
data: {type: SORTABLE_LAYER_GROUP_TYPE},
@@ -263,6 +264,8 @@ function LayerListFactory(
layerGroup={layerGroup}
onToggleLayerGroupContent={onToggle}
isLayerGroupContentOpen={isSectionOpen}
+ updateLayerGroup={visStateActions.updateLayerGroup}
+ removeLayerGroup={visStateActions.removeLayerGroup}
listeners={listeners}
/>
</div>
@@ -406,6 +409,7 @@ function LayerListFactory(
layers={layers}
panelProps={panelProps}
layerActions={layerActions}
+ visStateActions={visStateActions}
disabled={!isSortable}
/>
)
diff --git a/test/browser/components/side-panel/layer-list.spec.js b/test/browser/components/side-panel/layer-list.spec.js
index 4bad462ea..2dc39ff05 100644
--- a/test/browser/components/side-panel/layer-list.spec.js
+++ b/test/browser/components/side-panel/layer-list.spec.js
@@ -3,6 +3,8 @@
import React from 'react';
import cloneDeep from 'es-toolkit/compat/cloneDeep';
+import {bindActionCreators, createStore} from 'redux';
+import {Provider} from 'react-redux';
import {fireEvent, screen} from '@testing-library/react';
import {dataTestIds} from '@kepler.gl/constants';
@@ -12,10 +14,15 @@ import {
UIStateActions,
MapStateActions,
addDataToMap,
+ forwardTo,
keplerGlInit
} from '@kepler.gl/actions';
import {processCsvData} from '@kepler.gl/processors';
-import {keplerGlReducerCore as keplerGlReducer} from '@kepler.gl/reducers';
+import {
+ getLayerGroupFromLayerOrder,
+ keplerGlReducer as rootReducer,
+ keplerGlReducerCore as keplerGlReducer
+} from '@kepler.gl/reducers';
import {renderWithTheme} from '../../../helpers/component-jest-utils';
import testLayerData from '../../../fixtures/test-layer-data';
@@ -78,6 +85,32 @@ const LayerList = appInjector.get(LayerListFactory);
const StateWMultiH3Layers = mockStateWithMultipleH3Layers();
+function createInstanceState(instanceId) {
+ const state = mockStateWithMultipleH3Layers();
+ const [sharedGroupLayer, instanceGroupLayer] = state.visState.layers;
+
+ sharedGroupLayer.config.isVisible = true;
+ instanceGroupLayer.config.isVisible = true;
+ state.visState.layerOrder = [
+ {
+ id: 'shared-group',
+ label: `${instanceId} shared group`,
+ isVisible: true,
+ isIncludedInLegend: true,
+ layerOrder: [sharedGroupLayer.id]
+ },
+ {
+ id: `${instanceId}-only-group`,
+ label: `${instanceId} only group`,
+ isVisible: true,
+ isIncludedInLegend: true,
+ layerOrder: [instanceGroupLayer.id]
+ }
+ ];
+
+ return state;
+}
+
const defaultProps = {
datasets: StateWMultiH3Layers.visState.datasets,
layerClasses: StateWMultiH3Layers.visState.layerClasses,
@@ -88,6 +121,43 @@ const defaultProps = {
mapStateActions: MapStateActions
};
+const firstMapId = 'first-map';
+const secondMapId = 'second-map';
+
+function renderLayerListForInstances({emptySharedGroup = false} = {}) {
+ const firstMap = createInstanceState(firstMapId);
+ if (emptySharedGroup) {
+ firstMap.visState.layerOrder[0].layerOrder = [];
+ firstMap.visState.layerOrder.push(firstMap.visState.layers[0].id);
+ }
+ const store = createStore(rootReducer, {
+ [firstMapId]: firstMap,
+ [secondMapId]: createInstanceState(secondMapId)
+ });
+ const firstMapVisState = store.getState()[firstMapId].visState;
+ const secondMapVisState = store.getState()[secondMapId].visState;
+ const firstMapActions = bindActionCreators(
+ VisStateActions,
+ forwardTo(firstMapId, store.dispatch)
+ );
+
+ const {container} = renderWithTheme(
+ <Provider store={store}>
+ <LayerList
+ {...defaultProps}
+ datasets={firstMapVisState.datasets}
+ layerClasses={firstMapVisState.layerClasses}
+ layerOrder={firstMapVisState.layerOrder}
+ layers={firstMapVisState.layers}
+ visStateActions={firstMapActions}
+ isSortable={false}
+ />
+ </Provider>
+ );
+
+ return {container, store, firstMapVisState, secondMapVisState};
+}
+
// jest.mock('@kepler.gl/actions');
describe('Components -> SidePanel -> LayerPanel -> LayerList', () => {
@@ -145,4 +215,94 @@ describe('Components -> SidePanel -> LayerPanel -> LayerList', () => {
expect(removeLayer).toHaveBeenCalled();
});
+
+ it('keeps grouped-layer visibility isolated between map instances', () => {
+ const {container, store} = renderLayerListForInstances();
+
+ fireEvent.click(container.querySelectorAll('.layer-group__visibility-toggle svg')[0]);
+
+ const firstMapState = store.getState()[firstMapId].visState;
+ const secondMapState = store.getState()[secondMapId].visState;
+ const firstMapSharedGroup = getLayerGroupFromLayerOrder(
+ firstMapState.layerOrder,
+ 'shared-group'
+ );
+ const secondMapSharedGroup = getLayerGroupFromLayerOrder(
+ secondMapState.layerOrder,
+ 'shared-group'
+ );
+ const firstMapOnlyGroup = getLayerGroupFromLayerOrder(
+ firstMapState.layerOrder,
+ `${firstMapId}-only-group`
+ );
+ const secondMapOnlyGroup = getLayerGroupFromLayerOrder(
+ secondMapState.layerOrder,
+ `${secondMapId}-only-group`
+ );
+
+ expect(firstMapSharedGroup.isVisible).toBe(false);
+ expect(firstMapState.layers[0].config.isVisible).toBe(false);
+ expect(firstMapOnlyGroup.isVisible).toBe(true);
+ expect(firstMapState.layers[1].config.isVisible).toBe(true);
+ expect(secondMapSharedGroup.isVisible).toBe(true);
+ expect(secondMapState.layers[0].config.isVisible).toBe(true);
+ expect(secondMapOnlyGroup.isVisible).toBe(true);
+ expect(secondMapState.layers[1].config.isVisible).toBe(true);
+ });
+
+ it('keeps group renaming isolated between map instances', () => {
+ const {store, firstMapVisState, secondMapVisState} = renderLayerListForInstances();
+
+ fireEvent.change(screen.getByDisplayValue(`${firstMapId} shared group`), {
+ target: {value: 'Renamed group'}
+ });
+
+ const firstMapState = store.getState()[firstMapId].visState;
+ const secondMapState = store.getState()[secondMapId].visState;
+
+ expect(getLayerGroupFromLayerOrder(firstMapState.layerOrder, 'shared-group').label).toBe(
+ 'Renamed group'
+ );
+ expect(firstMapState.layerOrder[1]).toEqual(firstMapVisState.layerOrder[1]);
+ expect(firstMapState.layers).toEqual(firstMapVisState.layers);
+ expect(getLayerGroupFromLayerOrder(secondMapState.layerOrder, 'shared-group').label).toBe(
+ `${secondMapId} shared group`
+ );
+ expect(secondMapState).toEqual(secondMapVisState);
+ });
+
+ it('keeps confirmed group and child-layer deletion isolated between map instances', () => {
+ const {container, store, firstMapVisState, secondMapVisState} =
+ renderLayerListForInstances();
+
+ fireEvent.click(container.querySelector('.layer-group__delete svg'));
+
+ expect(screen.getByText('Remove group with layers?')).toBeInTheDocument();
+ expect(store.getState()[firstMapId].visState).toEqual(firstMapVisState);
+ expect(store.getState()[secondMapId].visState).toEqual(secondMapVisState);
+
+ fireEvent.click(screen.getByRole('button', {name: 'Remove'}));
+
+ const firstMapState = store.getState()[firstMapId].visState;
+
+ expect(firstMapState.layerOrder).toEqual([firstMapVisState.layerOrder[1]]);
+ expect(firstMapState.layers.map(layer => layer.id)).toEqual([firstMapVisState.layers[1].id]);
+ expect(store.getState()[secondMapId].visState).toEqual(secondMapVisState);
+ expect(screen.queryByText('Remove group with layers?')).not.toBeInTheDocument();
+ });
+
+ it('keeps immediate empty-group deletion isolated between map instances', () => {
+ const {container, store, firstMapVisState, secondMapVisState} =
+ renderLayerListForInstances({emptySharedGroup: true});
+
+ fireEvent.click(container.querySelector('.layer-group__delete svg'));
+
+ const firstMapState = store.getState()[firstMapId].visState;
+
+ expect(screen.queryByText('Remove group with layers?')).not.toBeInTheDocument();
+ expect(screen.queryByRole('button', {name: 'Remove'})).not.toBeInTheDocument();
+ expect(firstMapState.layerOrder).toEqual(firstMapVisState.layerOrder.slice(1));
+ expect(firstMapState.layers).toEqual(firstMapVisState.layers);
+ expect(store.getState()[secondMapId].visState).toEqual(secondMapVisState);
+ });
});