@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/esm/map-container.js

@@ -0,0 +1,1303 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// libraries
+import React, { Component, createRef } from 'react';
+import styled, { withTheme } from 'styled-components';
+import { Map as MapboxLegacyMap } from 'react-map-gl/mapbox-legacy';
+import { Map as MaplibreMap } from '@vis.gl/react-maplibre';
+import { MapView } from '@deck.gl/core';
+import DeckGL from '@deck.gl/react';
+import { createSelector } from 'reselect';
+import { useDroppable } from '@dnd-kit/core';
+import debounce from 'lodash/debounce';
+// components
+import MapPopoverFactory from './map/map-popover';
+import MapControlFactory from './map/map-control';
+import MapScaleFactory from './map/map-scale';
+import { StyledMapContainer } from './common/styled-components';
+import { Attribution, AttributionLogos, renderBasemapAttribution, dedupeBasemapAttributions } from './map/attribution';
+import EditorFactory from './editor/editor';
+import FilterFeatureBadges from './editor/filter-feature-badges';
+import { AnnotationOverlay } from './annotations';
+
+// utils
+import { generateMapboxLayers, updateMapboxLayers, EditorLayerUtils } from '@kepler.gl/layers';
+import { errorNotification, isStyleUsingMapboxTiles, isStyleUsingOpenStreetMapTiles, getBaseMapAttributions, getBaseMapLibrary, transformRequest, observeDimensions, unobserveDimensions, getMapLayersFromSplitMaps, onViewPortChange, getViewportFromMapState, normalizeEvent, rgbToHex, computeDeckEffects, getApplicationConfig, getLayerBlendingParameters, patchDeckRendererForPostProcessing } from '@kepler.gl/utils';
+
+// default-settings
+import { FILTER_TYPES, GEOCODER_LAYER_ID, THROTTLE_NOTIFICATION_TIME, DEFAULT_PICKING_RADIUS, NO_MAP_ID, EMPTY_MAPBOX_STYLE, MAPBOX_MAX_PITCH, MAP_LIB_OPTIONS, GLOBE_MIN_ZOOM, GLOBE_MAX_ZOOM } from '@kepler.gl/constants';
+import { getGlobeBaseLayers, getGlobeTopLayers, getGlobeClearColor, getGlobeBasemapAttributions, resolveGlobeBasemapProvider, getStarsBackgroundImage, KeplerGlobeView } from '@kepler.gl/deckgl-layers';
+import { DROPPABLE_MAP_CONTAINER_TYPE } from './common/dnd-layer-items';
+// Contexts
+import { MapViewStateContext } from './map-view-state-context';
+import ErrorBoundary from './common/error-boundary';
+import { LOCALE_CODES } from '@kepler.gl/localization';
+import { areAnyDeckLayersLoading, computeDeckLayers, getLayerHoverProp, prepareLayersForDeck, prepareLayersToRender } from '@kepler.gl/reducers';
+import LoadingIndicator from './loading-indicator';
+
+// Debounce the propagation of viewport change and mouse moves to redux store.
+// This is to avoid too many renders of other components when the map is
+// being panned/zoomed (leading to laggy basemap/deck syncing).
+var DEBOUNCE_VIEWPORT_PROPAGATE = 10;
+var DEBOUNCE_MOUSE_MOVE_PROPAGATE = 10;
+
+// How long should we wait between layer loading state changes before triggering a UI update
+var DEBOUNCE_LOADING_STATE_PROPAGATE = 100;
+var MAP_STYLE = {
+  container: {
+    display: 'inline-block',
+    position: 'relative',
+    width: '100%',
+    height: '100%'
+  },
+  top: {
+    position: 'absolute',
+    top: 0,
+    width: '100%',
+    height: '100%',
+    pointerEvents: 'none'
+  }
+};
+var LOCALE_CODES_ARRAY = Object.keys(LOCALE_CODES);
+var StyledMap = styled(StyledMapContainer)(function (_ref) {
+  var _ref$$mixBlendMode = _ref.$mixBlendMode,
+    $mixBlendMode = _ref$$mixBlendMode === void 0 ? 'normal' : _ref$$mixBlendMode,
+    $mapLibCssClass = _ref.$mapLibCssClass;
+  return "\n  #default-deckgl-overlay {\n    mix-blend-mode: ".concat($mixBlendMode, ";\n  };\n  *[").concat($mapLibCssClass, "-children] {\n    position: absolute;\n  }\n");
+});
+var MAPBOXGL_STYLE_UPDATE = 'style.load';
+var MAPBOXGL_RENDER = 'render';
+
+// Canonical OpenStreetMap attribution, injected into the collected list when a
+// style is detected to use OSM tiles but the resolved sources haven't yielded
+// an attribution string of their own (e.g. raw style declares OSM but the
+// TileJSON hasn't exposed it). Rendered through the same safe link parser as
+// every other collected attribution.
+var OSM_ATTRIBUTION_HTML = '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>';
+var StyledDroppable = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  background-color: ", ";\n  width: 100%;\n  height: 100%;\n  position: absolute;\n  pointer-events: none;\n  z-index: 1;\n"])), function (props) {
+  return props.$isOver ? props.theme.dndOverBackgroundColor : 'none';
+});
+var StyledMapScaleContainer = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: absolute;\n  bottom: ", "px;\n  left: ", "px;\n  z-index: 1;\n  pointer-events: auto;\n"])), function (props) {
+  return props.theme.sidePanel.margin.left + props.$bottomOffset;
+}, function (props) {
+  return props.$left;
+});
+export var isSplitSelector = function isSplitSelector(props) {
+  return props.visState.splitMaps && props.visState.splitMaps.length > 1;
+};
+export var Droppable = function Droppable(_ref2) {
+  var containerId = _ref2.containerId;
+  var _useDroppable = useDroppable({
+      id: containerId,
+      data: {
+        type: DROPPABLE_MAP_CONTAINER_TYPE,
+        index: containerId
+      },
+      disabled: !containerId
+    }),
+    isOver = _useDroppable.isOver,
+    setNodeRef = _useDroppable.setNodeRef;
+  return /*#__PURE__*/React.createElement(StyledDroppable, {
+    ref: setNodeRef,
+    $isOver: isOver
+  });
+};
+
+// Attribution UI (parser + components) lives in ./map/attribution and is
+// re-exported here to preserve the public import path (@kepler.gl/components).
+export { Attribution, AttributionLogos, renderBasemapAttribution, dedupeBasemapAttributions };
+MapContainerFactory.deps = [MapPopoverFactory, MapControlFactory, EditorFactory, MapScaleFactory];
+export default function MapContainerFactory(MapPopover, MapControl, Editor, MapScale) {
+  var MapContainer = /*#__PURE__*/function (_Component) {
+    function MapContainer(_props) {
+      var _this;
+      _classCallCheck(this, MapContainer);
+      _this = _callSuper(this, MapContainer, [_props]);
+      _defineProperty(_this, "displayName", 'MapContainer');
+      _defineProperty(_this, "anyActiveLayerLoading", false);
+      _defineProperty(_this, "state", {
+        // true for built-in kepler.gl styles (dark-matter, positron, …) and when the
+        // basemap uses Mapbox-hosted tiles (mapbox:// sources).
+        // For user-added custom styles (OpenFreeMap, CARTO self-hosted, …) MapLibre is
+        // merely the rendering engine, not the tile provider, so the logo is hidden and
+        // the basemap's own TileJSON attribution is shown instead.
+        showBaseMapLibLogo: false,
+        // attribution strings collected from the resolved map sources (e.g. CARTO,
+        // OpenFreeMap).  Populated after TileJSON resolves.
+        basemapAttributions: []
+      });
+      _defineProperty(_this, "_deck", null);
+      _defineProperty(_this, "_map", null);
+      _defineProperty(_this, "_ref", /*#__PURE__*/createRef());
+      _defineProperty(_this, "_deckGLErrorsElapsed", {});
+      _defineProperty(_this, "_basemapSourceDataListener", null);
+      _defineProperty(_this, "_basemapIdleListener", null);
+      _defineProperty(_this, "_onMapRender", function () {
+        if (typeof _this.props.onMapRender === 'function') {
+          _this.props.onMapRender(_this._map);
+        }
+      });
+      _defineProperty(_this, "previousLayers", {
+        // [layers.id]: mapboxLayerConfig
+      });
+      _defineProperty(_this, "_handleResize", function (dimensions) {
+        var _this$props = _this.props,
+          primary = _this$props.primary,
+          index = _this$props.index;
+        if (primary) {
+          var mapStateActions = _this.props.mapStateActions;
+          if (dimensions && dimensions.width > 0 && dimensions.height > 0) {
+            mapStateActions.updateMap(dimensions, index);
+          }
+        }
+      });
+      _defineProperty(_this, "layersSelector", function (props) {
+        return props.visState.layers;
+      });
+      _defineProperty(_this, "layerDataSelector", function (props) {
+        return props.visState.layerData;
+      });
+      _defineProperty(_this, "splitMapSelector", function (props) {
+        return props.visState.splitMaps;
+      });
+      _defineProperty(_this, "splitMapIndexSelector", function (props) {
+        return props.index;
+      });
+      _defineProperty(_this, "mapLayersSelector", createSelector(_this.splitMapSelector, _this.splitMapIndexSelector, getMapLayersFromSplitMaps));
+      _defineProperty(_this, "layerOrderSelector", function (props) {
+        return props.visState.layerOrder;
+      });
+      _defineProperty(_this, "layersToRenderSelector", createSelector(_this.layersSelector, _this.layerDataSelector, _this.mapLayersSelector, prepareLayersToRender));
+      _defineProperty(_this, "layersForDeckSelector", createSelector(_this.layersSelector, _this.layerDataSelector, prepareLayersForDeck));
+      _defineProperty(_this, "filtersSelector", function (props) {
+        return props.visState.filters;
+      });
+      _defineProperty(_this, "polygonFiltersSelector", createSelector(_this.filtersSelector, function (filters) {
+        return filters.filter(function (f) {
+          return f.type === FILTER_TYPES.polygon && f.enabled !== false;
+        });
+      }));
+      _defineProperty(_this, "featuresSelector", function (props) {
+        return props.visState.editor.features;
+      });
+      _defineProperty(_this, "selectedFeatureSelector", function (props) {
+        return props.visState.editor.selectedFeature;
+      });
+      _defineProperty(_this, "featureCollectionSelector", createSelector(_this.polygonFiltersSelector, _this.featuresSelector, function (polygonFilters, features) {
+        return {
+          type: 'FeatureCollection',
+          features: features.concat(polygonFilters.map(function (f) {
+            return f.value;
+          }))
+        };
+      }));
+      // @ts-ignore - No overload matches this call
+      _defineProperty(_this, "selectedPolygonIndexSelector", createSelector(_this.featureCollectionSelector, _this.selectedFeatureSelector, function (collection, selectedFeature) {
+        return collection.features.findIndex(function (f) {
+          return f.id === (selectedFeature === null || selectedFeature === void 0 ? void 0 : selectedFeature.id);
+        });
+      }));
+      _defineProperty(_this, "selectedFeatureIndexArraySelector", createSelector(function (value) {
+        return value;
+      }, function (value) {
+        return value < 0 ? [] : [value];
+      }));
+      _defineProperty(_this, "generateMapboxLayerMethodSelector", function (props) {
+        var _props$generateMapbox;
+        return (_props$generateMapbox = props.generateMapboxLayers) !== null && _props$generateMapbox !== void 0 ? _props$generateMapbox : generateMapboxLayers;
+      });
+      _defineProperty(_this, "mapboxLayersSelector", createSelector(_this.layersSelector, _this.layerDataSelector, _this.layerOrderSelector, _this.layersToRenderSelector, _this.generateMapboxLayerMethodSelector, function (layer, layerData, layerOrder, layersToRender, generateMapboxLayerMethod) {
+        return generateMapboxLayerMethod(layer, layerData, layerOrder, layersToRender);
+      }));
+      // merge in a background-color style if the basemap choice is NO_MAP_ID
+      // used by <StyledMap> inline style prop
+      _defineProperty(_this, "mapStyleTypeSelector", function (props) {
+        return props.mapStyle.styleType;
+      });
+      _defineProperty(_this, "mapStyleBackgroundColorSelector", function (props) {
+        return props.mapStyle.backgroundColor;
+      });
+      _defineProperty(_this, "globeModeSelector", function (props) {
+        var _props$mapState;
+        return Boolean((_props$mapState = props.mapState) === null || _props$mapState === void 0 || (_props$mapState = _props$mapState.globe) === null || _props$mapState === void 0 ? void 0 : _props$mapState.enabled);
+      });
+      _defineProperty(_this, "globeBackgroundColorSelector", function (props) {
+        var _props$mapState2;
+        return (_props$mapState2 = props.mapState) === null || _props$mapState2 === void 0 || (_props$mapState2 = _props$mapState2.globe) === null || _props$mapState2 === void 0 || (_props$mapState2 = _props$mapState2.config) === null || _props$mapState2 === void 0 ? void 0 : _props$mapState2.backgroundColor;
+      });
+      _defineProperty(_this, "globeStarsSelector", function (props) {
+        var _props$mapState3;
+        return Boolean((_props$mapState3 = props.mapState) === null || _props$mapState3 === void 0 || (_props$mapState3 = _props$mapState3.globe) === null || _props$mapState3 === void 0 || (_props$mapState3 = _props$mapState3.config) === null || _props$mapState3 === void 0 ? void 0 : _props$mapState3.stars);
+      });
+      _defineProperty(_this, "styleSelector", createSelector(_this.mapStyleTypeSelector, _this.mapStyleBackgroundColorSelector, _this.globeModeSelector, _this.globeBackgroundColorSelector, _this.globeStarsSelector, function (styleType, backgroundColor, isGlobeMode, globeBackgroundColor, globeStars) {
+        return _objectSpread(_objectSpread(_objectSpread({}, MAP_STYLE.container), styleType === NO_MAP_ID ? {
+          backgroundColor: rgbToHex(backgroundColor)
+        } : {}), isGlobeMode ? _objectSpread({
+          // Fall back to the default globe background when none is configured.
+          backgroundColor: rgbToHex(globeBackgroundColor || getGlobeClearColor().slice(0, 3))
+        }, globeStars ? {
+          backgroundImage: "url('".concat(getStarsBackgroundImage(), "')"),
+          backgroundRepeat: 'repeat'
+        } : {}) : {});
+      }));
+      /* component private functions */
+      _defineProperty(_this, "_onCloseMapPopover", function () {
+        _this.props.visStateActions.onLayerClick(null);
+      });
+      _defineProperty(_this, "_onLayerHover", function (_idx, info) {
+        _this.props.visStateActions.onLayerHover(info, _this.props.index);
+      });
+      _defineProperty(_this, "_onLayerSetDomain", function (idx, value) {
+        // deck.gl 9 native aggregation layers (Grid, Hexagon) pass
+        // {domain, aggregatedBins} via our ScaleEnhanced* overrides,
+        // while ClusterLayer's CPUAggregator also passes {domain, aggregatedBins}.
+        // Plain [min, max] is a fallback if the override is bypassed.
+        var config = Array.isArray(value) ? {
+          colorDomain: value
+        } : {
+          colorDomain: value.domain,
+          aggregatedBins: value.aggregatedBins
+        };
+        var layer = _this.props.visState.layers[idx];
+        if (!layer) return;
+        _this.props.visStateActions.layerConfigChange(layer, config);
+      });
+      _defineProperty(_this, "_onRedrawNeeded", function (_idx) {
+        // updateMapUpdater always returns a new state object reference, which triggers re-render
+        var _this$props2 = _this.props,
+          mapStateActions = _this$props2.mapStateActions,
+          index = _this$props2.index;
+        mapStateActions.updateMap({}, index);
+      });
+      _defineProperty(_this, "_onFitBounds", function (_idx, bounds) {
+        _this.props.mapStateActions.fitBounds(bounds);
+      });
+      _defineProperty(_this, "_onLayerFilteredItemsChange", function (idx, event) {
+        _this.props.visStateActions.layerFilteredItemsChange(_this.props.visState.layers[idx], event);
+      });
+      _defineProperty(_this, "_onWMSFeatureInfo", function (idx, data) {
+        _this.props.visStateActions.wmsFeatureInfo(_this.props.visState.layers[idx], data.featureInfo, data.coordinate);
+      });
+      _defineProperty(_this, "_handleMapToggleLayer", function (layerId) {
+        var _this$props3 = _this.props,
+          _this$props3$index = _this$props3.index,
+          mapIndex = _this$props3$index === void 0 ? 0 : _this$props3$index,
+          visStateActions = _this$props3.visStateActions;
+        visStateActions.toggleLayerForMap(mapIndex, layerId);
+      });
+      _defineProperty(_this, "_onMapboxStyleUpdate", function (update) {
+        // force refresh mapboxgl layers
+        _this.previousLayers = {};
+        _this._updateMapboxLayers();
+        _this._updateAttribution(update);
+        if (typeof _this.props.onMapStyleLoaded === 'function') {
+          _this.props.onMapStyleLoaded(_this._map);
+        }
+      });
+      _defineProperty(_this, "_updateAttribution", function (update) {
+        var _this$props$mapStyle, _this$props$mapStyle2;
+        _this._removeBasemapAttributionListeners();
+        var styleObj = (update === null || update === void 0 ? void 0 : update.style) || null;
+        if (!styleObj && _this._map) {
+          try {
+            var _this$_map$isStyleLoa, _this$_map, _this$_map$getStyle, _this$_map2;
+            var rawStyle = (_this$_map$isStyleLoa = (_this$_map = _this._map).isStyleLoaded) !== null && _this$_map$isStyleLoa !== void 0 && _this$_map$isStyleLoa.call(_this$_map) ? (_this$_map$getStyle = (_this$_map2 = _this._map).getStyle) === null || _this$_map$getStyle === void 0 ? void 0 : _this$_map$getStyle.call(_this$_map2) : null;
+            if (rawStyle) {
+              styleObj = {
+                stylesheet: rawStyle
+              };
+            }
+          } catch (_unused) {
+            // map style not ready yet
+          }
+        }
+        var usesMapbox = styleObj ? isStyleUsingMapboxTiles(styleObj) : false;
+        var usesOsm = styleObj ? isStyleUsingOpenStreetMapTiles(styleObj) : false;
+        var basemapAttributions = getBaseMapAttributions(_this._map);
+
+        // if OSM tiles are detected in the raw style but no source-level attribution
+        // string was collected yet, fold in the canonical OSM attribution so the
+        // render path stays uniform (no separate hardcoded fallback link)
+        if (usesOsm && !basemapAttributions.length) {
+          basemapAttributions.push(OSM_ATTRIBUTION_HTML);
+        }
+
+        // Determine whether to show the "Basemap by: MapLibre/Mapbox" logo:
+        //  - Always show for built-in kepler.gl styles (dark-matter, positron, …):
+        //    they don't carry their own "provider" branding so the rendering-engine
+        //    logo acts as the basemap credit.
+        //  - Always show when Mapbox tiles are in use (mapbox:// sources): Mapbox
+        //    attribution is required.
+        //  - Hide for custom user-added styles (custom === 'LOCAL' | 'MANAGED'):
+        //    those styles supply their own TileJSON attribution (e.g. OpenFreeMap),
+        //    so showing "Basemap by: MapLibre" would be misleading.
+        var styleType = (_this$props$mapStyle = _this.props.mapStyle) === null || _this$props$mapStyle === void 0 ? void 0 : _this$props$mapStyle.styleType;
+        var currentStyle = (_this$props$mapStyle2 = _this.props.mapStyle) === null || _this$props$mapStyle2 === void 0 || (_this$props$mapStyle2 = _this$props$mapStyle2.mapStyles) === null || _this$props$mapStyle2 === void 0 ? void 0 : _this$props$mapStyle2[styleType];
+        var isUserCustomStyle = Boolean(currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.custom);
+        var showBaseMapLibLogo = usesMapbox || !isUserCustomStyle;
+        _this.setState({
+          showBaseMapLibLogo: showBaseMapLibLogo,
+          basemapAttributions: basemapAttributions
+        });
+
+        // For non-Mapbox styles, TileJSON attribution resolves asynchronously
+        // after style.load.  Start a listener so we can update basemapAttributions
+        // as soon as the sources resolve their TileJSON.
+        if (!usesMapbox) {
+          _this._collectBasemapAttributions();
+        }
+      });
+      _defineProperty(_this, "_removeBasemapAttributionListeners", function () {
+        if (_this._basemapSourceDataListener && _this._map) {
+          _this._map.off('sourcedata', _this._basemapSourceDataListener);
+          _this._basemapSourceDataListener = null;
+        }
+        if (_this._basemapIdleListener && _this._map) {
+          _this._map.off('idle', _this._basemapIdleListener);
+          _this._basemapIdleListener = null;
+        }
+      });
+      _defineProperty(_this, "_collectBasemapAttributions", function () {
+        if (!_this._map) return;
+        _this._removeBasemapAttributionListeners();
+        var attempts = 0;
+        // Cap retries so a style that never yields attributions doesn't leave a
+        // permanent sourcedata listener attached.
+        var MAX_ATTEMPTS = 50;
+        var tryCollect = function tryCollect() {
+          // TileJSON resolves asynchronously; re-collect attributions once a
+          // source's metadata is available so custom basemap attributions are not lost.
+          var basemapAttributions = getBaseMapAttributions(_this._map);
+          if (basemapAttributions.length) {
+            _this._removeBasemapAttributionListeners();
+            // Don't change showBaseMapLibLogo here — it is fixed at style.load time
+            // based on whether the style uses Mapbox tiles.  We only update the
+            // provider attributions collected from the resolved TileJSON.
+            _this.setState({
+              basemapAttributions: basemapAttributions
+            });
+            return true;
+          }
+          return false;
+        };
+        var onSourceData = function onSourceData(e) {
+          // Collect attributions when:
+          //   (a) a source's TileJSON has just been fetched (sourceDataType === 'metadata') —
+          //       this is the earliest moment the `attribution` property is available on the
+          //       resolved source object, or
+          //   (b) a source is fully loaded (isSourceLoaded === true) — fallback for raster
+          //       sources or styles that set attribution inline rather than via TileJSON.
+          if (!(e !== null && e !== void 0 && e.isSourceLoaded) && (e === null || e === void 0 ? void 0 : e.sourceDataType) !== 'metadata') return;
+          attempts++;
+          tryCollect();
+          if (attempts >= MAX_ATTEMPTS) {
+            _this._removeBasemapAttributionListeners();
+          }
+        };
+
+        // The `idle` event fires when the map has finished loading all pending
+        // resources (tiles, TileJSON, sprites). At that point attributions from
+        // all sources are guaranteed to be resolved, so this is a reliable
+        // one-shot fallback that catches cases where the sourcedata metadata
+        // events are missed or the source never reaches isSourceLoaded.
+        var onIdle = function onIdle() {
+          _this._removeBasemapAttributionListeners();
+          var basemapAttributions = getBaseMapAttributions(_this._map);
+          if (basemapAttributions.length) {
+            _this.setState({
+              basemapAttributions: basemapAttributions
+            });
+          }
+        };
+        _this._basemapSourceDataListener = onSourceData;
+        _this._basemapIdleListener = onIdle;
+        _this._map.on('sourcedata', onSourceData);
+        _this._map.on('idle', onIdle);
+      });
+      _defineProperty(_this, "_setMapRef", function (mapRef) {
+        // Handle change of the map library
+        if (_this._map && mapRef) {
+          var map = mapRef.getMap();
+          if (map && _this._map !== map) {
+            _this._map.off(MAPBOXGL_STYLE_UPDATE, _this._onMapboxStyleUpdate);
+            _this._map.off(MAPBOXGL_RENDER, _this._onMapRender);
+            _this._removeBasemapAttributionListeners();
+            _this._map = null;
+          }
+        }
+        if (!_this._map && mapRef) {
+          _this._map = mapRef.getMap();
+          // i noticed in certain context we don't access the actual map element
+          if (!_this._map) {
+            return;
+          }
+          // bind mapboxgl event listener
+          _this._map.on(MAPBOXGL_STYLE_UPDATE, _this._onMapboxStyleUpdate);
+          _this._map.on(MAPBOXGL_RENDER, _this._onMapRender);
+        }
+        if (_this.props.getMapboxRef) {
+          // The parent component can gain access to our MapboxGlMap by
+          // providing this callback. Note that 'mapbox' will be null when the
+          // ref is unset (e.g. when a split map is closed).
+          _this.props.getMapboxRef(mapRef, _this.props.index);
+        }
+      });
+      _defineProperty(_this, "_onBeforeRender", function () {
+        // no-op
+      });
+      _defineProperty(_this, "_annotationViewportCache", null);
+      _defineProperty(_this, "_wasInteracting", false);
+      _defineProperty(_this, "_onDeckError", function (error, layer) {
+        var errorMessage = (error === null || error === void 0 ? void 0 : error.message) || 'unknown-error';
+        var layerMessage = layer !== null && layer !== void 0 && layer.id ? " in ".concat(layer.id, " layer") : '';
+        var errorMessageFull = errorMessage === 'WebGL context is lost' ? 'Your GPU was disconnected. This can happen if your computer goes to sleep. It can also occur for other reasons, such as if you are running too many GPU applications.' : "An error in deck.gl: ".concat(errorMessage).concat(layerMessage, ".");
+
+        // Throttle error notifications, as React doesn't like too many state changes from here.
+        var lastShown = _this._deckGLErrorsElapsed[errorMessageFull];
+        if (!lastShown || lastShown < Date.now() - THROTTLE_NOTIFICATION_TIME) {
+          _this._deckGLErrorsElapsed[errorMessageFull] = Date.now();
+
+          // Mark layer as invalid
+          var extraLayerMessage = '';
+          var visStateActions = _this.props.visStateActions;
+          if (layer) {
+            var _topMostLayer$props;
+            var topMostLayer = layer;
+            while (topMostLayer.parent) {
+              topMostLayer = topMostLayer.parent;
+            }
+            if ((_topMostLayer$props = topMostLayer.props) !== null && _topMostLayer$props !== void 0 && _topMostLayer$props.id) {
+              visStateActions.layerSetIsValid(topMostLayer, false);
+              extraLayerMessage = 'The layer has been disabled and highlighted.';
+            }
+          }
+
+          // Create new error notification or update existing one with same id.
+          // Update is required to preserve the order of notifications as they probably are going to "jump" based on order of errors.
+          var uiStateActions = _this.props.uiStateActions;
+          uiStateActions.addNotification(errorNotification({
+            message: "".concat(errorMessageFull, " ").concat(extraLayerMessage),
+            id: errorMessageFull // treat the error message as id
+          }));
+        }
+      });
+      _defineProperty(_this, "_onViewportChangePropagateDebounced", debounce(function () {
+        var _this$context;
+        var viewState = (_this$context = _this.context) === null || _this$context === void 0 ? void 0 : _this$context.getInternalViewState(_this.props.index);
+        onViewPortChange(viewState, _this.props.mapStateActions.updateMap, _this.props.onViewStateChange, _this.props.primary, _this.props.index);
+      }, DEBOUNCE_VIEWPORT_PROPAGATE));
+      _defineProperty(_this, "_onViewportChange", function (viewport) {
+        var _this$props$mapState;
+        var viewState = viewport.viewState,
+          interactionState = viewport.interactionState;
+        if (_this.props.isExport) {
+          // Image export map shouldn't be interactive (otherwise this callback can
+          // lead to inadvertent changes to the state of the main map)
+          return;
+        }
+        var setInternalViewState = _this.context.setInternalViewState;
+
+        // Flat map (2D/3D): keep the original, always-synchronous behavior. The
+        // interaction-aware timing below exists purely to fix globe-specific
+        // controlled-viewState, so it must not change the main 2D logic.
+        if (!((_this$props$mapState = _this.props.mapState) !== null && _this$props$mapState !== void 0 && (_this$props$mapState = _this$props$mapState.globe) !== null && _this$props$mapState !== void 0 && _this$props$mapState.enabled)) {
+          setInternalViewState(viewState, _this.props.index);
+          _this._wasInteracting = false;
+          _this._onViewportChangePropagateDebounced();
+          return;
+        }
+        var isUserInteraction = interactionState && (interactionState.isZooming || interactionState.isPanning || interactionState.isRotating || interactionState.isDragging || interactionState.inTransition);
+        // The emit that ends a gesture (panend/rotateEnd, or a fling transition
+        // ending) arrives with all interaction flags false. If we defer it, the
+        // controlled `viewState` fed back to deck lags a frame behind the
+        // controller's committed state and deck re-seeds from the stale value,
+        // making the globe visibly "jump back" to where the drag was released -
+        // most noticeable on a throw/fling release. Treat the first all-false emit
+        // right after an active gesture as part of that gesture and apply it
+        // synchronously too.
+        var isInteractionSettle = !isUserInteraction && _this._wasInteracting;
+        _this._wasInteracting = Boolean(isUserInteraction);
+        if (isUserInteraction || isInteractionSettle) {
+          // For interactive gestures (pan/zoom/rotate) and their end-of-gesture
+          // settle, update synchronously so the controlled `viewState` stays in
+          // lockstep with the controller and there's no stale re-seed.
+          setInternalViewState(viewState, _this.props.index);
+        } else {
+          // deck.gl can fire onViewStateChange synchronously during its own render
+          // (e.g. when switching view types like MapView -> GlobeView). Updating React
+          // state during render throws a warning, so defer non-interactive updates.
+          setTimeout(function () {
+            setInternalViewState(viewState, _this.props.index);
+          }, 0);
+        }
+        _this._onViewportChangePropagateDebounced();
+      });
+      _defineProperty(_this, "_onLayerHoverDebounced", debounce(function (data, index) {
+        _this.props.visStateActions.onLayerHover(data, index);
+      }, DEBOUNCE_MOUSE_MOVE_PROPAGATE));
+      _defineProperty(_this, "_onMouseMoveDebounced", debounce(function (event, viewport) {
+        _this.props.visStateActions.onMouseMove(normalizeEvent(event, viewport));
+      }, DEBOUNCE_MOUSE_MOVE_PROPAGATE));
+      _defineProperty(_this, "_onLayerLoadingStateChange", debounce(function () {
+        // trigger loading indicator update without any change to update UI
+        _this.props.visStateActions.setLoadingIndicator({
+          change: 0
+        });
+      }, DEBOUNCE_LOADING_STATE_PROPAGATE));
+      _defineProperty(_this, "_handleToggleLayerVisibility", function (layer) {
+        var visStateActions = _this.props.visStateActions;
+        visStateActions.layerConfigChange(layer, {
+          isVisible: !layer.config.isVisible
+        });
+      });
+      _defineProperty(_this, "_toggleMapControl", function (panelId) {
+        var _this$props4 = _this.props,
+          index = _this$props4.index,
+          uiStateActions = _this$props4.uiStateActions;
+        uiStateActions.toggleMapControl(panelId, Number(index));
+      });
+      patchDeckRendererForPostProcessing();
+      return _this;
+    }
+    _inherits(MapContainer, _Component);
+    return _createClass(MapContainer, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        if (!this._ref.current) {
+          return;
+        }
+        observeDimensions(this._ref.current, this._handleResize);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if (this._map) {
+          this._map.off(MAPBOXGL_STYLE_UPDATE, this._onMapboxStyleUpdate);
+          this._map.off(MAPBOXGL_RENDER, this._onMapRender);
+          this._removeBasemapAttributionListeners();
+        }
+        if (!this._ref.current) {
+          return;
+        }
+        unobserveDimensions(this._ref.current);
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        if (prevProps.mapStyle.styleType !== this.props.mapStyle.styleType) {
+          this._removeBasemapAttributionListeners();
+          if (this.props.mapStyle.styleType === NO_MAP_ID) {
+            this.setState({
+              showBaseMapLibLogo: false,
+              basemapAttributions: []
+            });
+          } else {
+            this._updateAttribution();
+          }
+        }
+      }
+    }, {
+      key: "_onDeckInitialized",
+      value: function _onDeckInitialized(device) {
+        if (this.props.onDeckInitialized) {
+          this.props.onDeckInitialized(this._deck, device);
+        }
+      }
+
+      /**
+       * 1) Allow effects only for the first view.
+       * 2) Prevent effect:preRender call without valid generated viewports.
+       * @param viewIndex View index.
+       * @returns Returns true if effects can be used.
+       */
+    }, {
+      key: "_isOKToRenderEffects",
+      value: function _isOKToRenderEffects(viewIndex) {
+        var _this$_deck;
+        return !viewIndex && Boolean((_this$_deck = this._deck) === null || _this$_deck === void 0 || (_this$_deck = _this$_deck.viewManager) === null || _this$_deck === void 0 || (_this$_deck = _this$_deck._viewports) === null || _this$_deck === void 0 ? void 0 : _this$_deck.length);
+      }
+    }, {
+      key: "_getAnnotationViewport",
+      value: function _getAnnotationViewport(mapState, internalViewState) {
+        var _internalViewState$lo, _internalViewState$la, _internalViewState$zo, _ref3, _internalViewState$pi, _ref4, _internalViewState$be, _this$_annotationView;
+        var longitude = (_internalViewState$lo = internalViewState === null || internalViewState === void 0 ? void 0 : internalViewState.longitude) !== null && _internalViewState$lo !== void 0 ? _internalViewState$lo : mapState.longitude;
+        var latitude = (_internalViewState$la = internalViewState === null || internalViewState === void 0 ? void 0 : internalViewState.latitude) !== null && _internalViewState$la !== void 0 ? _internalViewState$la : mapState.latitude;
+        var zoom = (_internalViewState$zo = internalViewState === null || internalViewState === void 0 ? void 0 : internalViewState.zoom) !== null && _internalViewState$zo !== void 0 ? _internalViewState$zo : mapState.zoom;
+        var pitch = (_ref3 = (_internalViewState$pi = internalViewState === null || internalViewState === void 0 ? void 0 : internalViewState.pitch) !== null && _internalViewState$pi !== void 0 ? _internalViewState$pi : mapState.pitch) !== null && _ref3 !== void 0 ? _ref3 : 0;
+        var bearing = (_ref4 = (_internalViewState$be = internalViewState === null || internalViewState === void 0 ? void 0 : internalViewState.bearing) !== null && _internalViewState$be !== void 0 ? _internalViewState$be : mapState.bearing) !== null && _ref4 !== void 0 ? _ref4 : 0;
+        var width = mapState.width || 0;
+        var height = mapState.height || 0;
+        var key = "".concat(longitude, ",").concat(latitude, ",").concat(zoom, ",").concat(pitch, ",").concat(bearing, ",").concat(width, ",").concat(height);
+        if (((_this$_annotationView = this._annotationViewportCache) === null || _this$_annotationView === void 0 ? void 0 : _this$_annotationView.key) === key) {
+          return this._annotationViewportCache.viewport;
+        }
+        var mergedState = _objectSpread(_objectSpread(_objectSpread({}, mapState), internalViewState), {}, {
+          width: width,
+          height: height
+        });
+        var vp = getViewportFromMapState(mergedState);
+        var viewport = {
+          project: function project(lngLat) {
+            return vp.project(lngLat);
+          },
+          unproject: function unproject(xy) {
+            return vp.unproject(xy);
+          },
+          longitude: longitude,
+          latitude: latitude,
+          width: width,
+          height: height,
+          zoom: zoom
+        };
+        this._annotationViewportCache = {
+          key: key,
+          viewport: viewport
+        };
+        return viewport;
+      }
+    }, {
+      key: "_renderMapPopover",
+      value: /* component render functions */
+
+      /* eslint-disable complexity */
+      function _renderMapPopover() {
+        var _this$props$visState$;
+        // this check is for limiting the display of the `<MapPopover>` to the `<MapContainer>` the user is interacting with
+        // the DeckGL onHover event handler adds a `mapIndex` property which is available in the `hoverInfo` object of `visState`
+        if (this.props.index !== ((_this$props$visState$ = this.props.visState.hoverInfo) === null || _this$props$visState$ === void 0 ? void 0 : _this$props$visState$.mapIndex)) {
+          return null;
+        }
+
+        // TODO: move this into reducer so it can be tested
+        var _this$props5 = this.props,
+          mapState = _this$props5.mapState,
+          _this$props5$visState = _this$props5.visState,
+          hoverInfo = _this$props5$visState.hoverInfo,
+          clicked = _this$props5$visState.clicked,
+          datasets = _this$props5$visState.datasets,
+          interactionConfig = _this$props5$visState.interactionConfig,
+          animationConfig = _this$props5$visState.animationConfig,
+          layers = _this$props5$visState.layers,
+          _this$props5$visState2 = _this$props5$visState.mousePos,
+          mousePosition = _this$props5$visState2.mousePosition,
+          coordinate = _this$props5$visState2.coordinate,
+          pinned = _this$props5$visState2.pinned;
+        var layersToRender = this.layersToRenderSelector(this.props);
+        if (!mousePosition || !interactionConfig.tooltip) {
+          return null;
+        }
+        var layerHoverProp = getLayerHoverProp({
+          animationConfig: animationConfig,
+          interactionConfig: interactionConfig,
+          hoverInfo: hoverInfo,
+          layers: layers,
+          layersToRender: layersToRender,
+          datasets: datasets
+        });
+        var compareMode = interactionConfig.tooltip.config ? interactionConfig.tooltip.config.compareMode : false;
+        var pinnedPosition = {
+          x: 0,
+          y: 0
+        };
+        var layerPinnedProp = null;
+        if (pinned || clicked) {
+          // project lnglat to screen so that tooltip follows the object on zoom
+          var viewport = getViewportFromMapState(mapState);
+          var lngLat = clicked ? clicked.coordinate : pinned.coordinate;
+          pinnedPosition = this._getHoverXY(viewport, lngLat);
+          layerPinnedProp = getLayerHoverProp({
+            animationConfig: animationConfig,
+            interactionConfig: interactionConfig,
+            hoverInfo: clicked,
+            layers: layers,
+            layersToRender: layersToRender,
+            datasets: datasets
+          });
+          if (layerHoverProp && layerPinnedProp) {
+            layerHoverProp.primaryData = layerPinnedProp.data;
+            layerHoverProp.compareType = interactionConfig.tooltip.config.compareType;
+          }
+        }
+        var commonProp = {
+          onClose: this._onCloseMapPopover,
+          zoom: mapState.zoom,
+          container: this._deck ? this._deck.canvas : undefined
+        };
+        return /*#__PURE__*/React.createElement(ErrorBoundary, null, layerPinnedProp && /*#__PURE__*/React.createElement(MapPopover, _extends({}, pinnedPosition, commonProp, {
+          layerHoverProp: layerPinnedProp,
+          coordinate: interactionConfig.coordinate.enabled && (pinned || {}).coordinate,
+          frozen: true,
+          isBase: compareMode,
+          onSetFeatures: this.props.visStateActions.setFeatures,
+          setSelectedFeature: this.props.visStateActions.setSelectedFeature
+          // @ts-ignore Argument of type 'Readonly<MapContainerProps>' is not assignable to parameter of type 'never'
+          ,
+          featureCollection: this.featureCollectionSelector(this.props)
+        })), layerHoverProp && (!layerPinnedProp || compareMode) && /*#__PURE__*/React.createElement(MapPopover, _extends({
+          x: mousePosition[0],
+          y: mousePosition[1]
+        }, commonProp, {
+          layerHoverProp: layerHoverProp,
+          frozen: false,
+          coordinate: interactionConfig.coordinate.enabled && coordinate,
+          onSetFeatures: this.props.visStateActions.setFeatures,
+          setSelectedFeature: this.props.visStateActions.setSelectedFeature
+          // @ts-ignore Argument of type 'Readonly<MapContainerProps>' is not assignable to parameter of type 'never'
+          ,
+          featureCollection: this.featureCollectionSelector(this.props)
+        })));
+      }
+
+      /* eslint-enable complexity */
+    }, {
+      key: "_getHoverXY",
+      value: function _getHoverXY(viewport, lngLat) {
+        var screenCoord = !viewport || !lngLat ? null : viewport.project(lngLat);
+        return screenCoord && {
+          x: screenCoord[0],
+          y: screenCoord[1]
+        };
+      }
+    }, {
+      key: "_renderDeckOverlay",
+      value: function _renderDeckOverlay(layersForDeck) {
+        var _this$context2,
+          _mapState$globe,
+          _mapStyle$mapStyles,
+          _this2 = this,
+          _this$props$mapState$;
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+          primaryMap: false
+        };
+        var _this$props6 = this.props,
+          mapStyle = _this$props6.mapStyle,
+          visState = _this$props6.visState,
+          mapState = _this$props6.mapState,
+          visStateActions = _this$props6.visStateActions,
+          mapboxApiAccessToken = _this$props6.mapboxApiAccessToken,
+          mapboxApiUrl = _this$props6.mapboxApiUrl,
+          deckGlProps = _this$props6.deckGlProps,
+          index = _this$props6.index,
+          mapControls = _this$props6.mapControls,
+          deckRenderCallbacks = _this$props6.deckRenderCallbacks,
+          theme = _this$props6.theme,
+          generateDeckGLLayers = _this$props6.generateDeckGLLayers,
+          onMouseMove = _this$props6.onMouseMove;
+        var hoverInfo = visState.hoverInfo,
+          editor = visState.editor;
+        var primaryMap = options.primaryMap,
+          isInteractive = options.isInteractive,
+          children = options.children;
+
+        // disable double click zoom when editor is in any draw mode
+        var mapDraw = mapControls.mapDraw;
+        var _ref5 = mapDraw || {},
+          _ref5$active = _ref5.active,
+          editorMenuActive = _ref5$active === void 0 ? false : _ref5$active;
+        var isEditorDrawingMode = EditorLayerUtils.isDrawingActive(editorMenuActive, editor.mode);
+        var internalViewState = (_this$context2 = this.context) === null || _this$context2 === void 0 ? void 0 : _this$context2.getInternalViewState(index);
+        var internalMapState = _objectSpread(_objectSpread({}, mapState), internalViewState);
+        var viewport = getViewportFromMapState(internalMapState);
+        var editorFeatureSelectedIndex = this.selectedPolygonIndexSelector(this.props);
+        var setFeatures = visStateActions.setFeatures,
+          onLayerClick = visStateActions.onLayerClick,
+          setSelectedFeature = visStateActions.setSelectedFeature;
+        var generateDeckGLLayersMethod = generateDeckGLLayers !== null && generateDeckGLLayers !== void 0 ? generateDeckGLLayers : computeDeckLayers;
+        var extraDeckParams = {};
+        if (primaryMap) {
+          // Omit hover updates when the pointer position is invalid, ie. over UI overlays or
+          // outside the map container. In those cases x/y may be < 0
+          extraDeckParams.getTooltip = function (info) {
+            var x = Number(info === null || info === void 0 ? void 0 : info.x);
+            var y = Number(info === null || info === void 0 ? void 0 : info.y);
+            if (Number.isNaN(x) || Number.isNaN(y) || x < 0 || y < 0) return null;
+            return EditorLayerUtils.getTooltip(info, {
+              editorMenuActive: editorMenuActive,
+              editor: editor,
+              theme: theme
+            });
+          };
+          extraDeckParams.getCursor = function (_ref6) {
+            var isDragging = _ref6.isDragging;
+            var editorCursor = EditorLayerUtils.getCursor({
+              editorMenuActive: editorMenuActive,
+              editor: editor,
+              hoverInfo: hoverInfo
+            });
+            if (editorCursor) return editorCursor;
+            if (isDragging) return 'grabbing';
+            if (hoverInfo !== null && hoverInfo !== void 0 && hoverInfo.layer) return 'pointer';
+            return 'grab';
+          };
+        }
+        var effects = this._isOKToRenderEffects(index) ? computeDeckEffects({
+          visState: visState,
+          mapState: mapState,
+          isExport: this.props.isExport
+        }) : [];
+        var isGlobeMode = (_mapState$globe = mapState.globe) === null || _mapState$globe === void 0 ? void 0 : _mapState$globe.enabled;
+
+        // In globe mode with a non-default blend mode, forward pre-computed layer
+        // rendering parameters into mapState so individual layers can merge them into
+        // their own parameters objects. The global DeckGL parameters cannot be used in
+        // globe mode because they are merged into globe system layers (atmosphere,
+        // surface, etc.) and alter their carefully tuned blend/depth state.
+        // 'normal' is omitted — it is the WebGL default and injecting it would
+        // override intentional blend:false settings on layers like trip/scenegraph.
+        var layerBlendingParams = isGlobeMode && visState.layerBlending && visState.layerBlending !== 'normal' ? getLayerBlendingParameters(visState.layerBlending) : undefined;
+        var deckLayersMapState = layerBlendingParams ? _objectSpread(_objectSpread({}, internalMapState), {}, {
+          layerParameters: layerBlendingParams
+        }) : internalMapState;
+        var deckGlLayers = generateDeckGLLayersMethod({
+          visState: visState,
+          mapState: deckLayersMapState,
+          mapStyle: mapStyle
+        }, {
+          mapIndex: index,
+          primaryMap: primaryMap,
+          mapboxApiAccessToken: mapboxApiAccessToken,
+          mapboxApiUrl: mapboxApiUrl,
+          layersForDeck: layersForDeck,
+          editorInfo: primaryMap ? {
+            editor: editor,
+            editorMenuActive: editorMenuActive,
+            onSetFeatures: setFeatures,
+            setSelectedFeature: setSelectedFeature,
+            onApplyPolygonFilterAll: visStateActions.setPolygonFilterAllLayers,
+            // @ts-ignore Argument of type 'Readonly<MapContainerProps>' is not assignable to parameter of type 'never'
+            featureCollection: this.featureCollectionSelector(this.props),
+            selectedFeatureIndexes: this.selectedFeatureIndexArraySelector(
+            // @ts-ignore Argument of type 'unknown' is not assignable to parameter of type 'number'.
+            editorFeatureSelectedIndex),
+            viewport: viewport
+          } : undefined
+        }, {
+          onLayerHover: this._onLayerHover,
+          onSetLayerDomain: this._onLayerSetDomain,
+          onFilteredItemsChange: this._onLayerFilteredItemsChange,
+          onWMSFeatureInfo: this._onWMSFeatureInfo,
+          onRedrawNeeded: this._onRedrawNeeded,
+          onFitBounds: this._onFitBounds
+        }, deckGlProps);
+
+        // Follow the selected basemap style's library so the globe uses the same
+        // provider as the flat 2D map (CARTO tiles for MapLibre styles, Mapbox
+        // tiles for Mapbox styles).
+        var globeBasemapProvider = resolveGlobeBasemapProvider(getBaseMapLibrary(mapStyle === null || mapStyle === void 0 || (_mapStyle$mapStyles = mapStyle.mapStyles) === null || _mapStyle$mapStyles === void 0 ? void 0 : _mapStyle$mapStyles[mapStyle === null || mapStyle === void 0 ? void 0 : mapStyle.styleType]), mapboxApiAccessToken || '');
+
+        // In globe mode, prepend globe base layers and append top layers
+        var globeBaseLayers = isGlobeMode && mapState.globe ? getGlobeBaseLayers({
+          mapboxApiAccessToken: mapboxApiAccessToken || '',
+          globe: mapState.globe,
+          mapStyleType: mapStyle === null || mapStyle === void 0 ? void 0 : mapStyle.styleType,
+          basemapProvider: globeBasemapProvider,
+          // Use the live (internal) latitude so the tile LOD compensation
+          // stays in sync with the deck viewport during a drag; mapState
+          // latitude lags behind while rotating.
+          latitude: internalMapState.latitude,
+          zoom: internalMapState.zoom
+        }) : [];
+        var globeTopLayers = isGlobeMode && mapState.globe ? getGlobeTopLayers({
+          globe: mapState.globe,
+          zoom: internalMapState.zoom
+        }) : [];
+        var finalDeckGlLayers = isGlobeMode ? [].concat(_toConsumableArray(globeBaseLayers), _toConsumableArray(deckGlLayers), _toConsumableArray(globeTopLayers)) : deckGlLayers;
+        var views = deckGlProps !== null && deckGlProps !== void 0 && deckGlProps.views ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.views() : isGlobeMode ? new KeplerGlobeView({
+          resolution: 5,
+          // The visible background around the globe is painted by the map
+          // container's CSS background (see styleSelector), NOT by a per-view
+          // color clear. deck.gl applies a View's `clearColor` in *every* pass,
+          // including the picking pass, and it forces the cleared alpha to 255
+          // (`clearColor[3] || 255`). In the picking buffer the alpha byte encodes
+          // the layer index, so a 255 clear makes deck.gl decode every pixel as a
+          // non-existent layer ("Picked non-existent layer. Is picking buffer
+          // corrupt?") on hover. `clearColor: false` skips the per-view color
+          // clear so the picking buffer keeps its 0 alpha; the canvas stays
+          // transparent and the CSS background shows through.
+          clear: true,
+          clearColor: false
+        }) : new MapView({
+          farZMultiplier: 1.2
+        });
+        var allDeckGlProps = _objectSpread(_objectSpread({}, deckGlProps), {}, {
+          pickingRadius: DEFAULT_PICKING_RADIUS,
+          views: views,
+          layers: finalDeckGlLayers,
+          effects: effects,
+          parameters: isGlobeMode ? {
+            cull: true
+          } : getLayerBlendingParameters(visState.layerBlending)
+        });
+        if (typeof (deckRenderCallbacks === null || deckRenderCallbacks === void 0 ? void 0 : deckRenderCallbacks.onDeckRender) === 'function') {
+          allDeckGlProps = deckRenderCallbacks.onDeckRender(allDeckGlProps);
+          if (!allDeckGlProps) {
+            // if onDeckRender returns null, do not render deck.gl
+            return null;
+          }
+        }
+        return /*#__PURE__*/React.createElement("div", isInteractive ? {
+          onMouseMove: primaryMap ? function (event) {
+            onMouseMove === null || onMouseMove === void 0 || onMouseMove(event);
+            _this2._onMouseMoveDebounced(event, viewport);
+          } : undefined
+        } : {
+          style: {
+            pointerEvents: 'none'
+          }
+        }, /*#__PURE__*/React.createElement(DeckGL, _extends({
+          id: "default-deckgl-overlay",
+          onLoad: function onLoad() {
+            if (typeof (deckRenderCallbacks === null || deckRenderCallbacks === void 0 ? void 0 : deckRenderCallbacks.onDeckLoad) === 'function') {
+              deckRenderCallbacks.onDeckLoad();
+            }
+          }
+        }, allDeckGlProps, {
+          controller: isInteractive ? _objectSpread({
+            doubleClickZoom: !isEditorDrawingMode,
+            dragRotate: this.props.mapState.dragRotate,
+            maxPitch: (_this$props$mapState$ = this.props.mapState.maxPitch) !== null && _this$props$mapState$ !== void 0 ? _this$props$mapState$ : getApplicationConfig().maxPitch
+          }, isGlobeMode ? {
+            minZoom: GLOBE_MIN_ZOOM,
+            maxZoom: GLOBE_MAX_ZOOM
+          } : {}) : false,
+          viewState: isGlobeMode ? _objectSpread(_objectSpread({}, internalViewState), {}, {
+            minZoom: GLOBE_MIN_ZOOM,
+            maxZoom: GLOBE_MAX_ZOOM
+          }) : internalViewState,
+          onBeforeRender: this._onBeforeRender,
+          onViewStateChange: isInteractive ? this._onViewportChange : undefined
+        }, extraDeckParams, {
+          onHover: isInteractive ? function (data) {
+            var res = EditorLayerUtils.onHover(data, {
+              editorMenuActive: editorMenuActive,
+              editor: editor,
+              hoverInfo: hoverInfo
+            });
+            if (res) return;
+            _this2._onLayerHoverDebounced(data, index);
+          } : null,
+          onClick: function onClick(data, event) {
+            // @ts-ignore
+            normalizeEvent(event.srcEvent, viewport);
+
+            // Handle bitmap layer alignment mode: if a bitmap layer is waiting
+            // for a map click, route the click coordinate to it
+            if (data.coordinate) {
+              var aligningLayer = visState.layers.find(function (l) {
+                return l.type === 'bitmap' && l.alignWaitingForMap && l.config.isVisible;
+              });
+              if (aligningLayer) {
+                aligningLayer.onAlignMapClick(data.coordinate);
+                _this2._onRedrawNeeded(0);
+                return;
+              }
+            }
+            var res = EditorLayerUtils.onClick(data, event, {
+              editorMenuActive: editorMenuActive,
+              editor: editor,
+              onLayerClick: onLayerClick,
+              setSelectedFeature: setSelectedFeature,
+              mapIndex: index
+            });
+            if (res) return;
+            visStateActions.onLayerClick(data);
+          },
+          onError: this._onDeckError,
+          ref: function ref(comp) {
+            // @ts-ignore
+            if (comp && comp.deck && !_this2._deck) {
+              // @ts-ignore
+              _this2._deck = comp.deck;
+            }
+          },
+          onDeviceInitialized: function onDeviceInitialized(device) {
+            return _this2._onDeckInitialized(device);
+          },
+          onAfterRender: function onAfterRender() {
+            if (typeof (deckRenderCallbacks === null || deckRenderCallbacks === void 0 ? void 0 : deckRenderCallbacks.onDeckAfterRender) === 'function') {
+              deckRenderCallbacks.onDeckAfterRender(allDeckGlProps);
+            }
+            var anyActiveLayerLoading = areAnyDeckLayersLoading(allDeckGlProps.layers);
+            if (anyActiveLayerLoading !== _this2.anyActiveLayerLoading) {
+              _this2._onLayerLoadingStateChange();
+              _this2.anyActiveLayerLoading = anyActiveLayerLoading;
+            }
+          }
+        }), children));
+      }
+    }, {
+      key: "_updateMapboxLayers",
+      value: function _updateMapboxLayers() {
+        var mapboxLayers = this.mapboxLayersSelector(this.props);
+        if (!Object.keys(mapboxLayers).length && !Object.keys(this.previousLayers).length) {
+          return;
+        }
+        updateMapboxLayers(this._map, mapboxLayers, this.previousLayers);
+        this.previousLayers = mapboxLayers;
+      }
+    }, {
+      key: "_renderMapboxOverlays",
+      value: function _renderMapboxOverlays() {
+        if (this._map && this._map.isStyleLoaded()) {
+          this._updateMapboxLayers();
+        }
+      }
+    }, {
+      key: "_renderMap",
+      value: /* eslint-disable complexity */
+      function _renderMap() {
+        var _mapStyle$mapStyles2, _this$props$MapCompon, _this$context3, _mapState$maxPitch, _this$props$isExport, _mapState$globe2, _mapStyle$bottomMapSt, _mapState$globe3, _mapControls$annotati, _mapState$globe4, _mapState$globe5, _theme$sidePanel$marg, _theme$sidePanel, _theme$sidePanel$marg2, _theme$sidePanel2;
+        var _this$props7 = this.props,
+          visState = _this$props7.visState,
+          mapState = _this$props7.mapState,
+          mapStyle = _this$props7.mapStyle,
+          mapStateActions = _this$props7.mapStateActions,
+          mapboxApiAccessToken = _this$props7.mapboxApiAccessToken,
+          mapControls = _this$props7.mapControls,
+          isExport = _this$props7.isExport,
+          locale = _this$props7.locale,
+          uiTheme = _this$props7.uiTheme,
+          uiStateActions = _this$props7.uiStateActions,
+          visStateActions = _this$props7.visStateActions,
+          index = _this$props7.index,
+          primary = _this$props7.primary,
+          bottomMapContainerProps = _this$props7.bottomMapContainerProps,
+          topMapContainerProps = _this$props7.topMapContainerProps,
+          theme = _this$props7.theme,
+          _this$props7$datasetA = _this$props7.datasetAttributions,
+          datasetAttributions = _this$props7$datasetA === void 0 ? [] : _this$props7$datasetA,
+          _this$props7$attribut = _this$props7.attributionLogos,
+          attributionLogos = _this$props7$attribut === void 0 ? [] : _this$props7$attribut,
+          _this$props7$containe = _this$props7.containerId,
+          containerId = _this$props7$containe === void 0 ? 0 : _this$props7$containe,
+          isLoadingIndicatorVisible = _this$props7.isLoadingIndicatorVisible,
+          activeSidePanel = _this$props7.activeSidePanel,
+          sidePanelWidth = _this$props7.sidePanelWidth;
+        var layers = visState.layers,
+          datasets = visState.datasets,
+          editor = visState.editor,
+          interactionConfig = visState.interactionConfig,
+          layerOrder = visState.layerOrder;
+        var layersToRender = this.layersToRenderSelector(this.props);
+        var layersForDeck = this.layersForDeckSelector(this.props);
+
+        // Current style can be a custom style, from which we pull the mapbox API acccess token
+        var currentStyle = (_mapStyle$mapStyles2 = mapStyle.mapStyles) === null || _mapStyle$mapStyles2 === void 0 ? void 0 : _mapStyle$mapStyles2[mapStyle.styleType];
+        var baseMapLibraryName = getBaseMapLibrary(currentStyle);
+        var baseMapLibraryConfig = getApplicationConfig().baseMapLibraryConfig[baseMapLibraryName];
+
+        // Select the correct Map adapter based on the active base map library.
+        // Using the native adapter for each library avoids Transform API
+        // incompatibilities (e.g. mapbox-legacy's cloneTransform with MapLibre v5).
+        var ResolvedMapComponent = (_this$props$MapCompon = this.props.MapComponent) !== null && _this$props$MapCompon !== void 0 ? _this$props$MapCompon : baseMapLibraryName === MAP_LIB_OPTIONS.MAPBOX ? MapboxLegacyMap : MaplibreMap;
+        var useMapboxAdapter = ResolvedMapComponent === MapboxLegacyMap;
+        var internalViewState = (_this$context3 = this.context) === null || _this$context3 === void 0 ? void 0 : _this$context3.getInternalViewState(index);
+        var configMaxPitch = (_mapState$maxPitch = mapState.maxPitch) !== null && _mapState$maxPitch !== void 0 ? _mapState$maxPitch : getApplicationConfig().maxPitch;
+        var effectiveMaxPitch = useMapboxAdapter ? Math.min(configMaxPitch, MAPBOX_MAX_PITCH) : configMaxPitch;
+        var mapProps = _objectSpread(_objectSpread({}, internalViewState), {}, {
+          maxPitch: effectiveMaxPitch,
+          preserveDrawingBuffer: (_this$props$isExport = this.props.isExport) !== null && _this$props$isExport !== void 0 ? _this$props$isExport : false,
+          mapboxAccessToken: (currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.accessToken) || mapboxApiAccessToken,
+          // baseApiUrl: mapboxApiUrl,
+          transformRequest: this.props.transformRequest || transformRequest((currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.accessToken) || mapboxApiAccessToken)
+        });
+        if (this.props.RTLTextPlugin !== undefined) {
+          mapProps.RTLTextPlugin = this.props.RTLTextPlugin;
+        }
+        if (useMapboxAdapter) {
+          var mapboxConfig = getApplicationConfig().baseMapLibraryConfig[MAP_LIB_OPTIONS.MAPBOX];
+          mapProps.mapLib = mapboxConfig.getMapLib();
+        }
+        var hasGeocoderLayer = Boolean(layers.find(function (l) {
+          return l.id === GEOCODER_LAYER_ID;
+        }));
+        var isSplit = Boolean(mapState.isSplit);
+        var deck = this._renderDeckOverlay(layersForDeck, {
+          primaryMap: true,
+          isInteractive: true,
+          children: /*#__PURE__*/React.createElement(ResolvedMapComponent, _extends({
+            key: "bottom-".concat(baseMapLibraryName)
+          }, mapProps, {
+            mapStyle: (_mapState$globe2 = mapState.globe) !== null && _mapState$globe2 !== void 0 && _mapState$globe2.enabled ? EMPTY_MAPBOX_STYLE : (_mapStyle$bottomMapSt = mapStyle.bottomMapStyle) !== null && _mapStyle$bottomMapSt !== void 0 ? _mapStyle$bottomMapSt : EMPTY_MAPBOX_STYLE
+          }, bottomMapContainerProps, {
+            ref: this._setMapRef
+          }))
+        });
+        if (!deck) {
+          // deckOverlay can be null if onDeckRender returns null
+          // in this case we don't want to render the map
+          return null;
+        }
+        // In split (dual) view mode, only render the map control buttons on the
+        // right-side map (primary === true, i.e. index === 1). Otherwise the same
+        // buttons are duplicated on both maps and any opened menu appears mirrored.
+        var showMapControl = !isSplit || Boolean(primary);
+        return /*#__PURE__*/React.createElement(React.Fragment, null, showMapControl && /*#__PURE__*/React.createElement(MapControl, {
+          mapState: mapState,
+          mapStateActions: mapStateActions,
+          datasets: datasets,
+          availableLocales: LOCALE_CODES_ARRAY,
+          dragRotate: mapState.dragRotate,
+          isSplit: isSplit,
+          primary: Boolean(primary),
+          isExport: isExport,
+          layers: layers,
+          layerOrder: layerOrder,
+          layersToRender: layersToRender,
+          mapIndex: index || 0,
+          mapControls: mapControls,
+          readOnly: this.props.readOnly,
+          scale: mapState.scale || 1,
+          logoComponent: this.props.logoComponent,
+          top: interactionConfig.geocoder && interactionConfig.geocoder.enabled ? theme.mapControlTop : 0,
+          editor: editor,
+          locale: locale,
+          themeName: uiTheme,
+          onTogglePerspective: mapStateActions.togglePerspective,
+          onSetMapViewMode: mapStateActions.setMapViewMode,
+          mapViewMode: mapState.mapViewMode,
+          onToggleSplitMap: mapStateActions.toggleSplitMap,
+          onMapToggleLayer: this._handleMapToggleLayer,
+          onToggleMapControl: this._toggleMapControl,
+          onToggleSplitMapViewport: mapStateActions.toggleSplitMapViewport,
+          onSetEditorMode: visStateActions.setEditorMode,
+          onSetLocale: uiStateActions.setLocale,
+          onSetTheme: uiStateActions.setTheme,
+          onToggleEditorVisibility: visStateActions.toggleEditorVisibility,
+          onConvertEditorFeaturesToLayer: visStateActions.convertEditorFeaturesToLayer,
+          onLayerVisConfigChange: visStateActions.layerVisConfigChange,
+          onToggleLayerVisibility: this._handleToggleLayerVisibility,
+          mapHeight: mapState.height,
+          setMapControlSettings: uiStateActions.setMapControlSettings,
+          activeSidePanel: activeSidePanel,
+          splitMaps: this.props.visState.splitMaps,
+          onToggleLayerForMap: visStateActions.toggleLayerForMap
+        }), isSplitSelector(this.props) && /*#__PURE__*/React.createElement(Droppable, {
+          containerId: containerId
+        }), deck, this._renderMapboxOverlays(), /*#__PURE__*/React.createElement(Editor, {
+          index: index || 0,
+          datasets: datasets,
+          editor: editor,
+          filters: this.polygonFiltersSelector(this.props),
+          layers: layers,
+          onDeleteFeature: visStateActions.deleteFeature,
+          onSetFeatureProperties: visStateActions.setEditorFeatureProperties,
+          onSelect: visStateActions.setSelectedFeature,
+          onTogglePolygonFilter: visStateActions.setPolygonFilterLayer,
+          onSetEditorMode: visStateActions.setEditorMode,
+          style: {
+            pointerEvents: 'all',
+            position: 'absolute',
+            display: editor.visible ? 'block' : 'none'
+          }
+        }), editor.visible ? /*#__PURE__*/React.createElement(FilterFeatureBadges, {
+          filters: this.polygonFiltersSelector(this.props),
+          viewport: this._getAnnotationViewport(mapState, internalViewState),
+          isGlobeEnabled: Boolean((_mapState$globe3 = mapState.globe) === null || _mapState$globe3 === void 0 ? void 0 : _mapState$globe3.enabled),
+          onSelect: visStateActions.setSelectedFeature
+        }) : null, /*#__PURE__*/React.createElement(AnnotationOverlay, {
+          annotations: visState.annotations,
+          selectedAnnotationId: visState.selectedAnnotationId,
+          isEditingAnnotationText: visState.isEditingAnnotationText,
+          isAnnotationMode: Boolean(mapControls === null || mapControls === void 0 || (_mapControls$annotati = mapControls.annotation) === null || _mapControls$annotati === void 0 ? void 0 : _mapControls$annotati.active),
+          mapIndex: index || 0,
+          viewport: this._getAnnotationViewport(mapState, internalViewState),
+          isGlobeEnabled: Boolean((_mapState$globe4 = mapState.globe) === null || _mapState$globe4 === void 0 ? void 0 : _mapState$globe4.enabled),
+          updateAnnotation: visStateActions.updateAnnotation,
+          setSelectedAnnotation: visStateActions.setSelectedAnnotation
+        }), this.props.children, mapStyle.topMapStyle && !((_mapState$globe5 = mapState.globe) !== null && _mapState$globe5 !== void 0 && _mapState$globe5.enabled) ? /*#__PURE__*/React.createElement(ResolvedMapComponent, _extends({
+          key: "top-".concat(baseMapLibraryName),
+          viewState: internalViewState,
+          maxPitch: effectiveMaxPitch,
+          mapStyle: mapStyle.topMapStyle,
+          style: MAP_STYLE.top,
+          mapboxAccessToken: mapProps.mapboxAccessToken,
+          transformRequest: mapProps.transformRequest
+        }, mapProps.RTLTextPlugin !== undefined ? {
+          RTLTextPlugin: mapProps.RTLTextPlugin
+        } : {}, useMapboxAdapter ? {
+          mapLib: getApplicationConfig().baseMapLibraryConfig[MAP_LIB_OPTIONS.MAPBOX].getMapLib()
+        } : {}, topMapContainerProps)) : null, hasGeocoderLayer ? this._renderDeckOverlay(_defineProperty({}, GEOCODER_LAYER_ID, hasGeocoderLayer), {
+          primaryMap: false,
+          isInteractive: false
+        }) : null, this._renderMapPopover(), !isExport && primary !== isSplit ? /*#__PURE__*/React.createElement(LoadingIndicator, {
+          isVisible: Boolean(isLoadingIndicatorVisible || this.anyActiveLayerLoading),
+          activeSidePanel: Boolean(activeSidePanel),
+          sidePanelWidth: sidePanelWidth,
+          hasAttributionLogos: attributionLogos.length > 0,
+          hasMapScale: getApplicationConfig().enableMapScale
+        }) : null, this.props.primary ? /*#__PURE__*/React.createElement(Attribution, {
+          showBaseMapLibLogo: this.state.showBaseMapLibLogo,
+          basemapAttributions: this.state.basemapAttributions,
+          datasetAttributions: datasetAttributions,
+          baseMapLibraryConfig: baseMapLibraryConfig,
+          globeAttributions: getGlobeBasemapAttributions({
+            globe: mapState.globe,
+            mapboxApiAccessToken: mapboxApiAccessToken,
+            mapStyleType: mapStyle === null || mapStyle === void 0 ? void 0 : mapStyle.styleType,
+            basemapProvider: resolveGlobeBasemapProvider(baseMapLibraryName, mapboxApiAccessToken)
+          })
+        }) : null, this.props.primary ? /*#__PURE__*/React.createElement(AttributionLogos, {
+          logos: attributionLogos,
+          activeSidePanel: Boolean(activeSidePanel),
+          sidePanelWidth: sidePanelWidth
+        }) : null, !isExport && getApplicationConfig().enableMapScale ? /*#__PURE__*/React.createElement(StyledMapScaleContainer, {
+          $left: primary && activeSidePanel ? (sidePanelWidth || 0) + ((_theme$sidePanel$marg = theme === null || theme === void 0 || (_theme$sidePanel = theme.sidePanel) === null || _theme$sidePanel === void 0 || (_theme$sidePanel = _theme$sidePanel.margin) === null || _theme$sidePanel === void 0 ? void 0 : _theme$sidePanel.left) !== null && _theme$sidePanel$marg !== void 0 ? _theme$sidePanel$marg : 9) : (_theme$sidePanel$marg2 = theme === null || theme === void 0 || (_theme$sidePanel2 = theme.sidePanel) === null || _theme$sidePanel2 === void 0 || (_theme$sidePanel2 = _theme$sidePanel2.margin) === null || _theme$sidePanel2 === void 0 ? void 0 : _theme$sidePanel2.left) !== null && _theme$sidePanel$marg2 !== void 0 ? _theme$sidePanel$marg2 : 9,
+          $bottomOffset: primary && attributionLogos.length > 0 ? 24 : 0
+        }, /*#__PURE__*/React.createElement(MapScale, {
+          mapState: mapState,
+          mapIndex: index !== null && index !== void 0 ? index : 0
+        })) : null);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _mapStyle$mapStyles3;
+        var _this$props8 = this.props,
+          visState = _this$props8.visState,
+          mapStyle = _this$props8.mapStyle;
+        var mapContent = this._renderMap();
+        if (!mapContent) {
+          // mapContent can be null if onDeckRender returns null
+          // in this case we don't want to render the map
+          return null;
+        }
+        var currentStyle = (_mapStyle$mapStyles3 = mapStyle.mapStyles) === null || _mapStyle$mapStyles3 === void 0 ? void 0 : _mapStyle$mapStyles3[mapStyle.styleType];
+        var baseMapLibraryName = getBaseMapLibrary(currentStyle);
+        var baseMapLibraryConfig = getApplicationConfig().baseMapLibraryConfig[baseMapLibraryName];
+        return /*#__PURE__*/React.createElement(StyledMap, {
+          ref: this._ref,
+          style: this.styleSelector(this.props),
+          onContextMenu: function onContextMenu(event) {
+            return event.preventDefault();
+          },
+          $mixBlendMode: visState.overlayBlending,
+          $mapLibCssClass: baseMapLibraryConfig.mapLibCssClass
+        }, mapContent);
+      }
+    }]);
+  }(Component);
+  _defineProperty(MapContainer, "contextType", MapViewStateContext);
+  _defineProperty(MapContainer, "defaultProps", {
+    deckGlProps: {},
+    index: 0,
+    primary: true
+  });
+  return withTheme(MapContainer);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createRef","styled","withTheme","Map","MapboxLegacyMap","MaplibreMap","MapView","DeckGL","createSelector","useDroppable","debounce","MapPopoverFactory","MapControlFactory","MapScaleFactory","StyledMapContainer","Attribution","AttributionLogos","renderBasemapAttribution","dedupeBasemapAttributions","EditorFactory","FilterFeatureBadges","AnnotationOverlay","generateMapboxLayers","updateMapboxLayers","EditorLayerUtils","errorNotification","isStyleUsingMapboxTiles","isStyleUsingOpenStreetMapTiles","getBaseMapAttributions","getBaseMapLibrary","transformRequest","observeDimensions","unobserveDimensions","getMapLayersFromSplitMaps","onViewPortChange","getViewportFromMapState","normalizeEvent","rgbToHex","computeDeckEffects","getApplicationConfig","getLayerBlendingParameters","patchDeckRendererForPostProcessing","FILTER_TYPES","GEOCODER_LAYER_ID","THROTTLE_NOTIFICATION_TIME","DEFAULT_PICKING_RADIUS","NO_MAP_ID","EMPTY_MAPBOX_STYLE","MAPBOX_MAX_PITCH","MAP_LIB_OPTIONS","GLOBE_MIN_ZOOM","GLOBE_MAX_ZOOM","getGlobeBaseLayers","getGlobeTopLayers","getGlobeClearColor","getGlobeBasemapAttributions","resolveGlobeBasemapProvider","getStarsBackgroundImage","KeplerGlobeView","DROPPABLE_MAP_CONTAINER_TYPE","MapViewStateContext","ErrorBoundary","LOCALE_CODES","areAnyDeckLayersLoading","computeDeckLayers","getLayerHoverProp","prepareLayersForDeck","prepareLayersToRender","LoadingIndicator","DEBOUNCE_VIEWPORT_PROPAGATE","DEBOUNCE_MOUSE_MOVE_PROPAGATE","DEBOUNCE_LOADING_STATE_PROPAGATE","MAP_STYLE","container","display","position","width","height","top","pointerEvents","LOCALE_CODES_ARRAY","Object","keys","StyledMap","_ref","_ref$$mixBlendMode","$mixBlendMode","$mapLibCssClass","concat","MAPBOXGL_STYLE_UPDATE","MAPBOXGL_RENDER","OSM_ATTRIBUTION_HTML","StyledDroppable","div","_templateObject","_taggedTemplateLiteral","props","$isOver","theme","dndOverBackgroundColor","StyledMapScaleContainer","_templateObject2","sidePanel","margin","left","$bottomOffset","$left","isSplitSelector","visState","splitMaps","length","Droppable","_ref2","containerId","_useDroppable","id","data","type","index","disabled","isOver","setNodeRef","createElement","ref","MapContainerFactory","deps","MapPopover","MapControl","Editor","MapScale","MapContainer","_Component","_this","_classCallCheck","_callSuper","_defineProperty","showBaseMapLibLogo","basemapAttributions","onMapRender","_map","dimensions","_this$props","primary","mapStateActions","updateMap","layers","layerData","splitMapSelector","splitMapIndexSelector","layerOrder","layersSelector","layerDataSelector","mapLayersSelector","filters","filtersSelector","filter","f","polygon","enabled","editor","features","selectedFeature","polygonFiltersSelector","featuresSelector","polygonFilters","map","value","featureCollectionSelector","selectedFeatureSelector","collection","findIndex","_props$generateMapbox","layerOrderSelector","layersToRenderSelector","generateMapboxLayerMethodSelector","layer","layersToRender","generateMapboxLayerMethod","mapStyle","styleType","backgroundColor","_props$mapState","Boolean","mapState","globe","_props$mapState2","config","_props$mapState3","stars","mapStyleTypeSelector","mapStyleBackgroundColorSelector","globeModeSelector","globeBackgroundColorSelector","globeStarsSelector","isGlobeMode","globeBackgroundColor","globeStars","_objectSpread","slice","backgroundImage","backgroundRepeat","visStateActions","onLayerClick","_idx","info","onLayerHover","idx","Array","isArray","colorDomain","domain","aggregatedBins","layerConfigChange","_this$props2","bounds","fitBounds","event","layerFilteredItemsChange","wmsFeatureInfo","featureInfo","coordinate","layerId","_this$props3","_this$props3$index","mapIndex","toggleLayerForMap","update","previousLayers","_updateMapboxLayers","_updateAttribution","onMapStyleLoaded","_this$props$mapStyle","_this$props$mapStyle2","_removeBasemapAttributionListeners","styleObj","style","_this$_map$isStyleLoa","_this$_map","_this$_map$getStyle","_this$_map2","rawStyle","isStyleLoaded","call","getStyle","stylesheet","_unused","usesMapbox","usesOsm","push","currentStyle","mapStyles","isUserCustomStyle","custom","setState","_collectBasemapAttributions","_basemapSourceDataListener","off","_basemapIdleListener","attempts","MAX_ATTEMPTS","tryCollect","onSourceData","e","isSourceLoaded","sourceDataType","onIdle","on","mapRef","getMap","_onMapboxStyleUpdate","_onMapRender","getMapboxRef","error","errorMessage","message","layerMessage","errorMessageFull","lastShown","_deckGLErrorsElapsed","Date","now","extraLayerMessage","_topMostLayer$props","topMostLayer","parent","layerSetIsValid","uiStateActions","addNotification","_this$context","viewState","context","getInternalViewState","onViewStateChange","viewport","_this$props$mapState","interactionState","isExport","setInternalViewState","_wasInteracting","_onViewportChangePropagateDebounced","isUserInteraction","isZooming","isPanning","isRotating","isDragging","inTransition","isInteractionSettle","setTimeout","onMouseMove","setLoadingIndicator","change","isVisible","panelId","_this$props4","toggleMapControl","Number","_inherits","_createClass","key","componentDidMount","current","_handleResize","componentWillUnmount","componentDidUpdate","prevProps","_onDeckInitialized","device","onDeckInitialized","_deck","_isOKToRenderEffects","viewIndex","_this$_deck","viewManager","_viewports","_getAnnotationViewport","internalViewState","_internalViewState$lo","_internalViewState$la","_internalViewState$zo","_ref3","_internalViewState$pi","_ref4","_internalViewState$be","_this$_annotationView","longitude","latitude","zoom","pitch","bearing","_annotationViewportCache","mergedState","vp","project","lngLat","unproject","xy","_renderMapPopover","_this$props$visState$","hoverInfo","_this$props5","_this$props5$visState","clicked","datasets","interactionConfig","animationConfig","_this$props5$visState2","mousePos","mousePosition","pinned","tooltip","layerHoverProp","compareMode","pinnedPosition","x","y","layerPinnedProp","_getHoverXY","primaryData","compareType","commonProp","onClose","_onCloseMapPopover","canvas","undefined","_extends","frozen","isBase","onSetFeatures","setFeatures","setSelectedFeature","featureCollection","screenCoord","_renderDeckOverlay","layersForDeck","_this$context2","_mapState$globe","_mapStyle$mapStyles","_this2","_this$props$mapState$","options","arguments","primaryMap","_this$props6","mapboxApiAccessToken","mapboxApiUrl","deckGlProps","mapControls","deckRenderCallbacks","generateDeckGLLayers","isInteractive","children","mapDraw","_ref5","_ref5$active","active","editorMenuActive","isEditorDrawingMode","isDrawingActive","mode","internalMapState","editorFeatureSelectedIndex","selectedPolygonIndexSelector","generateDeckGLLayersMethod","extraDeckParams","getTooltip","isNaN","getCursor","_ref6","editorCursor","effects","layerBlendingParams","layerBlending","deckLayersMapState","layerParameters","deckGlLayers","editorInfo","onApplyPolygonFilterAll","setPolygonFilterAllLayers","selectedFeatureIndexes","selectedFeatureIndexArraySelector","_onLayerHover","onSetLayerDomain","_onLayerSetDomain","onFilteredItemsChange","_onLayerFilteredItemsChange","onWMSFeatureInfo","_onWMSFeatureInfo","onRedrawNeeded","_onRedrawNeeded","onFitBounds","_onFitBounds","globeBasemapProvider","globeBaseLayers","mapStyleType","basemapProvider","globeTopLayers","finalDeckGlLayers","_toConsumableArray","views","resolution","clear","clearColor","farZMultiplier","allDeckGlProps","pickingRadius","parameters","cull","onDeckRender","_onMouseMoveDebounced","onLoad","onDeckLoad","controller","doubleClickZoom","dragRotate","maxPitch","minZoom","maxZoom","onBeforeRender","_onBeforeRender","_onViewportChange","onHover","res","_onLayerHoverDebounced","onClick","srcEvent","aligningLayer","find","l","alignWaitingForMap","onAlignMapClick","onError","_onDeckError","comp","deck","onDeviceInitialized","onAfterRender","onDeckAfterRender","anyActiveLayerLoading","_onLayerLoadingStateChange","mapboxLayers","mapboxLayersSelector","_renderMapboxOverlays","_renderMap","_mapStyle$mapStyles2","_this$props$MapCompon","_this$context3","_mapState$maxPitch","_this$props$isExport","_mapState$globe2","_mapStyle$bottomMapSt","_mapState$globe3","_mapControls$annotati","_mapState$globe4","_mapState$globe5","_theme$sidePanel$marg","_theme$sidePanel","_theme$sidePanel$marg2","_theme$sidePanel2","_this$props7","locale","uiTheme","bottomMapContainerProps","topMapContainerProps","_this$props7$datasetA","datasetAttributions","_this$props7$attribut","attributionLogos","_this$props7$containe","isLoadingIndicatorVisible","activeSidePanel","sidePanelWidth","layersForDeckSelector","baseMapLibraryName","baseMapLibraryConfig","ResolvedMapComponent","MapComponent","MAPBOX","useMapboxAdapter","configMaxPitch","effectiveMaxPitch","Math","min","mapProps","preserveDrawingBuffer","mapboxAccessToken","accessToken","RTLTextPlugin","mapboxConfig","mapLib","getMapLib","hasGeocoderLayer","isSplit","bottomMapStyle","_setMapRef","showMapControl","Fragment","availableLocales","readOnly","scale","logoComponent","geocoder","mapControlTop","themeName","onTogglePerspective","togglePerspective","onSetMapViewMode","setMapViewMode","mapViewMode","onToggleSplitMap","toggleSplitMap","onMapToggleLayer","_handleMapToggleLayer","onToggleMapControl","_toggleMapControl","onToggleSplitMapViewport","toggleSplitMapViewport","onSetEditorMode","setEditorMode","onSetLocale","setLocale","onSetTheme","setTheme","onToggleEditorVisibility","toggleEditorVisibility","onConvertEditorFeaturesToLayer","convertEditorFeaturesToLayer","onLayerVisConfigChange","layerVisConfigChange","onToggleLayerVisibility","_handleToggleLayerVisibility","mapHeight","setMapControlSettings","onToggleLayerForMap","onDeleteFeature","deleteFeature","onSetFeatureProperties","setEditorFeatureProperties","onSelect","onTogglePolygonFilter","setPolygonFilterLayer","visible","isGlobeEnabled","annotations","selectedAnnotationId","isEditingAnnotationText","isAnnotationMode","annotation","updateAnnotation","setSelectedAnnotation","topMapStyle","hasAttributionLogos","hasMapScale","enableMapScale","state","globeAttributions","logos","render","_mapStyle$mapStyles3","_this$props8","mapContent","styleSelector","onContextMenu","preventDefault","overlayBlending","mapLibCssClass"],"sources":["../../src/map-container.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// libraries\nimport React, {Component, createRef} from 'react';\nimport styled, {withTheme} from 'styled-components';\nimport {Map as MapboxLegacyMap, MapRef} from 'react-map-gl/mapbox-legacy';\nimport {Map as MaplibreMap} from '@vis.gl/react-maplibre';\nimport {PickingInfo, MapView} from '@deck.gl/core';\nimport DeckGL from '@deck.gl/react';\nimport {createSelector, Selector} from 'reselect';\nimport {useDroppable} from '@dnd-kit/core';\nimport debounce from 'lodash/debounce';\n\nimport {VisStateActions, MapStateActions, UIStateActions} from '@kepler.gl/actions';\n\n// components\nimport MapPopoverFactory from './map/map-popover';\nimport MapControlFactory from './map/map-control';\nimport MapScaleFactory from './map/map-scale';\nimport {StyledMapContainer} from './common/styled-components';\nimport {\n  Attribution,\n  AttributionLogos,\n  renderBasemapAttribution,\n  dedupeBasemapAttributions\n} from './map/attribution';\n\nimport EditorFactory from './editor/editor';\nimport FilterFeatureBadges from './editor/filter-feature-badges';\nimport {AnnotationOverlay} from './annotations';\n\n// utils\nimport {\n  generateMapboxLayers,\n  updateMapboxLayers,\n  Layer,\n  LayerBaseConfig,\n  VisualChannelDomain,\n  EditorLayerUtils,\n  AggregatedBin\n} from '@kepler.gl/layers';\nimport {\n  AttributionWithStyle,\n  DatasetAttribution,\n  MapState,\n  MapControls,\n  Viewport,\n  SplitMap,\n  SplitMapLayers\n} from '@kepler.gl/types';\nimport {\n  errorNotification,\n  isStyleUsingMapboxTiles,\n  isStyleUsingOpenStreetMapTiles,\n  getBaseMapAttributions,\n  getBaseMapLibrary,\n  transformRequest,\n  observeDimensions,\n  unobserveDimensions,\n  getMapLayersFromSplitMaps,\n  onViewPortChange,\n  getViewportFromMapState,\n  normalizeEvent,\n  rgbToHex,\n  computeDeckEffects,\n  getApplicationConfig,\n  GetMapRef,\n  getLayerBlendingParameters,\n  patchDeckRendererForPostProcessing\n} from '@kepler.gl/utils';\n\n// default-settings\nimport {\n  FILTER_TYPES,\n  GEOCODER_LAYER_ID,\n  THROTTLE_NOTIFICATION_TIME,\n  DEFAULT_PICKING_RADIUS,\n  NO_MAP_ID,\n  EMPTY_MAPBOX_STYLE,\n  MAPBOX_MAX_PITCH,\n  MAP_LIB_OPTIONS,\n  GLOBE_MIN_ZOOM,\n  GLOBE_MAX_ZOOM\n} from '@kepler.gl/constants';\n\nimport {\n  getGlobeBaseLayers,\n  getGlobeTopLayers,\n  getGlobeClearColor,\n  getGlobeBasemapAttributions,\n  resolveGlobeBasemapProvider,\n  getStarsBackgroundImage,\n  KeplerGlobeView\n} from '@kepler.gl/deckgl-layers';\n\nimport {DROPPABLE_MAP_CONTAINER_TYPE} from './common/dnd-layer-items';\n// Contexts\nimport {MapViewStateContext} from './map-view-state-context';\n\nimport ErrorBoundary from './common/error-boundary';\nimport {LOCALE_CODES} from '@kepler.gl/localization';\nimport {\n  MapStyle,\n  areAnyDeckLayersLoading,\n  computeDeckLayers,\n  getLayerHoverProp,\n  LayerHoverProp,\n  prepareLayersForDeck,\n  prepareLayersToRender,\n  LayersToRender\n} from '@kepler.gl/reducers';\nimport {VisState} from '@kepler.gl/schemas';\n\nimport LoadingIndicator from './loading-indicator';\n\n// Debounce the propagation of viewport change and mouse moves to redux store.\n// This is to avoid too many renders of other components when the map is\n// being panned/zoomed (leading to laggy basemap/deck syncing).\nconst DEBOUNCE_VIEWPORT_PROPAGATE = 10;\nconst DEBOUNCE_MOUSE_MOVE_PROPAGATE = 10;\n\n// How long should we wait between layer loading state changes before triggering a UI update\nconst DEBOUNCE_LOADING_STATE_PROPAGATE = 100;\n\nconst MAP_STYLE: {[key: string]: React.CSSProperties} = {\n  container: {\n    display: 'inline-block',\n    position: 'relative',\n    width: '100%',\n    height: '100%'\n  },\n  top: {\n    position: 'absolute',\n    top: 0,\n    width: '100%',\n    height: '100%',\n    pointerEvents: 'none'\n  }\n};\n\nconst LOCALE_CODES_ARRAY = Object.keys(LOCALE_CODES);\n\ninterface StyledMapContainerProps {\n  $mixBlendMode?: string;\n  $mapLibCssClass: string;\n}\n\nconst StyledMap = styled(StyledMapContainer)<StyledMapContainerProps>(\n  ({$mixBlendMode = 'normal', $mapLibCssClass}) => `\n  #default-deckgl-overlay {\n    mix-blend-mode: ${$mixBlendMode};\n  };\n  *[${$mapLibCssClass}-children] {\n    position: absolute;\n  }\n`\n);\n\nconst MAPBOXGL_STYLE_UPDATE = 'style.load';\nconst MAPBOXGL_RENDER = 'render';\n\n// Canonical OpenStreetMap attribution, injected into the collected list when a\n// style is detected to use OSM tiles but the resolved sources haven't yielded\n// an attribution string of their own (e.g. raw style declares OSM but the\n// TileJSON hasn't exposed it). Rendered through the same safe link parser as\n// every other collected attribution.\nconst OSM_ATTRIBUTION_HTML =\n  '© <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a>';\n\ninterface StyledDroppableProps {\n  $isOver: boolean;\n}\n\nconst StyledDroppable = styled.div<StyledDroppableProps>`\n  background-color: ${props => (props.$isOver ? props.theme.dndOverBackgroundColor : 'none')};\n  width: 100%;\n  height: 100%;\n  position: absolute;\n  pointer-events: none;\n  z-index: 1;\n`;\n\nconst StyledMapScaleContainer = styled.div<{$left: number; $bottomOffset: number}>`\n  position: absolute;\n  bottom: ${props => props.theme.sidePanel.margin.left + props.$bottomOffset}px;\n  left: ${props => props.$left}px;\n  z-index: 1;\n  pointer-events: auto;\n`;\n\nexport const isSplitSelector = props =>\n  props.visState.splitMaps && props.visState.splitMaps.length > 1;\n\nexport const Droppable = ({containerId}) => {\n  const {isOver, setNodeRef} = useDroppable({\n    id: containerId,\n    data: {type: DROPPABLE_MAP_CONTAINER_TYPE, index: containerId},\n    disabled: !containerId\n  });\n\n  return <StyledDroppable ref={setNodeRef} $isOver={isOver} />;\n};\n\n// Attribution UI (parser + components) lives in ./map/attribution and is\n// re-exported here to preserve the public import path (@kepler.gl/components).\nexport {Attribution, AttributionLogos, renderBasemapAttribution, dedupeBasemapAttributions};\n\nMapContainerFactory.deps = [MapPopoverFactory, MapControlFactory, EditorFactory, MapScaleFactory];\n\ntype MapboxStyle = string | object | undefined;\ntype PropSelector<R> = Selector<MapContainerProps, R>;\n\nexport interface MapContainerProps {\n  visState: VisState;\n  mapState: MapState;\n  mapControls: MapControls;\n  mapStyle: {bottomMapStyle?: MapboxStyle; topMapStyle?: MapboxStyle} & MapStyle;\n  mapboxApiAccessToken: string;\n  mapboxApiUrl: string;\n  visStateActions: typeof VisStateActions;\n  mapStateActions: typeof MapStateActions;\n  uiStateActions: typeof UIStateActions;\n\n  // optional\n  primary?: boolean; // primary one will be reporting its size to appState\n  readOnly?: boolean;\n  isExport?: boolean;\n  // onMapStyleLoaded?: (map: maplibregl.Map | ReturnType<MapRef['getMap']> | null) => void;\n  onMapStyleLoaded?: (map: GetMapRef | null) => void;\n  onMapRender?: (map: GetMapRef | null) => void;\n  getMapboxRef?: (mapbox?: MapRef | null, index?: number) => void;\n  index?: number;\n  deleteMapLabels?: (containerId: string, layerId: string) => void;\n  containerId?: number;\n\n  isLoadingIndicatorVisible?: boolean;\n  activeSidePanel: string | null;\n  sidePanelWidth?: number;\n\n  locale?: any;\n  uiTheme?: string;\n  theme?: any;\n  editor?: any;\n  MapComponent?: typeof MapboxLegacyMap | typeof MaplibreMap;\n  deckGlProps?: any;\n  onDeckInitialized?: (a: any, b: any) => void;\n  onViewStateChange?: (viewport: Viewport) => void;\n\n  topMapContainerProps: any;\n  bottomMapContainerProps: any;\n  transformRequest?: (url: string, resourceType?: string) => {url: string};\n\n  /** Pass `false` to disable the remote RTL text plugin, or a URL string to self-host it. */\n  RTLTextPlugin?: string | false;\n\n  datasetAttributions?: DatasetAttribution[];\n  attributionLogos?: AttributionWithStyle[];\n\n  generateMapboxLayers?: typeof generateMapboxLayers;\n  generateDeckGLLayers?: typeof computeDeckLayers;\n\n  onMouseMove?: (event: React.MouseEvent & {lngLat?: [number, number]}) => void;\n\n  children?: React.ReactNode;\n  deckRenderCallbacks?: {\n    onDeckLoad?: () => void;\n    onDeckRender?: (deckProps: Record<string, unknown>) => Record<string, unknown> | null;\n    onDeckAfterRender?: (deckProps: Record<string, unknown>) => any;\n  };\n\n  // Optional: override legend header logo in map controls (used by image export)\n  logoComponent?: React.FC | React.ReactNode;\n}\n\nexport default function MapContainerFactory(\n  MapPopover: ReturnType<typeof MapPopoverFactory>,\n  MapControl: ReturnType<typeof MapControlFactory>,\n  Editor: ReturnType<typeof EditorFactory>,\n  MapScale: ReturnType<typeof MapScaleFactory>\n): React.ComponentType<MapContainerProps> {\n  class MapContainer extends Component<MapContainerProps> {\n    displayName = 'MapContainer';\n\n    private anyActiveLayerLoading = false;\n\n    static contextType = MapViewStateContext;\n\n    declare context: React.ContextType<typeof MapViewStateContext>;\n\n    static defaultProps = {\n      deckGlProps: {},\n      index: 0,\n      primary: true\n    };\n\n    constructor(props) {\n      super(props);\n      patchDeckRendererForPostProcessing();\n    }\n\n    state = {\n      // true for built-in kepler.gl styles (dark-matter, positron, …) and when the\n      // basemap uses Mapbox-hosted tiles (mapbox:// sources).\n      // For user-added custom styles (OpenFreeMap, CARTO self-hosted, …) MapLibre is\n      // merely the rendering engine, not the tile provider, so the logo is hidden and\n      // the basemap's own TileJSON attribution is shown instead.\n      showBaseMapLibLogo: false,\n      // attribution strings collected from the resolved map sources (e.g. CARTO,\n      // OpenFreeMap).  Populated after TileJSON resolves.\n      basemapAttributions: [] as string[]\n    };\n\n    componentDidMount() {\n      if (!this._ref.current) {\n        return;\n      }\n      observeDimensions(this._ref.current, this._handleResize);\n    }\n\n    componentWillUnmount() {\n      if (this._map) {\n        this._map.off(MAPBOXGL_STYLE_UPDATE, this._onMapboxStyleUpdate);\n        this._map.off(MAPBOXGL_RENDER, this._onMapRender);\n        this._removeBasemapAttributionListeners();\n      }\n      if (!this._ref.current) {\n        return;\n      }\n      unobserveDimensions(this._ref.current);\n    }\n\n    componentDidUpdate(prevProps) {\n      if (prevProps.mapStyle.styleType !== this.props.mapStyle.styleType) {\n        this._removeBasemapAttributionListeners();\n        if (this.props.mapStyle.styleType === NO_MAP_ID) {\n          this.setState({\n            showBaseMapLibLogo: false,\n            basemapAttributions: []\n          });\n        } else {\n          this._updateAttribution();\n        }\n      }\n    }\n\n    _deck: any = null;\n    _map: GetMapRef | null = null;\n    _ref = createRef<HTMLDivElement>();\n    _deckGLErrorsElapsed: {[id: string]: number} = {};\n    _basemapSourceDataListener: ((e: any) => void) | null = null;\n    _basemapIdleListener: (() => void) | null = null;\n\n    _onMapRender = () => {\n      if (typeof this.props.onMapRender === 'function') {\n        this.props.onMapRender(this._map);\n      }\n    };\n\n    previousLayers = {\n      // [layers.id]: mapboxLayerConfig\n    };\n\n    _handleResize = dimensions => {\n      const {primary, index} = this.props;\n      if (primary) {\n        const {mapStateActions} = this.props;\n        if (dimensions && dimensions.width > 0 && dimensions.height > 0) {\n          mapStateActions.updateMap(dimensions, index);\n        }\n      }\n    };\n\n    layersSelector: PropSelector<VisState['layers']> = props => props.visState.layers;\n    layerDataSelector: PropSelector<VisState['layers']> = props => props.visState.layerData;\n    splitMapSelector: PropSelector<SplitMap[]> = props => props.visState.splitMaps;\n    splitMapIndexSelector: PropSelector<number | undefined> = props => props.index;\n    mapLayersSelector: PropSelector<SplitMapLayers | null | undefined> = createSelector(\n      this.splitMapSelector,\n      this.splitMapIndexSelector,\n      getMapLayersFromSplitMaps\n    );\n    layerOrderSelector: PropSelector<VisState['layerOrder']> = props => props.visState.layerOrder;\n    layersToRenderSelector: PropSelector<LayersToRender> = createSelector(\n      this.layersSelector,\n      this.layerDataSelector,\n      this.mapLayersSelector,\n      prepareLayersToRender\n    );\n    layersForDeckSelector = createSelector(\n      this.layersSelector,\n      this.layerDataSelector,\n      prepareLayersForDeck\n    );\n    filtersSelector = props => props.visState.filters;\n    polygonFiltersSelector = createSelector(this.filtersSelector, filters =>\n      filters.filter(f => f.type === FILTER_TYPES.polygon && f.enabled !== false)\n    );\n    featuresSelector = props => props.visState.editor.features;\n    selectedFeatureSelector = props => props.visState.editor.selectedFeature;\n    featureCollectionSelector = createSelector(\n      this.polygonFiltersSelector,\n      this.featuresSelector,\n      (polygonFilters, features) => ({\n        type: 'FeatureCollection',\n        features: features.concat(polygonFilters.map(f => f.value))\n      })\n    );\n    // @ts-ignore - No overload matches this call\n    selectedPolygonIndexSelector = createSelector(\n      this.featureCollectionSelector,\n      this.selectedFeatureSelector,\n      (collection, selectedFeature) =>\n        collection.features.findIndex(f => f.id === selectedFeature?.id)\n    );\n    selectedFeatureIndexArraySelector = createSelector(\n      (value: number) => value,\n      value => {\n        return value < 0 ? [] : [value];\n      }\n    );\n\n    generateMapboxLayerMethodSelector = props => props.generateMapboxLayers ?? generateMapboxLayers;\n\n    mapboxLayersSelector = createSelector(\n      this.layersSelector,\n      this.layerDataSelector,\n      this.layerOrderSelector,\n      this.layersToRenderSelector,\n      this.generateMapboxLayerMethodSelector,\n      (layer, layerData, layerOrder, layersToRender, generateMapboxLayerMethod) =>\n        generateMapboxLayerMethod(layer, layerData, layerOrder, layersToRender)\n    );\n\n    // merge in a background-color style if the basemap choice is NO_MAP_ID\n    // used by <StyledMap> inline style prop\n    mapStyleTypeSelector = props => props.mapStyle.styleType;\n    mapStyleBackgroundColorSelector = props => props.mapStyle.backgroundColor;\n    globeModeSelector = props => Boolean(props.mapState?.globe?.enabled);\n    globeBackgroundColorSelector = props => props.mapState?.globe?.config?.backgroundColor;\n    globeStarsSelector = props => Boolean(props.mapState?.globe?.config?.stars);\n    styleSelector = createSelector(\n      this.mapStyleTypeSelector,\n      this.mapStyleBackgroundColorSelector,\n      this.globeModeSelector,\n      this.globeBackgroundColorSelector,\n      this.globeStarsSelector,\n      (styleType, backgroundColor, isGlobeMode, globeBackgroundColor, globeStars) => ({\n        ...MAP_STYLE.container,\n        ...(styleType === NO_MAP_ID ? {backgroundColor: rgbToHex(backgroundColor)} : {}),\n        // In globe mode the deck.gl canvas is transparent (the globe View uses\n        // `clearColor: false` to avoid corrupting the picking buffer), so the\n        // background around the globe is painted here on the container instead.\n        ...(isGlobeMode\n          ? {\n              // Fall back to the default globe background when none is configured.\n              backgroundColor: rgbToHex(\n                (globeBackgroundColor as [number, number, number]) ||\n                  (getGlobeClearColor().slice(0, 3) as [number, number, number])\n              ),\n              // Optionally overlay a tileable star-field pattern on the background.\n              ...(globeStars\n                ? {\n                    backgroundImage: `url('${getStarsBackgroundImage()}')`,\n                    backgroundRepeat: 'repeat'\n                  }\n                : {})\n            }\n          : {})\n      })\n    );\n\n    /* component private functions */\n    _onCloseMapPopover = () => {\n      this.props.visStateActions.onLayerClick(null);\n    };\n\n    _onLayerHover = (_idx: number, info: PickingInfo<any> | null) => {\n      this.props.visStateActions.onLayerHover(info, this.props.index);\n    };\n\n    _onLayerSetDomain = (\n      idx: number,\n      value: number[] | {domain: VisualChannelDomain; aggregatedBins: Record<number, AggregatedBin>}\n    ) => {\n      // deck.gl 9 native aggregation layers (Grid, Hexagon) pass\n      // {domain, aggregatedBins} via our ScaleEnhanced* overrides,\n      // while ClusterLayer's CPUAggregator also passes {domain, aggregatedBins}.\n      // Plain [min, max] is a fallback if the override is bypassed.\n      const config = Array.isArray(value)\n        ? {colorDomain: value as VisualChannelDomain}\n        : {colorDomain: value.domain, aggregatedBins: value.aggregatedBins};\n\n      const layer = this.props.visState.layers[idx];\n      if (!layer) return;\n\n      this.props.visStateActions.layerConfigChange(layer, config as Partial<LayerBaseConfig>);\n    };\n\n    _onRedrawNeeded = (_idx: number) => {\n      // updateMapUpdater always returns a new state object reference, which triggers re-render\n      const {mapStateActions, index} = this.props;\n      mapStateActions.updateMap({}, index);\n    };\n\n    _onFitBounds = (_idx: number, bounds: [number, number, number, number]) => {\n      this.props.mapStateActions.fitBounds(bounds);\n    };\n\n    _onLayerFilteredItemsChange = (idx, event) => {\n      this.props.visStateActions.layerFilteredItemsChange(this.props.visState.layers[idx], event);\n    };\n\n    _onWMSFeatureInfo = (\n      idx: number,\n      data: {\n        featureInfo: Array<{name: string; value: string}> | string | null;\n        coordinate?: [number, number] | null;\n      }\n    ) => {\n      this.props.visStateActions.wmsFeatureInfo(\n        this.props.visState.layers[idx],\n        data.featureInfo,\n        data.coordinate\n      );\n    };\n\n    _handleMapToggleLayer = layerId => {\n      const {index: mapIndex = 0, visStateActions} = this.props;\n      visStateActions.toggleLayerForMap(mapIndex, layerId);\n    };\n\n    _onMapboxStyleUpdate = update => {\n      // force refresh mapboxgl layers\n      this.previousLayers = {};\n      this._updateMapboxLayers();\n\n      this._updateAttribution(update);\n\n      if (typeof this.props.onMapStyleLoaded === 'function') {\n        this.props.onMapStyleLoaded(this._map);\n      }\n    };\n\n    _updateAttribution = (update?: any) => {\n      this._removeBasemapAttributionListeners();\n\n      let styleObj = update?.style || null;\n      if (!styleObj && this._map) {\n        try {\n          const rawStyle = this._map.isStyleLoaded?.() ? this._map.getStyle?.() : null;\n          if (rawStyle) {\n            styleObj = {stylesheet: rawStyle};\n          }\n        } catch {\n          // map style not ready yet\n        }\n      }\n      const usesMapbox = styleObj ? isStyleUsingMapboxTiles(styleObj) : false;\n      const usesOsm = styleObj ? isStyleUsingOpenStreetMapTiles(styleObj) : false;\n      const basemapAttributions = getBaseMapAttributions(this._map);\n\n      // if OSM tiles are detected in the raw style but no source-level attribution\n      // string was collected yet, fold in the canonical OSM attribution so the\n      // render path stays uniform (no separate hardcoded fallback link)\n      if (usesOsm && !basemapAttributions.length) {\n        basemapAttributions.push(OSM_ATTRIBUTION_HTML);\n      }\n\n      // Determine whether to show the \"Basemap by: MapLibre/Mapbox\" logo:\n      //  - Always show for built-in kepler.gl styles (dark-matter, positron, …):\n      //    they don't carry their own \"provider\" branding so the rendering-engine\n      //    logo acts as the basemap credit.\n      //  - Always show when Mapbox tiles are in use (mapbox:// sources): Mapbox\n      //    attribution is required.\n      //  - Hide for custom user-added styles (custom === 'LOCAL' | 'MANAGED'):\n      //    those styles supply their own TileJSON attribution (e.g. OpenFreeMap),\n      //    so showing \"Basemap by: MapLibre\" would be misleading.\n      const styleType = this.props.mapStyle?.styleType;\n      const currentStyle = this.props.mapStyle?.mapStyles?.[styleType];\n      const isUserCustomStyle = Boolean(currentStyle?.custom);\n      const showBaseMapLibLogo = usesMapbox || !isUserCustomStyle;\n\n      this.setState({\n        showBaseMapLibLogo,\n        basemapAttributions\n      });\n\n      // For non-Mapbox styles, TileJSON attribution resolves asynchronously\n      // after style.load.  Start a listener so we can update basemapAttributions\n      // as soon as the sources resolve their TileJSON.\n      if (!usesMapbox) {\n        this._collectBasemapAttributions();\n      }\n    };\n\n    _removeBasemapAttributionListeners = () => {\n      if (this._basemapSourceDataListener && this._map) {\n        this._map.off('sourcedata', this._basemapSourceDataListener);\n        this._basemapSourceDataListener = null;\n      }\n      if (this._basemapIdleListener && this._map) {\n        this._map.off('idle', this._basemapIdleListener);\n        this._basemapIdleListener = null;\n      }\n    };\n\n    _collectBasemapAttributions = () => {\n      if (!this._map) return;\n      this._removeBasemapAttributionListeners();\n      let attempts = 0;\n      // Cap retries so a style that never yields attributions doesn't leave a\n      // permanent sourcedata listener attached.\n      const MAX_ATTEMPTS = 50;\n\n      const tryCollect = () => {\n        // TileJSON resolves asynchronously; re-collect attributions once a\n        // source's metadata is available so custom basemap attributions are not lost.\n        const basemapAttributions = getBaseMapAttributions(this._map);\n        if (basemapAttributions.length) {\n          this._removeBasemapAttributionListeners();\n          // Don't change showBaseMapLibLogo here — it is fixed at style.load time\n          // based on whether the style uses Mapbox tiles.  We only update the\n          // provider attributions collected from the resolved TileJSON.\n          this.setState({basemapAttributions});\n          return true;\n        }\n        return false;\n      };\n\n      const onSourceData = (e: any) => {\n        // Collect attributions when:\n        //   (a) a source's TileJSON has just been fetched (sourceDataType === 'metadata') —\n        //       this is the earliest moment the `attribution` property is available on the\n        //       resolved source object, or\n        //   (b) a source is fully loaded (isSourceLoaded === true) — fallback for raster\n        //       sources or styles that set attribution inline rather than via TileJSON.\n        if (!e?.isSourceLoaded && e?.sourceDataType !== 'metadata') return;\n        attempts++;\n        tryCollect();\n        if (attempts >= MAX_ATTEMPTS) {\n          this._removeBasemapAttributionListeners();\n        }\n      };\n\n      // The `idle` event fires when the map has finished loading all pending\n      // resources (tiles, TileJSON, sprites). At that point attributions from\n      // all sources are guaranteed to be resolved, so this is a reliable\n      // one-shot fallback that catches cases where the sourcedata metadata\n      // events are missed or the source never reaches isSourceLoaded.\n      const onIdle = () => {\n        this._removeBasemapAttributionListeners();\n        const basemapAttributions = getBaseMapAttributions(this._map);\n        if (basemapAttributions.length) {\n          this.setState({basemapAttributions});\n        }\n      };\n\n      this._basemapSourceDataListener = onSourceData;\n      this._basemapIdleListener = onIdle;\n      this._map.on('sourcedata', onSourceData);\n      this._map.on('idle', onIdle);\n    };\n\n    _setMapRef = mapRef => {\n      // Handle change of the map library\n      if (this._map && mapRef) {\n        const map = mapRef.getMap();\n        if (map && this._map !== map) {\n          this._map.off(MAPBOXGL_STYLE_UPDATE, this._onMapboxStyleUpdate);\n          this._map.off(MAPBOXGL_RENDER, this._onMapRender);\n          this._removeBasemapAttributionListeners();\n          this._map = null;\n        }\n      }\n\n      if (!this._map && mapRef) {\n        this._map = mapRef.getMap();\n        // i noticed in certain context we don't access the actual map element\n        if (!this._map) {\n          return;\n        }\n        // bind mapboxgl event listener\n        this._map.on(MAPBOXGL_STYLE_UPDATE, this._onMapboxStyleUpdate);\n        this._map.on(MAPBOXGL_RENDER, this._onMapRender);\n      }\n\n      if (this.props.getMapboxRef) {\n        // The parent component can gain access to our MapboxGlMap by\n        // providing this callback. Note that 'mapbox' will be null when the\n        // ref is unset (e.g. when a split map is closed).\n        this.props.getMapboxRef(mapRef, this.props.index);\n      }\n    };\n\n    _onDeckInitialized(device) {\n      if (this.props.onDeckInitialized) {\n        this.props.onDeckInitialized(this._deck, device);\n      }\n    }\n\n    /**\n     * 1) Allow effects only for the first view.\n     * 2) Prevent effect:preRender call without valid generated viewports.\n     * @param viewIndex View index.\n     * @returns Returns true if effects can be used.\n     */\n    _isOKToRenderEffects(viewIndex?: number): boolean {\n      return !viewIndex && Boolean(this._deck?.viewManager?._viewports?.length);\n    }\n\n    _onBeforeRender = () => {\n      // no-op\n    };\n\n    _annotationViewportCache: {key: string; viewport: any} | null = null;\n\n    _wasInteracting = false;\n\n    _getAnnotationViewport(mapState: any, internalViewState: any) {\n      const longitude = internalViewState?.longitude ?? mapState.longitude;\n      const latitude = internalViewState?.latitude ?? mapState.latitude;\n      const zoom = internalViewState?.zoom ?? mapState.zoom;\n      const pitch = internalViewState?.pitch ?? mapState.pitch ?? 0;\n      const bearing = internalViewState?.bearing ?? mapState.bearing ?? 0;\n      const width = mapState.width || 0;\n      const height = mapState.height || 0;\n      const key = `${longitude},${latitude},${zoom},${pitch},${bearing},${width},${height}`;\n\n      if (this._annotationViewportCache?.key === key) {\n        return this._annotationViewportCache.viewport;\n      }\n\n      const mergedState = {...mapState, ...internalViewState, width, height};\n      const vp = getViewportFromMapState(mergedState) as any;\n      const viewport = {\n        project: (lngLat: [number, number]) => vp.project(lngLat) as [number, number],\n        unproject: (xy: [number, number]) => vp.unproject(xy) as [number, number],\n        longitude,\n        latitude,\n        width,\n        height,\n        zoom\n      };\n      this._annotationViewportCache = {key, viewport};\n      return viewport;\n    }\n\n    _onDeckError = (error, layer) => {\n      const errorMessage = error?.message || 'unknown-error';\n      const layerMessage = layer?.id ? ` in ${layer.id} layer` : '';\n      const errorMessageFull =\n        errorMessage === 'WebGL context is lost'\n          ? 'Your GPU was disconnected. This can happen if your computer goes to sleep. It can also occur for other reasons, such as if you are running too many GPU applications.'\n          : `An error in deck.gl: ${errorMessage}${layerMessage}.`;\n\n      // Throttle error notifications, as React doesn't like too many state changes from here.\n      const lastShown = this._deckGLErrorsElapsed[errorMessageFull];\n      if (!lastShown || lastShown < Date.now() - THROTTLE_NOTIFICATION_TIME) {\n        this._deckGLErrorsElapsed[errorMessageFull] = Date.now();\n\n        // Mark layer as invalid\n        let extraLayerMessage = '';\n        const {visStateActions} = this.props;\n        if (layer) {\n          let topMostLayer = layer;\n          while (topMostLayer.parent) {\n            topMostLayer = topMostLayer.parent;\n          }\n          if (topMostLayer.props?.id) {\n            visStateActions.layerSetIsValid(topMostLayer, false);\n            extraLayerMessage = 'The layer has been disabled and highlighted.';\n          }\n        }\n\n        // Create new error notification or update existing one with same id.\n        // Update is required to preserve the order of notifications as they probably are going to \"jump\" based on order of errors.\n        const {uiStateActions} = this.props;\n        uiStateActions.addNotification(\n          errorNotification({\n            message: `${errorMessageFull} ${extraLayerMessage}`,\n            id: errorMessageFull // treat the error message as id\n          })\n        );\n      }\n    };\n\n    /* component render functions */\n\n    /* eslint-disable complexity */\n    _renderMapPopover() {\n      // this check is for limiting the display of the `<MapPopover>` to the `<MapContainer>` the user is interacting with\n      // the DeckGL onHover event handler adds a `mapIndex` property which is available in the `hoverInfo` object of `visState`\n      if (this.props.index !== this.props.visState.hoverInfo?.mapIndex) {\n        return null;\n      }\n\n      // TODO: move this into reducer so it can be tested\n      const {\n        mapState,\n        visState: {\n          hoverInfo,\n          clicked,\n          datasets,\n          interactionConfig,\n          animationConfig,\n          layers,\n          mousePos: {mousePosition, coordinate, pinned}\n        }\n      } = this.props;\n      const layersToRender = this.layersToRenderSelector(this.props);\n\n      if (!mousePosition || !interactionConfig.tooltip) {\n        return null;\n      }\n\n      const layerHoverProp = getLayerHoverProp({\n        animationConfig,\n        interactionConfig,\n        hoverInfo,\n        layers,\n        layersToRender,\n        datasets\n      });\n\n      const compareMode = interactionConfig.tooltip.config\n        ? interactionConfig.tooltip.config.compareMode\n        : false;\n\n      let pinnedPosition = {x: 0, y: 0};\n      let layerPinnedProp: LayerHoverProp | null = null;\n      if (pinned || clicked) {\n        // project lnglat to screen so that tooltip follows the object on zoom\n        const viewport = getViewportFromMapState(mapState);\n        const lngLat = clicked ? clicked.coordinate : pinned.coordinate;\n        pinnedPosition = this._getHoverXY(viewport, lngLat);\n        layerPinnedProp = getLayerHoverProp({\n          animationConfig,\n          interactionConfig,\n          hoverInfo: clicked,\n          layers,\n          layersToRender,\n          datasets\n        });\n        if (layerHoverProp && layerPinnedProp) {\n          layerHoverProp.primaryData = layerPinnedProp.data;\n          layerHoverProp.compareType = interactionConfig.tooltip.config.compareType;\n        }\n      }\n\n      const commonProp = {\n        onClose: this._onCloseMapPopover,\n        zoom: mapState.zoom,\n        container: this._deck ? this._deck.canvas : undefined\n      };\n\n      return (\n        <ErrorBoundary>\n          {layerPinnedProp && (\n            <MapPopover\n              {...pinnedPosition}\n              {...commonProp}\n              layerHoverProp={layerPinnedProp}\n              coordinate={interactionConfig.coordinate.enabled && (pinned || {}).coordinate}\n              frozen={true}\n              isBase={compareMode}\n              onSetFeatures={this.props.visStateActions.setFeatures}\n              setSelectedFeature={this.props.visStateActions.setSelectedFeature}\n              // @ts-ignore Argument of type 'Readonly<MapContainerProps>' is not assignable to parameter of type 'never'\n              featureCollection={this.featureCollectionSelector(this.props)}\n            />\n          )}\n          {layerHoverProp && (!layerPinnedProp || compareMode) && (\n            <MapPopover\n              x={mousePosition[0]}\n              y={mousePosition[1]}\n              {...commonProp}\n              layerHoverProp={layerHoverProp}\n              frozen={false}\n              coordinate={interactionConfig.coordinate.enabled && coordinate}\n              onSetFeatures={this.props.visStateActions.setFeatures}\n              setSelectedFeature={this.props.visStateActions.setSelectedFeature}\n              // @ts-ignore Argument of type 'Readonly<MapContainerProps>' is not assignable to parameter of type 'never'\n              featureCollection={this.featureCollectionSelector(this.props)}\n            />\n          )}\n        </ErrorBoundary>\n      );\n    }\n\n    /* eslint-enable complexity */\n\n    _getHoverXY(viewport, lngLat) {\n      const screenCoord = !viewport || !lngLat ? null : viewport.project(lngLat);\n      return screenCoord && {x: screenCoord[0], y: screenCoord[1]};\n    }\n\n    _renderDeckOverlay(\n      layersForDeck,\n      options: {primaryMap: boolean; isInteractive?: boolean; children?: React.ReactNode} = {\n        primaryMap: false\n      }\n    ) {\n      const {\n        mapStyle,\n        visState,\n        mapState,\n        visStateActions,\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        deckGlProps,\n        index,\n        mapControls,\n        deckRenderCallbacks,\n        theme,\n        generateDeckGLLayers,\n        onMouseMove\n      } = this.props;\n\n      const {hoverInfo, editor} = visState;\n      const {primaryMap, isInteractive, children} = options;\n\n      // disable double click zoom when editor is in any draw mode\n      const {mapDraw} = mapControls;\n      const {active: editorMenuActive = false} = mapDraw || {};\n      const isEditorDrawingMode = EditorLayerUtils.isDrawingActive(editorMenuActive, editor.mode);\n\n      const internalViewState = this.context?.getInternalViewState(index);\n      const internalMapState = {...mapState, ...internalViewState};\n      const viewport = getViewportFromMapState(internalMapState);\n\n      const editorFeatureSelectedIndex = this.selectedPolygonIndexSelector(this.props);\n\n      const {setFeatures, onLayerClick, setSelectedFeature} = visStateActions;\n\n      const generateDeckGLLayersMethod = generateDeckGLLayers ?? computeDeckLayers;\n\n      const extraDeckParams: {\n        getTooltip?: (info: any) => object | null;\n        getCursor?: ({isDragging}: {isDragging: boolean}) => string;\n      } = {};\n      if (primaryMap) {\n        // Omit hover updates when the pointer position is invalid, ie. over UI overlays or\n        // outside the map container. In those cases x/y may be < 0\n        extraDeckParams.getTooltip = info => {\n          const x = Number(info?.x);\n          const y = Number(info?.y);\n          if (Number.isNaN(x) || Number.isNaN(y) || x < 0 || y < 0) return null;\n\n          return EditorLayerUtils.getTooltip(info, {\n            editorMenuActive,\n            editor,\n            theme\n          });\n        };\n\n        extraDeckParams.getCursor = ({isDragging}: {isDragging: boolean}) => {\n          const editorCursor = EditorLayerUtils.getCursor({\n            editorMenuActive,\n            editor,\n            hoverInfo\n          });\n          if (editorCursor) return editorCursor;\n\n          if (isDragging) return 'grabbing';\n          if (hoverInfo?.layer) return 'pointer';\n          return 'grab';\n        };\n      }\n\n      const effects = this._isOKToRenderEffects(index)\n        ? computeDeckEffects({visState, mapState, isExport: this.props.isExport})\n        : [];\n\n      const isGlobeMode = mapState.globe?.enabled;\n\n      // In globe mode with a non-default blend mode, forward pre-computed layer\n      // rendering parameters into mapState so individual layers can merge them into\n      // their own parameters objects. The global DeckGL parameters cannot be used in\n      // globe mode because they are merged into globe system layers (atmosphere,\n      // surface, etc.) and alter their carefully tuned blend/depth state.\n      // 'normal' is omitted — it is the WebGL default and injecting it would\n      // override intentional blend:false settings on layers like trip/scenegraph.\n      const layerBlendingParams =\n        isGlobeMode && visState.layerBlending && visState.layerBlending !== 'normal'\n          ? getLayerBlendingParameters(visState.layerBlending)\n          : undefined;\n      const deckLayersMapState = layerBlendingParams\n        ? {...internalMapState, layerParameters: layerBlendingParams}\n        : internalMapState;\n\n      const deckGlLayers = generateDeckGLLayersMethod(\n        {\n          visState,\n          mapState: deckLayersMapState,\n          mapStyle\n        },\n        {\n          mapIndex: index,\n          primaryMap,\n          mapboxApiAccessToken,\n          mapboxApiUrl,\n          layersForDeck,\n          editorInfo: primaryMap\n            ? {\n                editor,\n                editorMenuActive,\n                onSetFeatures: setFeatures,\n                setSelectedFeature,\n                onApplyPolygonFilterAll: visStateActions.setPolygonFilterAllLayers,\n                // @ts-ignore Argument of type 'Readonly<MapContainerProps>' is not assignable to parameter of type 'never'\n                featureCollection: this.featureCollectionSelector(this.props),\n                selectedFeatureIndexes: this.selectedFeatureIndexArraySelector(\n                  // @ts-ignore Argument of type 'unknown' is not assignable to parameter of type 'number'.\n                  editorFeatureSelectedIndex\n                ),\n                viewport\n              }\n            : undefined\n        },\n        {\n          onLayerHover: this._onLayerHover,\n          onSetLayerDomain: this._onLayerSetDomain,\n          onFilteredItemsChange: this._onLayerFilteredItemsChange,\n          onWMSFeatureInfo: this._onWMSFeatureInfo,\n          onRedrawNeeded: this._onRedrawNeeded,\n          onFitBounds: this._onFitBounds\n        },\n        deckGlProps\n      );\n\n      // Follow the selected basemap style's library so the globe uses the same\n      // provider as the flat 2D map (CARTO tiles for MapLibre styles, Mapbox\n      // tiles for Mapbox styles).\n      const globeBasemapProvider = resolveGlobeBasemapProvider(\n        getBaseMapLibrary(mapStyle?.mapStyles?.[mapStyle?.styleType]),\n        mapboxApiAccessToken || ''\n      );\n\n      // In globe mode, prepend globe base layers and append top layers\n      const globeBaseLayers =\n        isGlobeMode && mapState.globe\n          ? getGlobeBaseLayers({\n              mapboxApiAccessToken: mapboxApiAccessToken || '',\n              globe: mapState.globe,\n              mapStyleType: mapStyle?.styleType,\n              basemapProvider: globeBasemapProvider,\n              // Use the live (internal) latitude so the tile LOD compensation\n              // stays in sync with the deck viewport during a drag; mapState\n              // latitude lags behind while rotating.\n              latitude: internalMapState.latitude,\n              zoom: internalMapState.zoom\n            })\n          : [];\n      const globeTopLayers =\n        isGlobeMode && mapState.globe\n          ? getGlobeTopLayers({globe: mapState.globe, zoom: internalMapState.zoom})\n          : [];\n      const finalDeckGlLayers = isGlobeMode\n        ? [...globeBaseLayers, ...deckGlLayers, ...globeTopLayers]\n        : deckGlLayers;\n\n      const views = deckGlProps?.views\n        ? deckGlProps?.views()\n        : isGlobeMode\n        ? new KeplerGlobeView({\n            resolution: 5,\n            // The visible background around the globe is painted by the map\n            // container's CSS background (see styleSelector), NOT by a per-view\n            // color clear. deck.gl applies a View's `clearColor` in *every* pass,\n            // including the picking pass, and it forces the cleared alpha to 255\n            // (`clearColor[3] || 255`). In the picking buffer the alpha byte encodes\n            // the layer index, so a 255 clear makes deck.gl decode every pixel as a\n            // non-existent layer (\"Picked non-existent layer. Is picking buffer\n            // corrupt?\") on hover. `clearColor: false` skips the per-view color\n            // clear so the picking buffer keeps its 0 alpha; the canvas stays\n            // transparent and the CSS background shows through.\n            clear: true,\n            clearColor: false\n          })\n        : new MapView({farZMultiplier: 1.2});\n\n      let allDeckGlProps = {\n        ...deckGlProps,\n        pickingRadius: DEFAULT_PICKING_RADIUS,\n        views,\n        layers: finalDeckGlLayers,\n        effects,\n        parameters: isGlobeMode ? {cull: true} : getLayerBlendingParameters(visState.layerBlending)\n      };\n\n      if (typeof deckRenderCallbacks?.onDeckRender === 'function') {\n        allDeckGlProps = deckRenderCallbacks.onDeckRender(allDeckGlProps);\n        if (!allDeckGlProps) {\n          // if onDeckRender returns null, do not render deck.gl\n          return null;\n        }\n      }\n\n      return (\n        <div\n          {...(isInteractive\n            ? {\n                onMouseMove: primaryMap\n                  ? event => {\n                      onMouseMove?.(event);\n                      this._onMouseMoveDebounced(event, viewport);\n                    }\n                  : undefined\n              }\n            : {style: {pointerEvents: 'none'}})}\n        >\n          <DeckGL\n            id=\"default-deckgl-overlay\"\n            onLoad={() => {\n              if (typeof deckRenderCallbacks?.onDeckLoad === 'function') {\n                deckRenderCallbacks.onDeckLoad();\n              }\n            }}\n            {...allDeckGlProps}\n            controller={\n              isInteractive\n                ? {\n                    doubleClickZoom: !isEditorDrawingMode,\n                    dragRotate: this.props.mapState.dragRotate,\n                    maxPitch: this.props.mapState.maxPitch ?? getApplicationConfig().maxPitch,\n                    // In globe mode allow zooming out further than deck.gl's default\n                    // of 0 so the whole globe can be pulled back on screen. Set on the\n                    // controller so it stays authoritative regardless of the viewState\n                    // round-trip through Redux/local context. Cap the max zoom too so\n                    // the basemap tiles don't break down at high globe zoom.\n                    ...(isGlobeMode ? {minZoom: GLOBE_MIN_ZOOM, maxZoom: GLOBE_MAX_ZOOM} : {})\n                  }\n                : false\n            }\n            viewState={\n              isGlobeMode\n                ? {...internalViewState, minZoom: GLOBE_MIN_ZOOM, maxZoom: GLOBE_MAX_ZOOM}\n                : internalViewState\n            }\n            onBeforeRender={this._onBeforeRender}\n            onViewStateChange={isInteractive ? this._onViewportChange : undefined}\n            {...extraDeckParams}\n            onHover={\n              isInteractive\n                ? data => {\n                    const res = EditorLayerUtils.onHover(data, {\n                      editorMenuActive,\n                      editor,\n                      hoverInfo\n                    });\n                    if (res) return;\n\n                    this._onLayerHoverDebounced(data, index);\n                  }\n                : null\n            }\n            onClick={(data, event) => {\n              // @ts-ignore\n              normalizeEvent(event.srcEvent, viewport);\n\n              // Handle bitmap layer alignment mode: if a bitmap layer is waiting\n              // for a map click, route the click coordinate to it\n              if (data.coordinate) {\n                const aligningLayer = visState.layers.find(\n                  (l: any) => l.type === 'bitmap' && l.alignWaitingForMap && l.config.isVisible\n                );\n                if (aligningLayer) {\n                  (aligningLayer as any).onAlignMapClick(data.coordinate as [number, number]);\n                  this._onRedrawNeeded(0);\n                  return;\n                }\n              }\n\n              const res = EditorLayerUtils.onClick(data, event, {\n                editorMenuActive,\n                editor,\n                onLayerClick,\n                setSelectedFeature,\n                mapIndex: index\n              });\n              if (res) return;\n\n              visStateActions.onLayerClick(data);\n            }}\n            onError={this._onDeckError}\n            ref={comp => {\n              // @ts-ignore\n              if (comp && comp.deck && !this._deck) {\n                // @ts-ignore\n                this._deck = comp.deck;\n              }\n            }}\n            onDeviceInitialized={device => this._onDeckInitialized(device)}\n            onAfterRender={() => {\n              if (typeof deckRenderCallbacks?.onDeckAfterRender === 'function') {\n                deckRenderCallbacks.onDeckAfterRender(allDeckGlProps);\n              }\n\n              const anyActiveLayerLoading = areAnyDeckLayersLoading(allDeckGlProps.layers);\n              if (anyActiveLayerLoading !== this.anyActiveLayerLoading) {\n                this._onLayerLoadingStateChange();\n                this.anyActiveLayerLoading = anyActiveLayerLoading;\n              }\n            }}\n          >\n            {children}\n          </DeckGL>\n        </div>\n      );\n    }\n\n    _updateMapboxLayers() {\n      const mapboxLayers = this.mapboxLayersSelector(this.props);\n      if (!Object.keys(mapboxLayers).length && !Object.keys(this.previousLayers).length) {\n        return;\n      }\n\n      updateMapboxLayers(this._map, mapboxLayers, this.previousLayers);\n\n      this.previousLayers = mapboxLayers;\n    }\n\n    _renderMapboxOverlays() {\n      if (this._map && this._map.isStyleLoaded()) {\n        this._updateMapboxLayers();\n      }\n    }\n    _onViewportChangePropagateDebounced = debounce(() => {\n      const viewState = this.context?.getInternalViewState(this.props.index);\n      onViewPortChange(\n        viewState,\n        this.props.mapStateActions.updateMap,\n        this.props.onViewStateChange,\n        this.props.primary,\n        this.props.index\n      );\n    }, DEBOUNCE_VIEWPORT_PROPAGATE);\n\n    _onViewportChange = viewport => {\n      const {viewState, interactionState} = viewport;\n      if (this.props.isExport) {\n        // Image export map shouldn't be interactive (otherwise this callback can\n        // lead to inadvertent changes to the state of the main map)\n        return;\n      }\n      const {setInternalViewState} = this.context;\n\n      // Flat map (2D/3D): keep the original, always-synchronous behavior. The\n      // interaction-aware timing below exists purely to fix globe-specific\n      // controlled-viewState, so it must not change the main 2D logic.\n      if (!this.props.mapState?.globe?.enabled) {\n        setInternalViewState(viewState, this.props.index);\n        this._wasInteracting = false;\n        this._onViewportChangePropagateDebounced();\n        return;\n      }\n\n      const isUserInteraction =\n        interactionState &&\n        (interactionState.isZooming ||\n          interactionState.isPanning ||\n          interactionState.isRotating ||\n          interactionState.isDragging ||\n          interactionState.inTransition);\n      // The emit that ends a gesture (panend/rotateEnd, or a fling transition\n      // ending) arrives with all interaction flags false. If we defer it, the\n      // controlled `viewState` fed back to deck lags a frame behind the\n      // controller's committed state and deck re-seeds from the stale value,\n      // making the globe visibly \"jump back\" to where the drag was released -\n      // most noticeable on a throw/fling release. Treat the first all-false emit\n      // right after an active gesture as part of that gesture and apply it\n      // synchronously too.\n      const isInteractionSettle = !isUserInteraction && this._wasInteracting;\n      this._wasInteracting = Boolean(isUserInteraction);\n      if (isUserInteraction || isInteractionSettle) {\n        // For interactive gestures (pan/zoom/rotate) and their end-of-gesture\n        // settle, update synchronously so the controlled `viewState` stays in\n        // lockstep with the controller and there's no stale re-seed.\n        setInternalViewState(viewState, this.props.index);\n      } else {\n        // deck.gl can fire onViewStateChange synchronously during its own render\n        // (e.g. when switching view types like MapView -> GlobeView). Updating React\n        // state during render throws a warning, so defer non-interactive updates.\n        setTimeout(() => {\n          setInternalViewState(viewState, this.props.index);\n        }, 0);\n      }\n      this._onViewportChangePropagateDebounced();\n    };\n\n    _onLayerHoverDebounced = debounce((data, index) => {\n      this.props.visStateActions.onLayerHover(data, index);\n    }, DEBOUNCE_MOUSE_MOVE_PROPAGATE);\n\n    _onMouseMoveDebounced = debounce((event, viewport) => {\n      this.props.visStateActions.onMouseMove(normalizeEvent(event, viewport));\n    }, DEBOUNCE_MOUSE_MOVE_PROPAGATE);\n\n    _onLayerLoadingStateChange = debounce(() => {\n      // trigger loading indicator update without any change to update UI\n      this.props.visStateActions.setLoadingIndicator({change: 0});\n    }, DEBOUNCE_LOADING_STATE_PROPAGATE);\n\n    _handleToggleLayerVisibility = (layer: Layer) => {\n      const {visStateActions} = this.props;\n      visStateActions.layerConfigChange(layer, {isVisible: !layer.config.isVisible});\n    };\n\n    _toggleMapControl = panelId => {\n      const {index, uiStateActions} = this.props;\n\n      uiStateActions.toggleMapControl(panelId, Number(index));\n    };\n\n    /* eslint-disable complexity */\n    _renderMap() {\n      const {\n        visState,\n        mapState,\n        mapStyle,\n        mapStateActions,\n        mapboxApiAccessToken,\n        // mapboxApiUrl,\n        mapControls,\n        isExport,\n        locale,\n        uiTheme,\n        uiStateActions,\n        visStateActions,\n        index,\n        primary,\n        bottomMapContainerProps,\n        topMapContainerProps,\n        theme,\n        datasetAttributions = [],\n        attributionLogos = [],\n        containerId = 0,\n        isLoadingIndicatorVisible,\n        activeSidePanel,\n        sidePanelWidth\n      } = this.props;\n\n      const {layers, datasets, editor, interactionConfig, layerOrder} = visState;\n\n      const layersToRender = this.layersToRenderSelector(this.props);\n      const layersForDeck = this.layersForDeckSelector(this.props);\n\n      // Current style can be a custom style, from which we pull the mapbox API acccess token\n      const currentStyle = mapStyle.mapStyles?.[mapStyle.styleType];\n      const baseMapLibraryName = getBaseMapLibrary(currentStyle);\n      const baseMapLibraryConfig = getApplicationConfig().baseMapLibraryConfig[baseMapLibraryName];\n\n      // Select the correct Map adapter based on the active base map library.\n      // Using the native adapter for each library avoids Transform API\n      // incompatibilities (e.g. mapbox-legacy's cloneTransform with MapLibre v5).\n      const ResolvedMapComponent =\n        this.props.MapComponent ??\n        (baseMapLibraryName === MAP_LIB_OPTIONS.MAPBOX ? MapboxLegacyMap : MaplibreMap);\n\n      const useMapboxAdapter = ResolvedMapComponent === MapboxLegacyMap;\n\n      const internalViewState = this.context?.getInternalViewState(index);\n      const configMaxPitch = mapState.maxPitch ?? getApplicationConfig().maxPitch;\n      const effectiveMaxPitch = useMapboxAdapter\n        ? Math.min(configMaxPitch, MAPBOX_MAX_PITCH)\n        : configMaxPitch;\n      const mapProps: Record<string, any> = {\n        ...internalViewState,\n        maxPitch: effectiveMaxPitch,\n        preserveDrawingBuffer: this.props.isExport ?? false,\n        mapboxAccessToken: currentStyle?.accessToken || mapboxApiAccessToken,\n        // baseApiUrl: mapboxApiUrl,\n        transformRequest:\n          this.props.transformRequest ||\n          transformRequest(currentStyle?.accessToken || mapboxApiAccessToken)\n      };\n\n      if (this.props.RTLTextPlugin !== undefined) {\n        mapProps.RTLTextPlugin = this.props.RTLTextPlugin;\n      }\n\n      if (useMapboxAdapter) {\n        const mapboxConfig = getApplicationConfig().baseMapLibraryConfig[MAP_LIB_OPTIONS.MAPBOX];\n        mapProps.mapLib = mapboxConfig.getMapLib();\n      }\n\n      const hasGeocoderLayer = Boolean(layers.find(l => l.id === GEOCODER_LAYER_ID));\n      const isSplit = Boolean(mapState.isSplit);\n\n      const deck = this._renderDeckOverlay(layersForDeck, {\n        primaryMap: true,\n        isInteractive: true,\n        children: (\n          <ResolvedMapComponent\n            key={`bottom-${baseMapLibraryName}`}\n            {...mapProps}\n            mapStyle={\n              mapState.globe?.enabled\n                ? EMPTY_MAPBOX_STYLE\n                : mapStyle.bottomMapStyle ?? EMPTY_MAPBOX_STYLE\n            }\n            {...bottomMapContainerProps}\n            ref={this._setMapRef}\n          />\n        )\n      });\n      if (!deck) {\n        // deckOverlay can be null if onDeckRender returns null\n        // in this case we don't want to render the map\n        return null;\n      }\n      // In split (dual) view mode, only render the map control buttons on the\n      // right-side map (primary === true, i.e. index === 1). Otherwise the same\n      // buttons are duplicated on both maps and any opened menu appears mirrored.\n      const showMapControl = !isSplit || Boolean(primary);\n      return (\n        <>\n          {showMapControl && (\n            <MapControl\n              mapState={mapState}\n              mapStateActions={mapStateActions}\n              datasets={datasets}\n              availableLocales={LOCALE_CODES_ARRAY}\n              dragRotate={mapState.dragRotate}\n              isSplit={isSplit}\n              primary={Boolean(primary)}\n              isExport={isExport}\n              layers={layers}\n              layerOrder={layerOrder}\n              layersToRender={layersToRender}\n              mapIndex={index || 0}\n              mapControls={mapControls}\n              readOnly={this.props.readOnly}\n              scale={mapState.scale || 1}\n              logoComponent={this.props.logoComponent}\n              top={\n                interactionConfig.geocoder && interactionConfig.geocoder.enabled\n                  ? theme.mapControlTop\n                  : 0\n              }\n              editor={editor}\n              locale={locale}\n              themeName={uiTheme}\n              onTogglePerspective={mapStateActions.togglePerspective}\n              onSetMapViewMode={mapStateActions.setMapViewMode}\n              mapViewMode={mapState.mapViewMode}\n              onToggleSplitMap={mapStateActions.toggleSplitMap}\n              onMapToggleLayer={this._handleMapToggleLayer}\n              onToggleMapControl={this._toggleMapControl}\n              onToggleSplitMapViewport={mapStateActions.toggleSplitMapViewport}\n              onSetEditorMode={visStateActions.setEditorMode}\n              onSetLocale={uiStateActions.setLocale}\n              onSetTheme={uiStateActions.setTheme}\n              onToggleEditorVisibility={visStateActions.toggleEditorVisibility}\n              onConvertEditorFeaturesToLayer={visStateActions.convertEditorFeaturesToLayer}\n              onLayerVisConfigChange={visStateActions.layerVisConfigChange}\n              onToggleLayerVisibility={this._handleToggleLayerVisibility}\n              mapHeight={mapState.height}\n              setMapControlSettings={uiStateActions.setMapControlSettings}\n              activeSidePanel={activeSidePanel}\n              splitMaps={this.props.visState.splitMaps}\n              onToggleLayerForMap={visStateActions.toggleLayerForMap}\n            />\n          )}\n          {isSplitSelector(this.props) && <Droppable containerId={containerId} />}\n\n          {deck}\n          {this._renderMapboxOverlays()}\n          <Editor\n            index={index || 0}\n            datasets={datasets}\n            editor={editor}\n            filters={this.polygonFiltersSelector(this.props)}\n            layers={layers}\n            onDeleteFeature={visStateActions.deleteFeature}\n            onSetFeatureProperties={visStateActions.setEditorFeatureProperties}\n            onSelect={visStateActions.setSelectedFeature}\n            onTogglePolygonFilter={visStateActions.setPolygonFilterLayer}\n            onSetEditorMode={visStateActions.setEditorMode}\n            style={{\n              pointerEvents: 'all',\n              position: 'absolute',\n              display: editor.visible ? 'block' : 'none'\n            }}\n          />\n          {editor.visible ? (\n            <FilterFeatureBadges\n              filters={this.polygonFiltersSelector(this.props)}\n              viewport={this._getAnnotationViewport(mapState, internalViewState)}\n              isGlobeEnabled={Boolean(mapState.globe?.enabled)}\n              onSelect={visStateActions.setSelectedFeature}\n            />\n          ) : null}\n          <AnnotationOverlay\n            annotations={visState.annotations}\n            selectedAnnotationId={visState.selectedAnnotationId}\n            isEditingAnnotationText={visState.isEditingAnnotationText}\n            isAnnotationMode={Boolean(mapControls?.annotation?.active)}\n            mapIndex={index || 0}\n            viewport={this._getAnnotationViewport(mapState, internalViewState)}\n            isGlobeEnabled={Boolean(mapState.globe?.enabled)}\n            updateAnnotation={visStateActions.updateAnnotation}\n            setSelectedAnnotation={visStateActions.setSelectedAnnotation}\n          />\n          {this.props.children}\n          {mapStyle.topMapStyle && !mapState.globe?.enabled ? (\n            <ResolvedMapComponent\n              key={`top-${baseMapLibraryName}`}\n              viewState={internalViewState}\n              maxPitch={effectiveMaxPitch}\n              mapStyle={mapStyle.topMapStyle}\n              style={MAP_STYLE.top}\n              mapboxAccessToken={mapProps.mapboxAccessToken}\n              transformRequest={mapProps.transformRequest}\n              {...(mapProps.RTLTextPlugin !== undefined\n                ? {RTLTextPlugin: mapProps.RTLTextPlugin}\n                : {})}\n              {...(useMapboxAdapter\n                ? {\n                    mapLib:\n                      getApplicationConfig().baseMapLibraryConfig[\n                        MAP_LIB_OPTIONS.MAPBOX\n                      ].getMapLib()\n                  }\n                : {})}\n              {...topMapContainerProps}\n            />\n          ) : null}\n\n          {hasGeocoderLayer\n            ? this._renderDeckOverlay(\n                {[GEOCODER_LAYER_ID]: hasGeocoderLayer},\n                {primaryMap: false, isInteractive: false}\n              )\n            : null}\n          {this._renderMapPopover()}\n          {!isExport && primary !== isSplit ? (\n            <LoadingIndicator\n              isVisible={Boolean(isLoadingIndicatorVisible || this.anyActiveLayerLoading)}\n              activeSidePanel={Boolean(activeSidePanel)}\n              sidePanelWidth={sidePanelWidth}\n              hasAttributionLogos={attributionLogos.length > 0}\n              hasMapScale={getApplicationConfig().enableMapScale}\n            />\n          ) : null}\n          {this.props.primary ? (\n            <Attribution\n              showBaseMapLibLogo={this.state.showBaseMapLibLogo}\n              basemapAttributions={this.state.basemapAttributions}\n              datasetAttributions={datasetAttributions}\n              baseMapLibraryConfig={baseMapLibraryConfig}\n              globeAttributions={getGlobeBasemapAttributions({\n                globe: mapState.globe,\n                mapboxApiAccessToken,\n                mapStyleType: mapStyle?.styleType,\n                basemapProvider: resolveGlobeBasemapProvider(\n                  baseMapLibraryName,\n                  mapboxApiAccessToken\n                )\n              })}\n            />\n          ) : null}\n          {this.props.primary ? (\n            <AttributionLogos\n              logos={attributionLogos}\n              activeSidePanel={Boolean(activeSidePanel)}\n              sidePanelWidth={sidePanelWidth}\n            />\n          ) : null}\n          {!isExport && getApplicationConfig().enableMapScale ? (\n            <StyledMapScaleContainer\n              $left={\n                primary && activeSidePanel\n                  ? (sidePanelWidth || 0) + (theme?.sidePanel?.margin?.left ?? 9)\n                  : theme?.sidePanel?.margin?.left ?? 9\n              }\n              $bottomOffset={primary && attributionLogos.length > 0 ? 24 : 0}\n            >\n              <MapScale mapState={mapState} mapIndex={index ?? 0} />\n            </StyledMapScaleContainer>\n          ) : null}\n        </>\n      );\n    }\n\n    render() {\n      const {visState, mapStyle} = this.props;\n      const mapContent = this._renderMap();\n      if (!mapContent) {\n        // mapContent can be null if onDeckRender returns null\n        // in this case we don't want to render the map\n        return null;\n      }\n\n      const currentStyle = mapStyle.mapStyles?.[mapStyle.styleType];\n      const baseMapLibraryName = getBaseMapLibrary(currentStyle);\n      const baseMapLibraryConfig = getApplicationConfig().baseMapLibraryConfig[baseMapLibraryName];\n\n      return (\n        <StyledMap\n          ref={this._ref}\n          style={this.styleSelector(this.props)}\n          onContextMenu={event => event.preventDefault()}\n          $mixBlendMode={visState.overlayBlending}\n          $mapLibCssClass={baseMapLibraryConfig.mapLibCssClass}\n        >\n          {mapContent}\n        </StyledMap>\n      );\n    }\n  }\n\n  return withTheme(MapContainer);\n}\n"],"mappings":"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","ignoreList":[]}