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.tsindex 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/brusexport {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.tsxindex 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 ? (<LegendConfigkey={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 (<InteractionPanelkey={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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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 propconst 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]: andataset,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.tsindex 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[]): SavedIntecombined.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[]): SavedInteif (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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.jsindex 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 groupsimport './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.jsindex 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.jsnew file mode 100644index 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.jsindex 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();+});