Skip to content

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

feat(interactions): fade layer opacity by zoom (#3780)

Igor Dykhta747ca0deb274
diff --git a/src/components/src/index.ts b/src/components/src/index.ts
index 6af8ba47f..26352c56a 100644
--- a/src/components/src/index.ts
+++ b/src/components/src/index.ts
@@ -152,6 +152,7 @@ export {default as BrushConfigFactory} from './side-panel/interaction-panel/brus
export {default as TooltipConfigFactory} from './side-panel/interaction-panel/tooltip-config';
export {default as GeocoderConfigFactory} from './side-panel/interaction-panel/geocoder-config';
export {default as LegendConfigFactory} from './side-panel/interaction-panel/legend-config';
+export {default as ZoomOpacityConfigFactory} from './side-panel/interaction-panel/zoom-opacity-config';
export {default as DndContextFactory} from './dnd-context';
export {default as CustomPanelsFactory} from './side-panel/custom-panel';
diff --git a/src/components/src/side-panel/interaction-manager.tsx b/src/components/src/side-panel/interaction-manager.tsx
index d43ba4259..34dea235e 100644
--- a/src/components/src/side-panel/interaction-manager.tsx
+++ b/src/components/src/side-panel/interaction-manager.tsx
@@ -4,18 +4,33 @@
import React from 'react';
import {useIntl} from 'react-intl';
-import {InteractionConfig, LayerOrder} from '@kepler.gl/types';
+import {InteractionConfig, LayerOrder, MapState} from '@kepler.gl/types';
import {UIStateActions, VisStateActions} from '@kepler.gl/actions';
import {Datasets} from '@kepler.gl/table';
import {Layer} from '@kepler.gl/layers';
import InteractionPanelFactory from './interaction-panel/interaction-panel';
import LegendConfigFactory from './interaction-panel/legend-config';
+import ZoomOpacityConfigFactory from './interaction-panel/zoom-opacity-config';
import PanelTitleFactory from './panel-title';
import {PanelHeaderActionIcon} from './panel-header-action';
import {PanelMeta} from './common/types';
+/** Right-hand map when split viewports are independent; otherwise the shared map zoom. */
+function fadeOnZoomMarkerZoom(mapState?: MapState): number | undefined {
+ const rightZoom = mapState?.splitMapViewports?.[1]?.zoom;
+ if (
+ mapState?.isSplit &&
+ !mapState.isViewportSynced &&
+ mapState.splitMapViewports.length > 1 &&
+ Number.isFinite(rightZoom)
+ ) {
+ return rightZoom;
+ }
+ return mapState?.zoom;
+}
+
type InteractionManagerProps = {
interactionConfig: InteractionConfig;
datasets: Datasets;
@@ -25,6 +40,7 @@ type InteractionManagerProps = {
layers?: readonly Layer[];
layerOrder?: LayerOrder;
mapLegendActive?: boolean;
+ mapState?: MapState;
actionIcons?: {
settings?: PanelHeaderActionIcon;
};
@@ -33,12 +49,18 @@ type InteractionManagerProps = {
};
};
-InteractionManagerFactory.deps = [InteractionPanelFactory, PanelTitleFactory, LegendConfigFactory];
+InteractionManagerFactory.deps = [
+ InteractionPanelFactory,
+ PanelTitleFactory,
+ LegendConfigFactory,
+ ZoomOpacityConfigFactory
+];
function InteractionManagerFactory(
InteractionPanel: ReturnType<typeof InteractionPanelFactory>,
PanelTitle: ReturnType<typeof PanelTitleFactory>,
- LegendConfig: ReturnType<typeof LegendConfigFactory>
+ LegendConfig: ReturnType<typeof LegendConfigFactory>,
+ ZoomOpacityConfig: ReturnType<typeof ZoomOpacityConfigFactory>
) {
const InteractionManager: React.FC<InteractionManagerProps> = ({
interactionConfig,
@@ -49,6 +71,7 @@ function InteractionManagerFactory(
layers,
layerOrder,
mapLegendActive,
+ mapState,
actionIcons,
interactionConfigIcons
}) => {
@@ -61,9 +84,9 @@ function InteractionManagerFactory(
className="interaction-manager-title"
title={intl.formatMessage({id: panelMetadata.label})}
/>
- {Object.keys(interactionConfig).map(key =>
- key === 'legend' ? (
- layers ? (
+ {Object.keys(interactionConfig).map(key => {
+ if (key === 'legend') {
+ return layers ? (
<LegendConfig
key={key}
layers={layers}
@@ -74,8 +97,21 @@ function InteractionManagerFactory(
mapLegendActive={mapLegendActive}
actionIcons={actionIcons}
/>
- ) : null
- ) : (
+ ) : null;
+ }
+ if (key === 'zoomOpacity') {
+ return layers ? (
+ <ZoomOpacityConfig
+ key={key}
+ layers={layers}
+ zoomOpacityConfig={interactionConfig.zoomOpacity}
+ zoom={fadeOnZoomMarkerZoom(mapState)}
+ visStateActions={visStateActions}
+ actionIcons={actionIcons}
+ />
+ ) : null;
+ }
+ return (
<InteractionPanel
key={key}
datasets={datasets}
@@ -85,8 +121,8 @@ function InteractionManagerFactory(
actionIcons={actionIcons}
interactionConfigIcons={interactionConfigIcons}
/>
- )
- )}
+ );
+ })}
</div>
);
};
diff --git a/src/components/src/side-panel/interaction-panel/zoom-opacity-config.tsx b/src/components/src/side-panel/interaction-panel/zoom-opacity-config.tsx
new file mode 100644
index 000000000..673ecf363
--- /dev/null
+++ b/src/components/src/side-panel/interaction-panel/zoom-opacity-config.tsx
@@ -0,0 +1,326 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, {ComponentType, useCallback, useMemo, useState} from 'react';
+import styled from 'styled-components';
+import classnames from 'classnames';
+import {useIntl} from 'react-intl';
+
+import {VisStateActions} from '@kepler.gl/actions';
+import {generateHashId} from '@kepler.gl/common-utils';
+import {FormattedMessage} from '@kepler.gl/localization';
+import {Layer} from '@kepler.gl/layers';
+import {DEFAULT_ZOOM_OPACITY_STOPS, setZoomOpacityStop} from '@kepler.gl/reducers';
+import {InteractionConfig, ZoomOpacityController, ZoomOpacityStops} from '@kepler.gl/types';
+
+import ZoomOpacitySlider from './zoom-opacity-slider';
+
+import ItemSelector from '../../common/item-selector/item-selector';
+import {Delete, Settings, ZoomIn} from '../../common/icons';
+import PanelHeaderActionFactory, {PanelHeaderActionIcon} from '../panel-header-action';
+import Switch from '../../common/switch';
+import {
+ Button,
+ PanelContent,
+ PanelHeaderContent,
+ PanelHeaderTitle,
+ PanelLabel,
+ SidePanelSection,
+ StyledPanelHeader
+} from '../../common/styled-components';
+
+const StyledZoomOpacityPanel = styled.div`
+ padding-bottom: 6px;
+ contain: layout paint;
+`;
+
+const HeaderActions = styled.div`
+ display: flex;
+ align-items: center;
+ gap: 24px;
+ margin-right: -10px;
+ padding-right: ${props => (props.theme.panelHeaderHeight - props.theme.switchHeight) / 2}px;
+
+ .kg-checkbox {
+ margin-left: 0;
+ margin-right: -${props => props.theme.switchLabelMargin}px;
+ }
+`;
+
+const Hint = styled.div`
+ color: ${props => props.theme.subtextColor};
+ font-size: 11px;
+ line-height: 1.4;
+ margin-bottom: 12px;
+`;
+
+const ControllerCard = styled.div`
+ border-top: 1px solid ${props => props.theme.panelBorderColor};
+ margin-top: 8px;
+ padding-top: 10px;
+
+ &:last-child {
+ margin-bottom: 12px;
+ }
+`;
+
+const LayersRow = styled.div`
+ align-items: center;
+ display: flex;
+ justify-content: space-between;
+ margin-bottom: 4px;
+
+ .side-panel-panel__label {
+ margin-bottom: 0;
+ }
+`;
+
+const RemoveButton = styled(Button)`
+ padding: 0;
+`;
+
+const EMPTY_CONTROLLERS: ZoomOpacityController[] = [];
+
+const DEFAULT_ZOOM_OPACITY_CONFIG: InteractionConfig['zoomOpacity'] = {
+ id: 'zoomOpacity',
+ label: 'interactions.fadeOnZoom',
+ enabled: false,
+ config: {controllers: EMPTY_CONTROLLERS}
+};
+
+type ZoomOpacityConfigProps = {
+ layers: readonly Layer[];
+ zoom?: number;
+ zoomOpacityConfig?: InteractionConfig['zoomOpacity'];
+ visStateActions: typeof VisStateActions;
+ actionIcons?: {
+ settings?: PanelHeaderActionIcon;
+ };
+};
+
+const defaultActionIcons = {
+ settings: Settings
+};
+
+ZoomOpacityConfigFactory.deps = [PanelHeaderActionFactory];
+
+function ZoomOpacityConfigFactory(
+ PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>
+): ComponentType<ZoomOpacityConfigProps> {
+ const ZoomOpacityConfig: React.FC<ZoomOpacityConfigProps> = ({
+ layers,
+ zoom,
+ zoomOpacityConfig,
+ visStateActions,
+ actionIcons: customActionIcons
+ }) => {
+ const actionIcons = {...defaultActionIcons, ...customActionIcons};
+ const intl = useIntl();
+ const [isConfigActive, setIsConfigActive] = useState(false);
+ const zoomInteraction = zoomOpacityConfig ?? DEFAULT_ZOOM_OPACITY_CONFIG;
+ const enabled = zoomInteraction.enabled !== false;
+ const controllers = zoomInteraction.config?.controllers ?? EMPTY_CONTROLLERS;
+
+ const togglePanelActive = useCallback(() => {
+ setIsConfigActive(prev => !prev);
+ }, []);
+
+ const commit = useCallback(
+ (next: Partial<InteractionConfig['zoomOpacity']>) => {
+ visStateActions.interactionConfigChange({
+ ...zoomInteraction,
+ ...next,
+ config: next.config || zoomInteraction.config
+ });
+ },
+ [visStateActions, zoomInteraction]
+ );
+
+ const onToggleEnabled = useCallback(() => {
+ commit({enabled: !enabled});
+ }, [commit, enabled]);
+
+ const updateControllers = useCallback(
+ (nextControllers: ZoomOpacityController[]) => {
+ commit({
+ config: {
+ ...zoomInteraction.config,
+ controllers: nextControllers
+ }
+ });
+ },
+ [commit, zoomInteraction.config]
+ );
+
+ const onAddController = useCallback(() => {
+ updateControllers([
+ ...controllers,
+ {
+ id: generateHashId(6),
+ layerIds: [],
+ stops: {...DEFAULT_ZOOM_OPACITY_STOPS}
+ }
+ ]);
+ }, [controllers, updateControllers]);
+
+ const onDeleteController = useCallback(
+ (controllerId: string) => {
+ updateControllers(controllers.filter(controller => controller.id !== controllerId));
+ },
+ [controllers, updateControllers]
+ );
+
+ const onLayersChange = useCallback(
+ (controllerId: string, selected: readonly Layer[] | null) => {
+ const layerIds = (selected || []).map(layer => layer.id);
+ updateControllers(
+ controllers.map(controller =>
+ controller.id === controllerId ? {...controller, layerIds} : controller
+ )
+ );
+ },
+ [controllers, updateControllers]
+ );
+
+ const onStopChange = useCallback(
+ (controllerId: string, key: keyof ZoomOpacityStops, value: number) => {
+ if (!Number.isFinite(value)) {
+ return;
+ }
+ updateControllers(
+ controllers.map(controller =>
+ controller.id === controllerId
+ ? {...controller, stops: setZoomOpacityStop(controller.stops, key, value)}
+ : controller
+ )
+ );
+ },
+ [controllers, updateControllers]
+ );
+
+ const assignedElsewhere = useMemo(() => {
+ const byController = new Map<string, Set<string>>();
+ controllers.forEach(controller => {
+ const ids = new Set<string>();
+ controllers.forEach(other => {
+ if (other.id !== controller.id) {
+ other.layerIds.forEach(id => ids.add(id));
+ }
+ });
+ byController.set(controller.id, ids);
+ });
+ return byController;
+ }, [controllers]);
+
+ return (
+ <StyledZoomOpacityPanel className="interaction-panel interaction-zoom-opacity">
+ <StyledPanelHeader
+ className={classnames('interaction-zoom-opacity__header', {'is-open': isConfigActive})}
+ onClick={togglePanelActive}
+ >
+ <PanelHeaderContent className="interaction-zoom-opacity__header__content">
+ <div className="interaction-zoom-opacity__header__icon icon">
+ <ZoomIn height="16px" />
+ </div>
+ <div className="interaction-zoom-opacity__header__title">
+ <PanelHeaderTitle>
+ <FormattedMessage id="interactions.fadeOnZoom" />
+ </PanelHeaderTitle>
+ </div>
+ </PanelHeaderContent>
+ <HeaderActions
+ className="interaction-zoom-opacity__header__actions"
+ onClick={event => event.stopPropagation()}
+ >
+ <PanelHeaderAction
+ className={classnames('interaction-zoom-opacity__enable-config', {
+ 'is-open': isConfigActive
+ })}
+ id="zoom-opacity-config"
+ tooltip="tooltip.interactionSettings"
+ active={isConfigActive}
+ flush
+ onClick={togglePanelActive}
+ IconComponent={actionIcons.settings}
+ />
+ <Switch
+ checked={enabled}
+ id="zoom-opacity-toggle"
+ onChange={onToggleEnabled}
+ secondary
+ />
+ </HeaderActions>
+ </StyledPanelHeader>
+ {isConfigActive ? (
+ <PanelContent className="interaction-zoom-opacity__content">
+ <Hint>
+ <FormattedMessage id="interactions.fadeOnZoomHint" />
+ </Hint>
+ <Button
+ type="button"
+ secondary
+ small
+ className="interaction-zoom-opacity__add"
+ onClick={onAddController}
+ >
+ <FormattedMessage id="interactions.fadeOnZoomAdd" />
+ </Button>
+ {controllers.map(controller => {
+ const taken = assignedElsewhere.get(controller.id) || new Set<string>();
+ const options = layers.filter(layer => !taken.has(layer.id));
+ const selected = layers.filter(layer => controller.layerIds.includes(layer.id));
+ return (
+ <ControllerCard
+ key={controller.id}
+ className="interaction-zoom-opacity__controller"
+ data-testid={`zoom-opacity-controller-${controller.id}`}
+ >
+ <SidePanelSection>
+ <LayersRow>
+ <PanelLabel>
+ <FormattedMessage id="interactions.fadeOnZoomLayers" />
+ </PanelLabel>
+ <RemoveButton
+ type="button"
+ link
+ small
+ className="interaction-zoom-opacity__delete"
+ title={intl.formatMessage({id: 'interactions.fadeOnZoomDelete'})}
+ onClick={() => onDeleteController(controller.id)}
+ >
+ <Delete height="12px" />
+ </RemoveButton>
+ </LayersRow>
+ <ItemSelector
+ options={options}
+ selectedItems={selected}
+ onChange={items =>
+ onLayersChange(controller.id, (items as Layer[] | null) || [])
+ }
+ searchable={true}
+ multiSelect={true}
+ getOptionValue={(layer: Layer) => layer.id}
+ displayOption={(layer: Layer) => layer.config?.label || layer.id}
+ placeholder="placeholder.selectLayer"
+ inputTheme="secondary"
+ />
+ </SidePanelSection>
+ <ZoomOpacitySlider
+ idPrefix={`zoom-opacity-${controller.id}`}
+ stops={controller.stops}
+ zoom={zoom}
+ onChange={(key, value) => onStopChange(controller.id, key, value)}
+ />
+ </ControllerCard>
+ );
+ })}
+ </PanelContent>
+ ) : null}
+ </StyledZoomOpacityPanel>
+ );
+ };
+
+ return ZoomOpacityConfig;
+}
+
+export default ZoomOpacityConfigFactory;
diff --git a/src/components/src/side-panel/interaction-panel/zoom-opacity-slider.tsx b/src/components/src/side-panel/interaction-panel/zoom-opacity-slider.tsx
new file mode 100644
index 000000000..14cf94524
--- /dev/null
+++ b/src/components/src/side-panel/interaction-panel/zoom-opacity-slider.tsx
@@ -0,0 +1,299 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, {useCallback, useEffect, useRef, useState} from 'react';
+import styled from 'styled-components';
+import {useIntl} from 'react-intl';
+
+import {ZOOM_OPACITY_RANGE} from '@kepler.gl/reducers';
+import {ZoomOpacityStops} from '@kepler.gl/types';
+
+const HANDLE_SIZE = 6;
+const PAD_TOP = 8;
+const CURVE_HEIGHT = 18;
+const LABEL_HEIGHT = 9;
+const PLOT_HEIGHT = PAD_TOP + CURVE_HEIGHT + HANDLE_SIZE / 2 + 1 + LABEL_HEIGHT;
+const PAD_X = 10;
+
+const HANDLES: {key: keyof ZoomOpacityStops; labelId: string}[] = [
+ {key: 'appear', labelId: 'interactions.fadeOnZoomAppear'},
+ {key: 'full', labelId: 'interactions.fadeOnZoomFullStart'},
+ {key: 'fade', labelId: 'interactions.fadeOnZoomFullEnd'},
+ {key: 'gone', labelId: 'interactions.fadeOnZoomDisappear'}
+];
+
+const SliderRoot = styled.div`
+ margin-top: 4px;
+ user-select: none;
+`;
+
+const Plot = styled.div`
+ height: ${PLOT_HEIGHT}px;
+ position: relative;
+ touch-action: none;
+`;
+
+const Envelope = styled.svg`
+ color: ${props => props.theme.textColor};
+ display: block;
+ height: 100%;
+ overflow: visible;
+ width: 100%;
+`;
+
+const AxisLabel = styled.span<{$edge: 'left' | 'right'}>`
+ color: ${props => props.theme.subtextColor};
+ font-size: 9px;
+ left: ${props => (props.$edge === 'left' ? 0 : 'auto')};
+ line-height: ${LABEL_HEIGHT}px;
+ pointer-events: none;
+ position: absolute;
+ right: ${props => (props.$edge === 'right' ? 0 : 'auto')};
+ top: ${PAD_TOP + CURVE_HEIGHT + HANDLE_SIZE / 2 + 1}px;
+`;
+
+const Handle = styled.button<{$active: boolean; $x: number; $y: number}>`
+ background: ${props => props.theme.sliderHandleColor};
+ border: 1px solid
+ ${props =>
+ props.$active ? props.theme.selectBorderColor : props.theme.sliderInactiveBorderColor};
+ border-radius: 50%;
+ box-shadow: ${props => props.theme.sliderHandleShadow};
+ cursor: grab;
+ height: ${HANDLE_SIZE}px;
+ left: ${props => props.$x}px;
+ margin: 0;
+ padding: 0;
+ position: absolute;
+ top: ${props => props.$y}px;
+ transform: translate(-50%, -50%);
+ width: ${HANDLE_SIZE}px;
+ z-index: ${props => (props.$active ? 3 : 1)};
+
+ &:hover,
+ &:focus {
+ background: ${props => props.theme.sliderHandleHoverColor};
+ outline: none;
+ z-index: 3;
+ }
+`;
+
+const ValueTip = styled.div<{$below: boolean; $x: number; $y: number}>`
+ background: ${props => props.theme.tooltipBg};
+ border-radius: 2px;
+ color: ${props => props.theme.tooltipColor};
+ font-size: 10px;
+ left: ${props => props.$x}px;
+ line-height: 1;
+ padding: 3px 4px;
+ pointer-events: none;
+ position: absolute;
+ top: ${props =>
+ props.$below ? props.$y + HANDLE_SIZE / 2 + 4 : props.$y - HANDLE_SIZE / 2 - 4}px;
+ transform: translate(-50%, ${props => (props.$below ? '0' : '-100%')});
+ white-space: nowrap;
+ z-index: 4;
+`;
+
+const ZoomMarker = styled.div<{$x: number}>`
+ background: ${props => props.theme.primaryBtnActBgd};
+ bottom: ${PLOT_HEIGHT - opacityToY(0)}px;
+ left: ${props => props.$x}px;
+ pointer-events: none;
+ position: absolute;
+ top: 2px;
+ transform: translateX(-50%);
+ width: 1px;
+ z-index: 2;
+`;
+
+type ZoomOpacitySliderProps = {
+ idPrefix: string;
+ stops: ZoomOpacityStops;
+ zoom?: number;
+ onChange: (key: keyof ZoomOpacityStops, value: number) => void;
+};
+
+function zoomToX(zoom: number, width: number): number {
+ const [minZoom, maxZoom] = ZOOM_OPACITY_RANGE;
+ const inner = Math.max(width - PAD_X * 2, 1);
+ return PAD_X + ((zoom - minZoom) / (maxZoom - minZoom)) * inner;
+}
+
+function opacityToY(opacity: number): number {
+ return PAD_TOP + (1 - opacity) * CURVE_HEIGHT;
+}
+
+function clientXToZoom(clientX: number, rect: DOMRect): number {
+ const [minZoom, maxZoom] = ZOOM_OPACITY_RANGE;
+ const inner = Math.max(rect.width - PAD_X * 2, 1);
+ const ratio = (clientX - rect.left - PAD_X) / inner;
+ return minZoom + Math.min(1, Math.max(0, ratio)) * (maxZoom - minZoom);
+}
+
+function envelopePath(stops: ZoomOpacityStops, width: number): string {
+ const yZero = opacityToY(0);
+ const yFull = opacityToY(1);
+ const xAppear = zoomToX(stops.appear, width);
+ const xFull = zoomToX(stops.full, width);
+ const xFade = zoomToX(stops.fade, width);
+ const xGone = zoomToX(stops.gone, width);
+ return [
+ `M ${PAD_X} ${yZero}`,
+ `L ${xAppear} ${yZero}`,
+ `L ${xFull} ${yFull}`,
+ `L ${xFade} ${yFull}`,
+ `L ${xGone} ${yZero}`,
+ `L ${width - PAD_X} ${yZero}`
+ ].join(' ');
+}
+
+export default function ZoomOpacitySlider({
+ idPrefix,
+ stops,
+ zoom,
+ onChange
+}: ZoomOpacitySliderProps) {
+ const intl = useIntl();
+ const plotRef = useRef<HTMLDivElement>(null);
+ const activeKeyRef = useRef<keyof ZoomOpacityStops | null>(null);
+ const [width, setWidth] = useState(0);
+ const [active, setActive] = useState<keyof ZoomOpacityStops | null>(null);
+ const [minZoom, maxZoom] = ZOOM_OPACITY_RANGE;
+
+ useEffect(() => {
+ const plot = plotRef.current;
+ if (!plot) {
+ return undefined;
+ }
+ const measure = () => setWidth(plot.clientWidth);
+ measure();
+ const observer = new ResizeObserver(measure);
+ observer.observe(plot);
+ return () => observer.disconnect();
+ }, []);
+
+ const moveActive = useCallback(
+ (key: keyof ZoomOpacityStops, clientX: number) => {
+ const plot = plotRef.current;
+ if (!plot) {
+ return;
+ }
+ onChange(key, clientXToZoom(clientX, plot.getBoundingClientRect()));
+ },
+ [onChange]
+ );
+
+ const endDrag = useCallback(() => {
+ activeKeyRef.current = null;
+ setActive(null);
+ }, []);
+
+ const onPointerDown = (key: keyof ZoomOpacityStops) => (event: React.PointerEvent) => {
+ event.preventDefault();
+ event.stopPropagation();
+ const handle = event.currentTarget as HTMLElement;
+ try {
+ handle.setPointerCapture(event.pointerId);
+ } catch {
+ // Pointer capture is unavailable for some synthetic events.
+ }
+ activeKeyRef.current = key;
+ setActive(key);
+
+ const onPointerMove = (moveEvent: PointerEvent) => {
+ if (activeKeyRef.current !== key) {
+ return;
+ }
+ moveActive(key, moveEvent.clientX);
+ };
+ const onPointerUp = () => {
+ window.removeEventListener('pointermove', onPointerMove);
+ window.removeEventListener('pointerup', onPointerUp);
+ window.removeEventListener('pointercancel', onPointerUp);
+ endDrag();
+ };
+ window.addEventListener('pointermove', onPointerMove);
+ window.addEventListener('pointerup', onPointerUp);
+ window.addEventListener('pointercancel', onPointerUp);
+ moveActive(key, event.clientX);
+ };
+
+ const onKeyDown = (key: keyof ZoomOpacityStops) => (event: React.KeyboardEvent) => {
+ const step = event.shiftKey ? 1 : 0.1;
+ if (event.key === 'ArrowLeft' || event.key === 'ArrowDown') {
+ event.preventDefault();
+ onChange(key, stops[key] - step);
+ } else if (event.key === 'ArrowRight' || event.key === 'ArrowUp') {
+ event.preventDefault();
+ onChange(key, stops[key] + step);
+ }
+ };
+
+ const yZero = opacityToY(0);
+ const path = width > 0 ? envelopePath(stops, width) : '';
+
+ return (
+ <SliderRoot className="interaction-zoom-opacity__slider">
+ <Plot ref={plotRef}>
+ <Envelope aria-hidden="true">
+ {width > 0 ? (
+ <>
+ <line
+ x1={PAD_X}
+ x2={width - PAD_X}
+ y1={yZero}
+ y2={yZero}
+ stroke="currentColor"
+ strokeOpacity={0.25}
+ />
+ <path d={`${path} Z`} fill="currentColor" fillOpacity={0.18} />
+ <path d={path} fill="none" stroke="currentColor" strokeWidth={1.5} />
+ </>
+ ) : null}
+ </Envelope>
+ {width > 0
+ ? HANDLES.map(handle => {
+ const value = stops[handle.key];
+ const x = zoomToX(value, width);
+ const y = opacityToY(handle.key === 'full' || handle.key === 'fade' ? 1 : 0);
+ const label = intl.formatMessage({id: handle.labelId});
+ return (
+ <React.Fragment key={handle.key}>
+ <Handle
+ type="button"
+ className={`interaction-zoom-opacity__handle interaction-zoom-opacity__handle--${handle.key}`}
+ id={`${idPrefix}-${handle.key}`}
+ $active={active === handle.key}
+ $x={x}
+ $y={y}
+ role="slider"
+ aria-label={label}
+ aria-valuemin={minZoom}
+ aria-valuemax={maxZoom}
+ aria-valuenow={value}
+ aria-valuetext={String(value)}
+ onPointerDown={onPointerDown(handle.key)}
+ onKeyDown={onKeyDown(handle.key)}
+ />
+ {active === handle.key ? (
+ <ValueTip $below={y < PLOT_HEIGHT / 2} $x={x} $y={y}>
+ {label} {value}
+ </ValueTip>
+ ) : null}
+ </React.Fragment>
+ );
+ })
+ : null}
+ {width > 0 && Number.isFinite(zoom) ? (
+ <ZoomMarker
+ className="interaction-zoom-opacity__zoom-marker"
+ $x={zoomToX(Math.min(maxZoom, Math.max(minZoom, zoom as number)), width)}
+ />
+ ) : null}
+ <AxisLabel $edge="left">{minZoom}</AxisLabel>
+ <AxisLabel $edge="right">{maxZoom}</AxisLabel>
+ </Plot>
+ </SliderRoot>
+ );
+}
diff --git a/src/localization/src/translations/en.ts b/src/localization/src/translations/en.ts
index 9af73a673..49247515a 100644
--- a/src/localization/src/translations/en.ts
+++ b/src/localization/src/translations/en.ts
@@ -942,7 +942,16 @@ ${'```'}
legendEmpty: 'Add a layer to choose what appears in the legend.',
legendHiddenByGroup: 'Hidden because a group is excluded from the legend',
legendHideInvisible: 'Hide hidden layers in legend',
- legendAllLayers: 'All Layers'
+ legendAllLayers: 'All Layers',
+ fadeOnZoom: 'Fade on zoom',
+ fadeOnZoomHint: 'Fade layers as the map zooms. Configure a zoom range to show layers.',
+ fadeOnZoomAdd: 'Add controller',
+ fadeOnZoomLayers: 'Layers',
+ fadeOnZoomAppear: 'Appear',
+ fadeOnZoomFullStart: 'Full start',
+ fadeOnZoomFullEnd: 'Full end',
+ fadeOnZoomDisappear: 'Disappear',
+ fadeOnZoomDelete: 'Remove controller'
},
layerBlending: {
title: 'Layer Blending',
diff --git a/src/reducers/src/interaction-utils.ts b/src/reducers/src/interaction-utils.ts
index 6de658944..cea7038d5 100644
--- a/src/reducers/src/interaction-utils.ts
+++ b/src/reducers/src/interaction-utils.ts
@@ -10,7 +10,14 @@ import {
COMPARE_TYPES
} from '@kepler.gl/constants';
-import {Field, TooltipField, CompareType} from '@kepler.gl/types';
+import {
+ Field,
+ InteractionConfig,
+ TooltipField,
+ CompareType,
+ ZoomOpacityController,
+ ZoomOpacityStops
+} from '@kepler.gl/types';
import {parseFieldValue, getFormatter, isNumber, defaultFormatter} from '@kepler.gl/utils';
import {notNullorUndefined} from '@kepler.gl/common-utils';
@@ -153,3 +160,163 @@ export function getTooltipDisplayValue({
? getFormatter(field.displayFormat, field)(value)
: parseFieldValue(value, field.type);
}
+
+export const ZOOM_OPACITY_RANGE: [number, number] = [0, 24];
+
+export const DEFAULT_ZOOM_OPACITY_STOPS: ZoomOpacityStops = {
+ appear: 1,
+ full: 3,
+ fade: 8,
+ gone: 12
+};
+
+const ZOOM_OPACITY_STOP_KEYS = ['appear', 'full', 'fade', 'gone'] as const;
+
+function isOrderedZoomOpacityStops(stops: ZoomOpacityStops | undefined): stops is ZoomOpacityStops {
+ if (!stops) {
+ return false;
+ }
+ const {appear, full, fade, gone} = stops;
+ return (
+ [appear, full, fade, gone].every(
+ value => typeof value === 'number' && Number.isFinite(value)
+ ) &&
+ appear <= full &&
+ full <= fade &&
+ fade <= gone
+ );
+}
+
+/**
+ * 0–1 multiplier for a layer's opacity at `zoom`.
+ * 0 at and outside the envelope, rising from appear to full, holding through fade, then falling to gone.
+ * Equal neighbors are a step. Unordered stops leave opacity unchanged.
+ */
+export function zoomOpacityFactor(zoom: number, stops: ZoomOpacityStops): number {
+ if (!isOrderedZoomOpacityStops(stops) || !Number.isFinite(zoom)) {
+ return 1;
+ }
+ const {appear, full, fade, gone} = stops;
+ if (zoom <= appear || zoom >= gone) {
+ return 0;
+ }
+ if (zoom < full) {
+ const span = full - appear;
+ return span <= 0 ? 1 : (zoom - appear) / span;
+ }
+ if (zoom <= fade) {
+ return 1;
+ }
+ const span = gone - fade;
+ return span <= 0 ? 0 : (gone - zoom) / span;
+}
+
+/** Envelope multiplier for one layer. 1 when fade-on-zoom is off or the layer is not assigned. */
+export function getLayerZoomOpacityFactor(
+ layerId: string,
+ zoom: number | undefined,
+ interactionConfig?: InteractionConfig | null
+): number {
+ const zoomOpacity = interactionConfig?.zoomOpacity;
+ if (!zoomOpacity?.enabled || typeof zoom !== 'number') {
+ return 1;
+ }
+ const controller = zoomOpacity.config?.controllers?.find(item =>
+ item.layerIds?.includes(layerId)
+ );
+ if (!controller) {
+ return 1;
+ }
+ return zoomOpacityFactor(zoom, controller.stops);
+}
+
+/** Write one stop and push its neighbors so appear <= full <= fade <= gone. */
+export function setZoomOpacityStop(
+ stops: ZoomOpacityStops,
+ key: keyof ZoomOpacityStops,
+ value: number
+): ZoomOpacityStops {
+ const [minZoom, maxZoom] = ZOOM_OPACITY_RANGE;
+ const next: ZoomOpacityStops = {...stops};
+ const clamped = Math.min(maxZoom, Math.max(minZoom, value));
+ next[key] = Math.round(clamped * 10) / 10;
+ const index = ZOOM_OPACITY_STOP_KEYS.indexOf(key);
+ for (let i = index - 1; i >= 0; i--) {
+ const stopKey = ZOOM_OPACITY_STOP_KEYS[i];
+ if (next[stopKey] > next[ZOOM_OPACITY_STOP_KEYS[i + 1]]) {
+ next[stopKey] = next[ZOOM_OPACITY_STOP_KEYS[i + 1]];
+ }
+ }
+ for (let i = index + 1; i < ZOOM_OPACITY_STOP_KEYS.length; i++) {
+ const stopKey = ZOOM_OPACITY_STOP_KEYS[i];
+ if (next[stopKey] < next[ZOOM_OPACITY_STOP_KEYS[i - 1]]) {
+ next[stopKey] = next[ZOOM_OPACITY_STOP_KEYS[i - 1]];
+ }
+ }
+ return next;
+}
+
+/** Concatenate controllers and keep the first assignment of each layer id. */
+export function combineZoomOpacityControllers(
+ configs: Array<{controllers?: ZoomOpacityController[]} | null | undefined>
+): ZoomOpacityController[] {
+ const seen = new Set<string>();
+ const controllers: ZoomOpacityController[] = [];
+ configs.forEach(config => {
+ (config?.controllers || []).forEach(controller => {
+ const layerIds = (controller.layerIds || []).filter(id => {
+ if (seen.has(id)) {
+ return false;
+ }
+ seen.add(id);
+ return true;
+ });
+ if (layerIds.length || !(controller.layerIds || []).length) {
+ controllers.push({
+ ...controller,
+ stops: {...controller.stops},
+ layerIds
+ });
+ }
+ });
+ });
+ return controllers;
+}
+
+/** Drop a deleted layer from fade-on-zoom controllers. Returns the same config when nothing changes. */
+export function removeLayerFromZoomOpacity<
+ T extends {zoomOpacity?: InteractionConfig['zoomOpacity']}
+>(interactionConfig: T, layerId: string): T {
+ const zoomOpacity = interactionConfig?.zoomOpacity;
+ if (!zoomOpacity) {
+ return interactionConfig;
+ }
+ const controllers = zoomOpacity.config?.controllers;
+ if (!controllers?.length) {
+ return interactionConfig;
+ }
+ let changed = false;
+ const nextControllers = controllers.map(controller => {
+ if (!controller.layerIds?.includes(layerId)) {
+ return controller;
+ }
+ changed = true;
+ return {
+ ...controller,
+ layerIds: controller.layerIds.filter(id => id !== layerId)
+ };
+ });
+ if (!changed) {
+ return interactionConfig;
+ }
+ return {
+ ...interactionConfig,
+ zoomOpacity: {
+ ...zoomOpacity,
+ config: {
+ ...zoomOpacity.config,
+ controllers: nextControllers
+ }
+ }
+ };
+}
diff --git a/src/reducers/src/layer-utils.ts b/src/reducers/src/layer-utils.ts
index 2d93275ab..08cc4351a 100644
--- a/src/reducers/src/layer-utils.ts
+++ b/src/reducers/src/layer-utils.ts
@@ -37,6 +37,7 @@ import KeplerTable from '@kepler.gl/table';
import {VisState} from '@kepler.gl/schemas';
import {isFunction, getMapLayersFromSplitMaps, DataRow, isPlainObject} from '@kepler.gl/utils';
import {arrayMove, generateHashId} from '@kepler.gl/common-utils';
+import {getLayerZoomOpacityFactor} from './interaction-utils';
import {ThreeDBuildingLayer} from '@kepler.gl/deckgl-layers';
@@ -280,6 +281,58 @@ export function getLayerHoverProp({
return null;
}
+const ZOOM_OPACITY_PROP_KEYS = ['opacity', 'lineOpacity', 'strokeOpacity'];
+
+/** Stroke and outline props replace the parent opacity, so they need the same factor. */
+function scaleZoomOpacitySubLayerProps(
+ subLayerProps: Record<string, any> | undefined,
+ factor: number
+): Record<string, any> | undefined {
+ if (!subLayerProps) {
+ return undefined;
+ }
+ let changed = false;
+ const next: Record<string, any> = {};
+ for (const id of Object.keys(subLayerProps)) {
+ const sublayer = subLayerProps[id];
+ if (!sublayer || typeof sublayer !== 'object') {
+ next[id] = sublayer;
+ continue;
+ }
+ const scaled = {...sublayer};
+ let sublayerChanged = false;
+ for (const key of ZOOM_OPACITY_PROP_KEYS) {
+ if (typeof sublayer[key] === 'number') {
+ scaled[key] = sublayer[key] * factor;
+ sublayerChanged = true;
+ }
+ }
+ next[id] = sublayerChanged ? scaled : sublayer;
+ if (sublayerChanged) {
+ changed = true;
+ }
+ }
+ return changed ? next : undefined;
+}
+
+function applyZoomOpacityToDeckLayer(deckLayer: any, factor: number): any {
+ if (Array.isArray(deckLayer)) {
+ return deckLayer.map(layer => applyZoomOpacityToDeckLayer(layer, factor));
+ }
+ if (!deckLayer || factor === 1 || typeof deckLayer.clone !== 'function') {
+ return deckLayer;
+ }
+ const baseOpacity = deckLayer.props?.opacity;
+ const opacity = (typeof baseOpacity === 'number' ? baseOpacity : 1) * factor;
+ const subLayerProps = scaleZoomOpacitySubLayerProps(deckLayer.props?._subLayerProps, factor);
+ return deckLayer.clone({
+ opacity,
+ // Fully faded layers are not pickable.
+ visible: deckLayer.props?.visible !== false && factor > 0,
+ ...(subLayerProps ? {_subLayerProps: subLayerProps} : {})
+ });
+}
+
export function renderDeckGlLayer(props: any, layerCallbacks: {[key: string]: any}) {
const {
datasets,
@@ -301,7 +354,7 @@ export function renderDeckGlLayer(props: any, layerCallbacks: {[key: string]: an
// instead of leaking undefined into deck.gl's visible prop
const visible = !mapLayers || Boolean(mapLayers[layer.id]);
// Layer is Layer class
- return layer.renderLayer({
+ const rendered = layer.renderLayer({
data,
gpuFilter,
idx: layerIndex,
@@ -314,6 +367,8 @@ export function renderDeckGlLayer(props: any, layerCallbacks: {[key: string]: an
dataset,
experimentalContext
});
+ const factor = getLayerZoomOpacityFactor(layer.id, mapState?.zoom, interactionConfig);
+ return applyZoomOpacityToDeckLayer(rendered, factor);
}
export function isLayerRenderable(layer: Layer, layerData) {
diff --git a/src/reducers/src/vis-state-merger.ts b/src/reducers/src/vis-state-merger.ts
index b548c6621..c9d35e056 100644
--- a/src/reducers/src/vis-state-merger.ts
+++ b/src/reducers/src/vis-state-merger.ts
@@ -51,6 +51,7 @@ import {
import {KeplerTable, Datasets, assignGpuChannels, resetFilterGpuMode} from '@kepler.gl/table';
import {getLayerOrderFromLayers} from './layer-utils';
+import {combineZoomOpacityControllers} from './interaction-utils';
/**
* Merge loaded filters with current state, if no fields or data are loaded
@@ -485,7 +486,11 @@ export function mergeInteractions<S extends VisState>(
}
const currentConfig =
- key === 'tooltip' || key === 'brush' || key === 'geocoder' || key === 'legend'
+ key === 'tooltip' ||
+ key === 'brush' ||
+ key === 'geocoder' ||
+ key === 'legend' ||
+ key === 'zoomOpacity'
? state.interactionConfig[key].config
: null;
@@ -551,6 +556,13 @@ function combineInteractionConfigs(configs: SavedInteractionConfig[]): SavedInte
combined.legend = withLegend.legend;
}
}
+ // Same for fade-on-zoom: an older config in front must not drop controllers from a later one.
+ if (!combined.zoomOpacity) {
+ const withZoomOpacity = configs.find(c => c.zoomOpacity);
+ if (withZoomOpacity?.zoomOpacity) {
+ combined.zoomOpacity = withZoomOpacity.zoomOpacity;
+ }
+ }
// handle each property key of an `InteractionConfig`, e.g. tooltip, geocoder, brush, coordinate
// by combining values for each among all passed in configs
@@ -610,6 +622,10 @@ function combineInteractionConfigs(configs: SavedInteractionConfig[]): SavedInte
if (key === 'legend') {
combined[key].hideInvisibleLayers = toBeCombinedProps.some(p => p?.hideInvisibleLayers);
}
+
+ if (key === 'zoomOpacity' && combined.zoomOpacity) {
+ combined.zoomOpacity.controllers = combineZoomOpacityControllers(toBeCombinedProps);
+ }
}
return combined;
diff --git a/src/reducers/src/vis-state-updaters.ts b/src/reducers/src/vis-state-updaters.ts
index 541965302..07f089851 100644
--- a/src/reducers/src/vis-state-updaters.ts
+++ b/src/reducers/src/vis-state-updaters.ts
@@ -187,7 +187,7 @@ import {
setFilterGpuMode,
sortDatasetByColumn
} from '@kepler.gl/table';
-import {findFieldsToShow} from './interaction-utils';
+import {findFieldsToShow, removeLayerFromZoomOpacity} from './interaction-utils';
import {
calculateLayerData,
findDefaultLayer,
@@ -324,6 +324,14 @@ export const defaultInteractionConfig: InteractionConfig = {
label: 'interactions.coordinate',
enabled: false,
position: null
+ },
+ zoomOpacity: {
+ id: 'zoomOpacity',
+ label: 'interactions.fadeOnZoom',
+ enabled: false,
+ config: {
+ controllers: []
+ }
}
};
@@ -2050,6 +2058,9 @@ export function removeLayerUpdater<T extends VisState>(
const {layers, layerData, layerOrder, clicked, hoverInfo} = state;
const layerToRemove = layers[idx];
+ const interactionConfig = state.interactionConfig
+ ? removeLayerFromZoomOpacity(state.interactionConfig, layerToRemove.id)
+ : state.interactionConfig;
const newState = {
...state,
layers: filterOutById(layerToRemove.id)(layers),
@@ -2057,7 +2068,10 @@ export function removeLayerUpdater<T extends VisState>(
layerOrder: removeElementFromLayerOrder(layerOrder, layerToRemove.id),
clicked: layerToRemove.isLayerHovered(clicked) ? undefined : clicked,
hoverInfo: layerToRemove.isLayerHovered(hoverInfo) ? undefined : hoverInfo,
- splitMaps: removeLayerFromSplitMaps(state.splitMaps, layerToRemove)
+ splitMaps: removeLayerFromSplitMaps(state.splitMaps, layerToRemove),
+ // Only replace interactionConfig when a controller actually listed this layer.
+ // Partial test states omit it, and adding the key would change that shape.
+ ...(interactionConfig !== state.interactionConfig ? {interactionConfig} : {})
// TODO: update filters, create helper to remove layer form filter (remove layerid and dataid) if mapped
};
diff --git a/src/schemas/src/vis-state-schema.ts b/src/schemas/src/vis-state-schema.ts
index 1e93222e6..47eabaf0d 100644
--- a/src/schemas/src/vis-state-schema.ts
+++ b/src/schemas/src/vis-state-schema.ts
@@ -710,7 +710,7 @@ class InteractionSchemaV0 extends Schema {
}
}
-const interactionPropsV1 = ['tooltip', 'legend', 'brush', 'geocoder', 'coordinate'];
+const interactionPropsV1 = ['tooltip', 'legend', 'brush', 'geocoder', 'coordinate', 'zoomOpacity'];
export class InteractionSchemaV1 extends Schema {
key = 'interactionConfig';
@@ -723,16 +723,19 @@ export class InteractionSchemaV1 extends Schema {
// save config even if disabled,
return Array.isArray(this.properties)
? {
- [this.key]: this.properties.reduce(
- (accu, key) => ({
+ [this.key]: this.properties.reduce((accu, key) => {
+ const interaction = interactionConfig[key];
+ if (!interaction) {
+ return accu;
+ }
+ return {
...accu,
[key]: {
- ...interactionConfig[key].config,
- enabled: interactionConfig[key].enabled
+ ...interaction.config,
+ enabled: interaction.enabled
}
- }),
- {}
- )
+ };
+ }, {})
}
: {};
}
diff --git a/src/types/reducers.d.ts b/src/types/reducers.d.ts
index 40d2650fb..b0f6569cf 100644
--- a/src/types/reducers.d.ts
+++ b/src/types/reducers.d.ts
@@ -411,12 +411,36 @@ export type LegendInfo = BaseInteraction & {
hideInvisibleLayers: boolean;
};
};
+/** Zoom stops for a fade envelope. Opacity is 0 outside [appear, gone]. */
+export type ZoomOpacityStops = {
+ /** Zoom where opacity leaves 0. */
+ appear: number;
+ /** Zoom where opacity reaches the layer's full opacity. */
+ full: number;
+ /** Zoom where opacity starts falling. */
+ fade: number;
+ /** Zoom where opacity returns to 0. */
+ gone: number;
+};
+/** Layers that share one zoom envelope. */
+export type ZoomOpacityController = {
+ id: string;
+ layerIds: string[];
+ stops: ZoomOpacityStops;
+};
+export type ZoomOpacityInteraction = BaseInteraction & {
+ id: 'zoomOpacity';
+ config: {
+ controllers: ZoomOpacityController[];
+ };
+};
export type InteractionConfig = {
tooltip: TooltipInfo;
legend: LegendInfo;
geocoder: Geocoder;
brush: Brush;
coordinate: Coordinate;
+ zoomOpacity: ZoomOpacityInteraction;
};
export type MapInfo = {
title: string;
diff --git a/src/types/schemas.d.ts b/src/types/schemas.d.ts
index 91cb8e3c0..b50d59d2e 100644
--- a/src/types/schemas.d.ts
+++ b/src/types/schemas.d.ts
@@ -49,6 +49,9 @@ export type SavedInteractionConfig = {
enabled: boolean;
hideInvisibleLayers?: boolean;
};
+ zoomOpacity?: InteractionConfig['zoomOpacity']['config'] & {
+ enabled: boolean;
+ };
};
export type SavedScale = string;
diff --git a/test/node/reducers/index.js b/test/node/reducers/index.js
index a80db9f0f..d81456983 100644
--- a/test/node/reducers/index.js
+++ b/test/node/reducers/index.js
@@ -23,3 +23,4 @@ import './chart-updater-test';
// test layer groups
import './layer-group-test';
import './layer-group-updaters-test';
+import './zoom-opacity-test';
diff --git a/test/node/reducers/vis-state-merger-combine-configs-test.spec.js b/test/node/reducers/vis-state-merger-combine-configs-test.spec.js
index 2b7ae2bd0..d8460e4eb 100644
--- a/test/node/reducers/vis-state-merger-combine-configs-test.spec.js
+++ b/test/node/reducers/vis-state-merger-combine-configs-test.spec.js
@@ -224,6 +224,54 @@ const TEST_CASES = [
],
expected: {currentTime: 100, speed: 1, timeFormat: 'L LTS', timezone: 'America/Guayaquil'}
},
+ {
+ testMessage:
+ 'interactionConfig zoomOpacity concatenates controllers and drops duplicate layer ids',
+ propName: 'interactionConfig',
+ configsToMerge: [
+ {
+ zoomOpacity: {
+ enabled: false,
+ controllers: [
+ {
+ id: 'c1',
+ layerIds: ['l1', 'l2'],
+ stops: {appear: 1, full: 3, fade: 8, gone: 12}
+ }
+ ]
+ }
+ },
+ {
+ zoomOpacity: {
+ enabled: true,
+ controllers: [
+ {
+ id: 'c2',
+ layerIds: ['l2', 'l3'],
+ stops: {appear: 4, full: 6, fade: 10, gone: 14}
+ }
+ ]
+ }
+ }
+ ],
+ expected: {
+ zoomOpacity: {
+ enabled: true,
+ controllers: [
+ {
+ id: 'c1',
+ layerIds: ['l1', 'l2'],
+ stops: {appear: 1, full: 3, fade: 8, gone: 12}
+ },
+ {
+ id: 'c2',
+ layerIds: ['l3'],
+ stops: {appear: 4, full: 6, fade: 10, gone: 14}
+ }
+ ]
+ }
+ }
+ },
{
testMessage: 'editor',
propName: 'editor',
diff --git a/test/node/reducers/zoom-opacity-test.js b/test/node/reducers/zoom-opacity-test.js
new file mode 100644
index 000000000..0b805ac07
--- /dev/null
+++ b/test/node/reducers/zoom-opacity-test.js
@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import test from 'tape';
+import cloneDeep from 'es-toolkit/compat/cloneDeep';
+
+import {VisStateActions} from '@kepler.gl/actions';
+import {
+ combineZoomOpacityControllers,
+ getLayerZoomOpacityFactor,
+ INITIAL_VIS_STATE,
+ mergeInteractions,
+ renderDeckGlLayer,
+ visStateReducer,
+ zoomOpacityFactor
+} from '@kepler.gl/reducers';
+import {StateWFilesFiltersLayerColor} from 'test/helpers/mock-state';
+
+const stops = {appear: 2, full: 4, fade: 8, gone: 10};
+
+test('interactionUtil -> zoomOpacityFactor', t => {
+ t.equal(zoomOpacityFactor(0, stops), 0, 'below appear');
+ t.equal(zoomOpacityFactor(2, stops), 0, 'at appear');
+ t.equal(zoomOpacityFactor(3, stops), 0.5, 'halfway up');
+ t.equal(zoomOpacityFactor(4, stops), 1, 'at full');
+ t.equal(zoomOpacityFactor(6, stops), 1, 'plateau');
+ t.equal(zoomOpacityFactor(8, stops), 1, 'at fade');
+ t.equal(zoomOpacityFactor(9, stops), 0.5, 'halfway down');
+ t.equal(zoomOpacityFactor(10, stops), 0, 'at gone');
+ t.equal(zoomOpacityFactor(14, stops), 0, 'above gone');
+
+ const stepIn = {appear: 5, full: 5, fade: 9, gone: 12};
+ t.equal(zoomOpacityFactor(5, stepIn), 0, 'equal appear and full is off at that zoom');
+ t.equal(zoomOpacityFactor(5.1, stepIn), 1, 'equal appear and full steps to full opacity');
+
+ const stepOut = {appear: 1, full: 2, fade: 8, gone: 8};
+ t.equal(zoomOpacityFactor(7.9, stepOut), 1, 'equal fade and gone stays full until the end');
+ t.equal(zoomOpacityFactor(8, stepOut), 0, 'equal fade and gone steps off');
+
+ t.equal(
+ zoomOpacityFactor(3, {appear: 4, full: 2, fade: 8, gone: 10}),
+ 1,
+ 'unordered stops leave opacity unchanged'
+ );
+ t.end();
+});
+
+test('interactionUtil -> getLayerZoomOpacityFactor', t => {
+ const interactionConfig = {
+ zoomOpacity: {
+ id: 'zoomOpacity',
+ label: 'interactions.fadeOnZoom',
+ enabled: true,
+ config: {
+ controllers: [{id: 'c1', layerIds: ['a'], stops: {appear: 0, full: 0, fade: 2, gone: 4}}]
+ }
+ }
+ };
+
+ t.equal(
+ getLayerZoomOpacityFactor('a', 1, interactionConfig),
+ 1,
+ 'assigned layer uses the envelope'
+ );
+ t.equal(getLayerZoomOpacityFactor('b', 1, interactionConfig), 1, 'unassigned layer is unchanged');
+ t.equal(
+ getLayerZoomOpacityFactor('a', 1, {
+ zoomOpacity: {...interactionConfig.zoomOpacity, enabled: false}
+ }),
+ 1,
+ 'disabled fade leaves opacity unchanged'
+ );
+ t.equal(
+ getLayerZoomOpacityFactor('a', undefined, interactionConfig),
+ 1,
+ 'missing zoom is unchanged'
+ );
+ t.end();
+});
+
+test('interactionUtil -> combineZoomOpacityControllers', t => {
+ const combined = combineZoomOpacityControllers([
+ {
+ controllers: [{id: 'c1', layerIds: ['l1', 'l2'], stops}]
+ },
+ {
+ controllers: [{id: 'c2', layerIds: ['l2', 'l3'], stops}]
+ }
+ ]);
+
+ t.equal(combined.length, 2, 'keeps both controllers');
+ t.deepEqual(combined[0].layerIds, ['l1', 'l2'], 'first assignment wins');
+ t.deepEqual(combined[1].layerIds, ['l3'], 'drops a layer id already assigned');
+ t.end();
+});
+
+test('mergeInteractions -> zoomOpacity controllers', t => {
+ const controllers = [
+ {id: 'c1', layerIds: ['layer-1'], stops: {appear: 2, full: 4, fade: 8, gone: 11}}
+ ];
+ const merged = mergeInteractions(INITIAL_VIS_STATE, {
+ zoomOpacity: {enabled: true, controllers}
+ });
+
+ t.equal(merged.interactionConfig.zoomOpacity.enabled, true, 'loads the enabled flag');
+ t.deepEqual(
+ merged.interactionConfig.zoomOpacity.config.controllers,
+ controllers,
+ 'loads controllers into config'
+ );
+ t.end();
+});
+
+test('renderDeckGlLayer -> zoom opacity', t => {
+ function makeDeckLayer(opacity) {
+ const deckLayer = {
+ props: {opacity, visible: true},
+ clone(next) {
+ return {props: {...this.props, ...next}, clone: this.clone};
+ }
+ };
+ return deckLayer;
+ }
+
+ const deckLayer = makeDeckLayer(0.8);
+ const layer = {
+ id: 'a',
+ config: {dataId: 'missing'},
+ renderLayer() {
+ return [deckLayer];
+ }
+ };
+ const interactionConfig = {
+ zoomOpacity: {
+ enabled: true,
+ config: {
+ controllers: [{id: 'c1', layerIds: ['a'], stops}]
+ }
+ }
+ };
+
+ const rising = renderDeckGlLayer(
+ {
+ datasets: {},
+ layer,
+ layerIndex: 0,
+ data: {},
+ mapState: {zoom: 3},
+ interactionConfig
+ },
+ {}
+ );
+ t.equal(rising[0].props.opacity, 0.4, 'scales the layer opacity on the way up');
+ t.equal(rising[0].props.visible, true, 'stays visible while fading');
+
+ const stroked = {
+ props: {
+ opacity: 0.8,
+ visible: true,
+ _subLayerProps: {
+ 'polygons-stroke': {opacity: 0.6},
+ linestrings: {opacity: 0.6},
+ points: {lineOpacity: 0.4},
+ 'polygons-fill': {type: 'Fill'}
+ }
+ },
+ clone(next) {
+ return {props: {...this.props, ...next}, clone: this.clone};
+ }
+ };
+ const strokedLayer = {
+ id: 'a',
+ config: {dataId: 'missing'},
+ renderLayer() {
+ return [stroked];
+ }
+ };
+ const fadedStroke = renderDeckGlLayer(
+ {
+ datasets: {},
+ layer: strokedLayer,
+ layerIndex: 0,
+ data: {},
+ mapState: {zoom: 3},
+ interactionConfig
+ },
+ {}
+ );
+ t.equal(
+ fadedStroke[0].props._subLayerProps['polygons-stroke'].opacity,
+ 0.3,
+ 'scales polygon stroke opacity'
+ );
+ t.equal(
+ fadedStroke[0].props._subLayerProps.linestrings.opacity,
+ 0.3,
+ 'scales line stroke opacity'
+ );
+ t.equal(
+ fadedStroke[0].props._subLayerProps.points.lineOpacity,
+ 0.2,
+ 'scales point outline opacity'
+ );
+ t.equal(
+ fadedStroke[0].props._subLayerProps['polygons-fill'].type,
+ 'Fill',
+ 'leaves non-opacity sublayer props'
+ );
+ t.equal(
+ stroked.props._subLayerProps['polygons-stroke'].opacity,
+ 0.6,
+ 'does not mutate the original stroke opacity'
+ );
+
+ const hidden = renderDeckGlLayer(
+ {
+ datasets: {},
+ layer,
+ layerIndex: 0,
+ data: {},
+ mapState: {zoom: 1},
+ interactionConfig
+ },
+ {}
+ );
+ t.equal(hidden[0].props.opacity, 0, 'opacity is 0 outside the envelope');
+ t.equal(hidden[0].props.visible, false, 'fully faded layers are not pickable');
+
+ const untouched = renderDeckGlLayer(
+ {
+ datasets: {},
+ layer,
+ layerIndex: 0,
+ data: {},
+ mapState: {zoom: 3},
+ interactionConfig: {
+ zoomOpacity: {...interactionConfig.zoomOpacity, enabled: false}
+ }
+ },
+ {}
+ );
+ t.equal(untouched[0], deckLayer, 'disabled fade does not clone the deck layer');
+ t.end();
+});
+
+test('visStateReducer -> REMOVE_LAYER drops zoom opacity layer id', t => {
+ const state = cloneDeep(StateWFilesFiltersLayerColor.visState);
+ const layerId = state.layers[0].id;
+ const otherId = state.layers[1].id;
+ state.interactionConfig.zoomOpacity.config.controllers = [
+ {id: 'c1', layerIds: [layerId, otherId], stops}
+ ];
+
+ const next = visStateReducer(state, VisStateActions.removeLayer(layerId));
+
+ t.deepEqual(
+ next.interactionConfig.zoomOpacity.config.controllers[0].layerIds,
+ [otherId],
+ 'removes the deleted layer from the controller'
+ );
+ t.ok(
+ next.layers.every(layer => layer.id !== layerId),
+ 'still removes the layer'
+ );
+ t.end();
+});
diff --git a/test/node/schemas/vis-state-schema-test.js b/test/node/schemas/vis-state-schema-test.js
index df76e05bf..18d4214b3 100644
--- a/test/node/schemas/vis-state-schema-test.js
+++ b/test/node/schemas/vis-state-schema-test.js
@@ -227,6 +227,10 @@ test('#visStateSchema -> v1 -> save load interaction', t => {
legend: {
enabled: false,
hideInvisibleLayers: false
+ },
+ zoomOpacity: {
+ enabled: false,
+ controllers: []
}
};
@@ -289,6 +293,10 @@ test('#visStateSchema -> v1 -> save load interaction -> tooltip format', t => {
legend: {
enabled: false,
hideInvisibleLayers: false
+ },
+ zoomOpacity: {
+ enabled: false,
+ controllers: []
}
};
@@ -596,3 +604,25 @@ test('#visStateSchema -> v1 -> save load hideInvisibleLayers', t => {
t.equal(loaded.legend.hideInvisibleLayers, true, 'should load hideInvisibleLayers');
t.end();
});
+
+test('#visStateSchema -> v1 -> save load zoomOpacity controllers', t => {
+ const initialState = cloneDeep(StateWFilesFiltersLayerColor);
+ const layerId = initialState.visState.layers[0].id;
+ const controllers = [
+ {
+ id: 'c1',
+ layerIds: [layerId],
+ stops: {appear: 2, full: 4, fade: 9, gone: 14}
+ }
+ ];
+ initialState.visState.interactionConfig.zoomOpacity.enabled = true;
+ initialState.visState.interactionConfig.zoomOpacity.config.controllers = controllers;
+
+ const savedState = SchemaManager.getConfigToSave(initialState);
+ const savedZoom = savedState.config.visState.interactionConfig.zoomOpacity;
+ t.deepEqual(savedZoom, {enabled: true, controllers}, 'should persist fade-on-zoom controllers');
+
+ const loaded = SchemaManager.parseSavedConfig(savedState).visState.interactionConfig.zoomOpacity;
+ t.deepEqual(loaded, {enabled: true, controllers}, 'should load fade-on-zoom controllers');
+ t.end();
+});