@kepler.gl/components 3.0.0-alpha.0

package/dist/map-container.js

@@ -0,0 +1,653 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = MapContainerFactory;
+exports.Attribution = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactMapGl = _interopRequireDefault(require("react-map-gl"));
+
+var _react2 = _interopRequireDefault(require("@deck.gl/react"));
+
+var _reselect = require("reselect");
+
+var _viewportMercatorProject = _interopRequireDefault(require("viewport-mercator-project"));
+
+var _mapPopover = _interopRequireDefault(require("./map/map-popover"));
+
+var _mapControl = _interopRequireDefault(require("./map/map-control"));
+
+var _styledComponents = require("./common/styled-components");
+
+var _editor = _interopRequireDefault(require("./editor/editor"));
+
+var _layers = require("@kepler.gl/layers");
+
+var _utils = require("@kepler.gl/utils");
+
+var _styles = require("@kepler.gl/styles");
+
+var _constants = require("@kepler.gl/constants");
+
+var _errorBoundary = _interopRequireDefault(require("./common/error-boundary"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _core = require("@deck.gl/core");
+
+var _reducers = require("@kepler.gl/reducers");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/** @type {{[key: string]: React.CSSProperties}} */
+var MAP_STYLE = {
+  container: {
+    display: 'inline-block',
+    position: 'relative',
+    width: '100%',
+    height: '100%'
+  },
+  top: {
+    position: 'absolute',
+    top: '0px',
+    pointerEvents: 'none',
+    width: '100%',
+    height: '100%'
+  }
+};
+var LOCALE_CODES_ARRAY = Object.keys(_localization.LOCALE_CODES);
+var MAPBOXGL_STYLE_UPDATE = 'style.load';
+var MAPBOXGL_RENDER = 'render';
+
+var nop = function nop() {};
+
+var MapboxLogo = function MapboxLogo() {
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: "attrition-logo"
+  }, "Basemap by:", /*#__PURE__*/_react["default"].createElement("a", {
+    className: "mapboxgl-ctrl-logo",
+    target: "_blank",
+    rel: "noopener noreferrer",
+    href: "https://www.mapbox.com/",
+    "aria-label": "Mapbox logo"
+  }));
+};
+
+var Attribution = function Attribution(_ref) {
+  var _ref$showMapboxLogo = _ref.showMapboxLogo,
+      showMapboxLogo = _ref$showMapboxLogo === void 0 ? true : _ref$showMapboxLogo;
+  var isPalm = (0, _utils.hasMobileWidth)(_styles.breakPointValues);
+  var memoizedComponents = (0, _react.useMemo)(function () {
+    if (!showMapboxLogo) {
+      return /*#__PURE__*/_react["default"].createElement(_styledComponents.StyledAttrbution, null, /*#__PURE__*/_react["default"].createElement("a", {
+        href: "http://www.openstreetmap.org/copyright",
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, "\xA9 OpenStreetMap"));
+    }
+
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents.StyledAttrbution, null, isPalm ? /*#__PURE__*/_react["default"].createElement(MapboxLogo, null) : null, /*#__PURE__*/_react["default"].createElement("div", {
+      className: "attrition-link"
+    }, /*#__PURE__*/_react["default"].createElement("a", {
+      href: "https://kepler.gl/policy/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 kepler.gl |", ' '), /*#__PURE__*/_react["default"].createElement("a", {
+      href: "https://www.mapbox.com/about/maps/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 Mapbox |", ' '), /*#__PURE__*/_react["default"].createElement("a", {
+      href: "http://www.openstreetmap.org/copyright",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 OpenStreetMap |", ' '), /*#__PURE__*/_react["default"].createElement("a", {
+      href: "https://www.mapbox.com/map-feedback/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, /*#__PURE__*/_react["default"].createElement("strong", null, "Improve this map "), !isPalm ? /*#__PURE__*/_react["default"].createElement("strong", null, " | ") : null), !isPalm ? /*#__PURE__*/_react["default"].createElement(MapboxLogo, null) : null));
+  }, [showMapboxLogo, isPalm]);
+  return memoizedComponents;
+};
+
+exports.Attribution = Attribution;
+MapContainerFactory.deps = [_mapPopover["default"], _mapControl["default"], _editor["default"]];
+
+function MapContainerFactory(MapPopover, MapControl, Editor) {
+  var MapContainer = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(MapContainer, _Component);
+
+    var _super = _createSuper(MapContainer);
+
+    function MapContainer(_props) {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, MapContainer);
+      _this = _super.call(this, _props);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "displayName", 'MapContainer');
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", {
+        // Determines whether attribution should be visible based the result of loading the map style
+        showMapboxAttribution: true
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_deck", null);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_map", null);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_ref", /*#__PURE__*/(0, _react.createRef)());
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_deckGLErrorsElapsed", {});
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "previousLayers", {// [layers.id]: mapboxLayerConfig
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_handleResize", function (dimensions) {
+        var primary = _this.props.primary;
+
+        if (primary) {
+          var mapStateActions = _this.props.mapStateActions;
+
+          if (dimensions && dimensions.width > 0 && dimensions.height > 0) {
+            mapStateActions.updateMap(dimensions);
+          }
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layersSelector", function (props) {
+        return props.visState.layers;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layerDataSelector", function (props) {
+        return props.visState.layerData;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "splitMapSelector", function (props) {
+        return props.visState.splitMaps;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "splitMapIndexSelector", function (props) {
+        return props.index;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mapLayersSelector", (0, _reselect.createSelector)(_this.splitMapSelector, _this.splitMapIndexSelector, _utils.getMapLayersFromSplitMaps));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layerOrderSelector", function (props) {
+        return props.visState.layerOrder;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layersToRenderSelector", (0, _reselect.createSelector)(_this.layersSelector, _this.layerDataSelector, _this.mapLayersSelector, _reducers.prepareLayersToRender));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layersForDeckSelector", (0, _reselect.createSelector)(_this.layersSelector, _this.layerDataSelector, _reducers.prepareLayersForDeck));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filtersSelector", function (props) {
+        return props.visState.filters;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "polygonFilters", (0, _reselect.createSelector)(_this.filtersSelector, function (filters) {
+        return filters.filter(function (f) {
+          return f.type === _constants.FILTER_TYPES.polygon;
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mapboxLayersSelector", (0, _reselect.createSelector)(_this.layersSelector, _this.layerDataSelector, _this.layerOrderSelector, _this.layersToRenderSelector, _layers.generateMapboxLayers));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onCloseMapPopover", function () {
+        _this.props.visStateActions.onLayerClick(null);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onLayerSetDomain", function (idx, colorDomain) {
+        _this.props.visStateActions.layerConfigChange(_this.props.visState.layers[idx], {
+          colorDomain: colorDomain
+        });
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_handleMapToggleLayer", function (layerId) {
+        var _this$props = _this.props,
+            _this$props$index = _this$props.index,
+            mapIndex = _this$props$index === void 0 ? 0 : _this$props$index,
+            visStateActions = _this$props.visStateActions;
+        visStateActions.toggleLayerForMap(mapIndex, layerId);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onMapboxStyleUpdate", function (update) {
+        // force refresh mapboxgl layers
+        _this.previousLayers = {};
+
+        _this._updateMapboxLayers();
+
+        if (update && update.style) {
+          // No attributions are needed if the style doesn't reference Mapbox sources
+          _this.setState({
+            showMapboxAttribution: (0, _utils.isStyleUsingMapboxTiles)(update.style)
+          });
+        }
+
+        if (typeof _this.props.onMapStyleLoaded === 'function') {
+          _this.props.onMapStyleLoaded(_this._map);
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_setMapboxMap", function (mapbox) {
+        if (!_this._map && mapbox) {
+          _this._map = mapbox.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, function () {
+            if (typeof _this.props.onMapRender === 'function') {
+              _this.props.onMapRender(_this._map);
+            }
+          });
+        }
+
+        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(mapbox, _this.props.index);
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onBeforeRender", function (_ref2) {
+        var gl = _ref2.gl;
+        (0, _utils.setLayerBlending)(gl, _this.props.visState.layerBlending);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onDeckError", function (error, layer) {
+        var errorMessage = "An error in deck.gl: ".concat(error.message, " in ").concat(layer.id);
+        var notificationId = "".concat(layer.id, "-").concat(error.message); // Throttle error notifications, as React doesn't like too many state changes from here.
+
+        var lastShown = _this._deckGLErrorsElapsed[notificationId];
+
+        if (!lastShown || lastShown < Date.now() - _constants.THROTTLE_NOTIFICATION_TIME) {
+          _this._deckGLErrorsElapsed[notificationId] = Date.now(); // 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((0, _utils.errorNotification)({
+            message: errorMessage,
+            id: notificationId
+          }));
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onViewportChange", function (viewState) {
+        (0, _utils.onViewPortChange)(viewState, _this.props.mapStateActions.updateMap, _this.props.onViewStateChange, _this.props.primary);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_toggleMapControl", function (panelId) {
+        var _this$props2 = _this.props,
+            index = _this$props2.index,
+            uiStateActions = _this$props2.uiStateActions;
+        uiStateActions.toggleMapControl(panelId, Number(index));
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(MapContainer, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        if (!this._ref.current) {
+          return;
+        }
+
+        (0, _utils.observeDimensions)(this._ref.current, this._handleResize);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        // unbind mapboxgl event listener
+        if (this._map) {
+          var _this$_map, _this$_map2;
+
+          (_this$_map = this._map) === null || _this$_map === void 0 ? void 0 : _this$_map.off(MAPBOXGL_STYLE_UPDATE, nop);
+          (_this$_map2 = this._map) === null || _this$_map2 === void 0 ? void 0 : _this$_map2.off(MAPBOXGL_RENDER, nop);
+        }
+
+        if (!this._ref.current) {
+          return;
+        }
+
+        (0, _utils.unobserveDimensions)(this._ref.current);
+      }
+    }, {
+      key: "_onDeckInitialized",
+      value: function _onDeckInitialized(gl) {
+        if (this.props.onDeckInitialized) {
+          this.props.onDeckInitialized(this._deck, gl);
+        }
+      }
+    }, {
+      key: "_renderMapPopover",
+      value:
+      /* component render functions */
+
+      /* eslint-disable complexity */
+      function _renderMapPopover() {
+        // TODO: move this into reducer so it can be tested
+        var _this$props3 = this.props,
+            mapState = _this$props3.mapState,
+            _this$props3$visState = _this$props3.visState,
+            hoverInfo = _this$props3$visState.hoverInfo,
+            clicked = _this$props3$visState.clicked,
+            datasets = _this$props3$visState.datasets,
+            interactionConfig = _this$props3$visState.interactionConfig,
+            layers = _this$props3$visState.layers,
+            _this$props3$visState2 = _this$props3$visState.mousePos,
+            mousePosition = _this$props3$visState2.mousePosition,
+            coordinate = _this$props3$visState2.coordinate,
+            pinned = _this$props3$visState2.pinned;
+        var layersToRender = this.layersToRenderSelector(this.props);
+
+        if (!mousePosition || !interactionConfig.tooltip) {
+          return null;
+        }
+
+        var layerHoverProp = (0, _reducers.getLayerHoverProp)({
+          interactionConfig: interactionConfig,
+          hoverInfo: hoverInfo,
+          layers: layers,
+          layersToRender: layersToRender,
+          datasets: datasets
+        });
+        var compareMode = interactionConfig.tooltip.config ? interactionConfig.tooltip.config.compareMode : false;
+        var pinnedPosition = {};
+        var layerPinnedProp = null;
+
+        if (pinned || clicked) {
+          // project lnglat to screen so that tooltip follows the object on zoom
+          var _viewport = new _viewportMercatorProject["default"](mapState);
+
+          var lngLat = clicked ? clicked.coordinate : pinned.coordinate;
+          pinnedPosition = this._getHoverXY(_viewport, lngLat);
+          layerPinnedProp = (0, _reducers.getLayerHoverProp)({
+            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["default"].createElement(_errorBoundary["default"], null, layerPinnedProp && /*#__PURE__*/_react["default"].createElement(MapPopover, (0, _extends2["default"])({}, pinnedPosition, commonProp, {
+          layerHoverProp: layerPinnedProp,
+          coordinate: interactionConfig.coordinate.enabled && (pinned || {}).coordinate,
+          frozen: true,
+          isBase: compareMode
+        })), layerHoverProp && (!layerPinnedProp || compareMode) && /*#__PURE__*/_react["default"].createElement(MapPopover, (0, _extends2["default"])({
+          x: mousePosition[0],
+          y: mousePosition[1]
+        }, commonProp, {
+          layerHoverProp: layerHoverProp,
+          frozen: false,
+          coordinate: interactionConfig.coordinate.enabled && coordinate
+        })));
+      }
+      /* 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 _this2 = this;
+
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+          primaryMap: false
+        };
+        var _this$props4 = this.props,
+            mapState = _this$props4.mapState,
+            mapStyle = _this$props4.mapStyle,
+            visState = _this$props4.visState,
+            visStateActions = _this$props4.visStateActions,
+            mapboxApiAccessToken = _this$props4.mapboxApiAccessToken,
+            mapboxApiUrl = _this$props4.mapboxApiUrl,
+            deckGlProps = _this$props4.deckGlProps,
+            index = _this$props4.index;
+        var deckGlLayers = (0, _reducers.computeDeckLayers)({
+          visState: visState,
+          mapState: mapState,
+          mapStyle: mapStyle
+        }, {
+          mapIndex: index,
+          primaryMap: options.primaryMap,
+          mapboxApiAccessToken: mapboxApiAccessToken,
+          mapboxApiUrl: mapboxApiUrl,
+          layersForDeck: layersForDeck
+        }, this._onLayerSetDomain, deckGlProps);
+        var views = deckGlProps !== null && deckGlProps !== void 0 && deckGlProps.views ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.views() : new _core.MapView({
+          legacyMeterSizes: true
+        });
+        return /*#__PURE__*/_react["default"].createElement(_react2["default"], (0, _extends2["default"])({
+          id: "default-deckgl-overlay"
+        }, deckGlProps, {
+          views: views,
+          layers: deckGlLayers,
+          controller: true,
+          viewState: mapState,
+          onBeforeRender: this._onBeforeRender,
+          onHover: visStateActions.onLayerHover,
+          onClick: visStateActions.onLayerClick,
+          onError: this._onDeckError,
+          ref: function ref(comp) {
+            if (comp && comp.deck && !_this2._deck) {
+              _this2._deck = comp.deck;
+            }
+          },
+          onWebGLInitialized: function onWebGLInitialized(gl) {
+            return _this2._onDeckInitialized(gl);
+          }
+        }));
+      }
+    }, {
+      key: "_updateMapboxLayers",
+      value: function _updateMapboxLayers() {
+        var mapboxLayers = this.mapboxLayersSelector(this.props);
+
+        if (!Object.keys(mapboxLayers).length && !Object.keys(this.previousLayers).length) {
+          return;
+        }
+
+        (0, _layers.updateMapboxLayers)(this._map, mapboxLayers, this.previousLayers);
+        this.previousLayers = mapboxLayers;
+      }
+    }, {
+      key: "_renderMapboxOverlays",
+      value: function _renderMapboxOverlays() {
+        if (this._map && this._map.isStyleLoaded()) {
+          this._updateMapboxLayers();
+        }
+      }
+    }, {
+      key: "_renderDrawEditor",
+      value: function _renderDrawEditor() {
+        var _this$props5 = this.props,
+            visState = _this$props5.visState,
+            mapControls = _this$props5.mapControls,
+            visStateActions = _this$props5.visStateActions,
+            index = _this$props5.index;
+        var layers = visState.layers,
+            datasets = visState.datasets,
+            editor = visState.editor;
+        var isEdit = mapControls.mapDraw ? mapControls.mapDraw.active : false;
+        var layersToRender = this.layersToRenderSelector(this.props);
+        return /*#__PURE__*/_react["default"].createElement(Editor, {
+          index: index,
+          datasets: datasets,
+          editor: editor,
+          filters: this.polygonFilters(this.props),
+          isEnabled: isEdit,
+          layers: layers,
+          layersToRender: layersToRender,
+          onDeleteFeature: visStateActions.deleteFeature,
+          onSelect: visStateActions.setSelectedFeature,
+          onUpdate: visStateActions.setFeatures,
+          onTogglePolygonFilter: visStateActions.setPolygonFilterLayer,
+          style: {
+            pointerEvents: isEdit ? 'all' : 'none',
+            position: 'absolute',
+            display: editor.visible ? 'block' : 'none'
+          }
+        });
+      }
+    }, {
+      key: "_renderMap",
+      value:
+      /* eslint-disable complexity */
+      function _renderMap() {
+        var _mapStyle$mapStyles;
+
+        var _this$props6 = this.props,
+            visState = _this$props6.visState,
+            mapState = _this$props6.mapState,
+            mapStyle = _this$props6.mapStyle,
+            mapStateActions = _this$props6.mapStateActions,
+            _this$props6$MapCompo = _this$props6.MapComponent,
+            MapComponent = _this$props6$MapCompo === void 0 ? _reactMapGl["default"] : _this$props6$MapCompo,
+            mapboxApiAccessToken = _this$props6.mapboxApiAccessToken,
+            mapboxApiUrl = _this$props6.mapboxApiUrl,
+            mapControls = _this$props6.mapControls,
+            isExport = _this$props6.isExport,
+            locale = _this$props6.locale,
+            uiStateActions = _this$props6.uiStateActions,
+            visStateActions = _this$props6.visStateActions,
+            index = _this$props6.index,
+            primary = _this$props6.primary,
+            bottomMapContainerProps = _this$props6.bottomMapContainerProps,
+            topMapContainerProps = _this$props6.topMapContainerProps;
+        var layers = visState.layers,
+            datasets = visState.datasets,
+            editor = visState.editor,
+            interactionConfig = visState.interactionConfig,
+            hoverInfo = visState.hoverInfo;
+        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$mapStyles = mapStyle.mapStyles) === null || _mapStyle$mapStyles === void 0 ? void 0 : _mapStyle$mapStyles[mapStyle.styleType];
+
+        var mapProps = _objectSpread(_objectSpread({}, mapState), {}, {
+          width: '100%',
+          height: '100%',
+          preserveDrawingBuffer: true,
+          mapboxApiAccessToken: (currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.accessToken) || mapboxApiAccessToken,
+          mapboxApiUrl: mapboxApiUrl,
+          onViewportChange: this._onViewportChange,
+          transformRequest: _utils.transformRequest
+        });
+
+        var hasGeocoderLayer = Boolean(layers.find(function (l) {
+          return l.id === _constants.GEOCODER_LAYER_ID;
+        }));
+        var isSplit = Boolean(mapState.isSplit);
+        return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(MapControl, {
+          datasets: datasets,
+          availableLocales: LOCALE_CODES_ARRAY,
+          dragRotate: mapState.dragRotate,
+          isSplit: isSplit,
+          primary: primary,
+          isExport: isExport,
+          layers: layers,
+          layersToRender: layersToRender,
+          mapIndex: index,
+          mapControls: mapControls,
+          readOnly: this.props.readOnly,
+          scale: mapState.scale || 1,
+          top: interactionConfig.geocoder && interactionConfig.geocoder.enabled ? 52 : 0,
+          editor: editor,
+          locale: locale,
+          onTogglePerspective: mapStateActions.togglePerspective,
+          onToggleSplitMap: mapStateActions.toggleSplitMap,
+          onMapToggleLayer: this._handleMapToggleLayer,
+          onToggleMapControl: this._toggleMapControl,
+          onSetEditorMode: visStateActions.setEditorMode,
+          onSetLocale: uiStateActions.setLocale,
+          onToggleEditorVisibility: visStateActions.toggleEditorVisibility,
+          mapHeight: mapState.height
+        }), /*#__PURE__*/_react["default"].createElement(MapComponent, (0, _extends2["default"])({
+          key: "bottom"
+        }, mapProps, {
+          mapStyle: mapStyle.bottomMapStyle
+        }, bottomMapContainerProps, {
+          ref: this._setMapboxMap,
+          getCursor: hoverInfo ? function () {
+            return 'pointer';
+          } : undefined,
+          onMouseMove: this.props.visStateActions.onMouseMove
+        }), this._renderDeckOverlay(layersForDeck, {
+          primaryMap: true
+        }), this._renderMapboxOverlays(), this._renderDrawEditor()), mapStyle.topMapStyle || hasGeocoderLayer ? /*#__PURE__*/_react["default"].createElement("div", {
+          style: MAP_STYLE.top
+        }, /*#__PURE__*/_react["default"].createElement(MapComponent, (0, _extends2["default"])({
+          key: "top"
+        }, mapProps, {
+          mapStyle: mapStyle.topMapStyle
+        }, topMapContainerProps), this._renderDeckOverlay((0, _defineProperty2["default"])({}, _constants.GEOCODER_LAYER_ID, hasGeocoderLayer)))) : null, this._renderMapPopover(), !isSplit || index === 1 ? /*#__PURE__*/_react["default"].createElement(Attribution, {
+          showMapboxLogo: this.state.showMapboxAttribution
+        }) : null);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var mapStyle = this.props.mapStyle;
+        return /*#__PURE__*/_react["default"].createElement(_styledComponents.StyledMapContainer, {
+          ref: this._ref,
+          style: MAP_STYLE.container
+        }, mapStyle.bottomMapStyle && this._renderMap());
+      }
+    }]);
+    return MapContainer;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(MapContainer, "defaultProps", {
+    MapComponent: _reactMapGl["default"],
+    deckGlProps: {},
+    index: 0,
+    primary: true
+  });
+  return MapContainer;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/map-container.tsx"],"names":["MAP_STYLE","container","display","position","width","height","top","pointerEvents","LOCALE_CODES_ARRAY","Object","keys","LOCALE_CODES","MAPBOXGL_STYLE_UPDATE","MAPBOXGL_RENDER","nop","MapboxLogo","Attribution","showMapboxLogo","isPalm","breakPointValues","memoizedComponents","MapContainerFactory","deps","MapPopoverFactory","MapControlFactory","EditorFactory","MapPopover","MapControl","Editor","MapContainer","props","showMapboxAttribution","dimensions","primary","mapStateActions","updateMap","visState","layers","layerData","splitMaps","index","splitMapSelector","splitMapIndexSelector","getMapLayersFromSplitMaps","layerOrder","layersSelector","layerDataSelector","mapLayersSelector","prepareLayersToRender","prepareLayersForDeck","filters","filtersSelector","filter","f","type","FILTER_TYPES","polygon","layerOrderSelector","layersToRenderSelector","generateMapboxLayers","visStateActions","onLayerClick","idx","colorDomain","layerConfigChange","layerId","mapIndex","toggleLayerForMap","update","previousLayers","_updateMapboxLayers","style","setState","onMapStyleLoaded","_map","mapbox","getMap","on","_onMapboxStyleUpdate","onMapRender","getMapboxRef","gl","layerBlending","error","layer","errorMessage","message","id","notificationId","lastShown","_deckGLErrorsElapsed","Date","now","THROTTLE_NOTIFICATION_TIME","uiStateActions","addNotification","viewState","onViewStateChange","panelId","toggleMapControl","Number","_ref","current","_handleResize","off","onDeckInitialized","_deck","mapState","hoverInfo","clicked","datasets","interactionConfig","mousePos","mousePosition","coordinate","pinned","layersToRender","tooltip","layerHoverProp","compareMode","config","pinnedPosition","layerPinnedProp","viewport","WebMercatorViewport","lngLat","_getHoverXY","primaryData","data","compareType","commonProp","onClose","_onCloseMapPopover","zoom","canvas","undefined","enabled","screenCoord","project","x","y","layersForDeck","options","primaryMap","mapStyle","mapboxApiAccessToken","mapboxApiUrl","deckGlProps","deckGlLayers","_onLayerSetDomain","views","MapView","legacyMeterSizes","_onBeforeRender","onLayerHover","_onDeckError","comp","deck","_onDeckInitialized","mapboxLayers","mapboxLayersSelector","length","isStyleLoaded","mapControls","editor","isEdit","mapDraw","active","polygonFilters","deleteFeature","setSelectedFeature","setFeatures","setPolygonFilterLayer","visible","MapComponent","MapboxGLMap","isExport","locale","bottomMapContainerProps","topMapContainerProps","layersForDeckSelector","currentStyle","mapStyles","styleType","mapProps","preserveDrawingBuffer","accessToken","onViewportChange","_onViewportChange","transformRequest","hasGeocoderLayer","Boolean","find","l","GEOCODER_LAYER_ID","isSplit","dragRotate","readOnly","scale","geocoder","togglePerspective","toggleSplitMap","_handleMapToggleLayer","_toggleMapControl","setEditorMode","setLocale","toggleEditorVisibility","bottomMapStyle","_setMapboxMap","onMouseMove","_renderDeckOverlay","_renderMapboxOverlays","_renderDrawEditor","topMapStyle","_renderMapPopover","state","_renderMap","Component"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// libraries\nimport React, {Component, createRef, useMemo} from 'react';\nimport MapboxGLMap, {MapRef} from 'react-map-gl';\nimport DeckGL from '@deck.gl/react';\nimport {createSelector, Selector} from 'reselect';\nimport WebMercatorViewport from 'viewport-mercator-project';\nimport mapboxgl from 'mapbox-gl';\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 {StyledMapContainer, StyledAttrbution} from './common/styled-components';\n\nimport EditorFactory from './editor/editor';\n\n// utils\nimport {\n  generateMapboxLayers,\n  updateMapboxLayers,\n  LayerBaseConfig,\n  VisualChannelDomain\n} from '@kepler.gl/layers';\nimport {MapState, MapControls, Viewport, SplitMap, SplitMapLayers} from '@kepler.gl/types';\nimport {\n  errorNotification,\n  setLayerBlending,\n  isStyleUsingMapboxTiles,\n  transformRequest,\n  observeDimensions,\n  unobserveDimensions,\n  hasMobileWidth,\n  getMapLayersFromSplitMaps,\n  onViewPortChange\n} from '@kepler.gl/utils';\nimport {breakPointValues} from '@kepler.gl/styles';\n\n// default-settings\nimport {\n  FILTER_TYPES,\n  GEOCODER_LAYER_ID,\n  THROTTLE_NOTIFICATION_TIME\n} from '@kepler.gl/constants';\n\nimport ErrorBoundary from './common/error-boundary';\nimport {LOCALE_CODES} from '@kepler.gl/localization';\nimport {MapView} from '@deck.gl/core';\nimport {\n  MapStyle,\n  computeDeckLayers,\n  getLayerHoverProp,\n  LayerHoverProp,\n  prepareLayersForDeck,\n  prepareLayersToRender,\n  LayersToRender\n} from '@kepler.gl/reducers';\nimport {VisState} from '@kepler.gl/schemas';\n\n/** @type {{[key: string]: React.CSSProperties}} */\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: '0px',\n    pointerEvents: 'none',\n    width: '100%',\n    height: '100%'\n  }\n};\n\nconst LOCALE_CODES_ARRAY = Object.keys(LOCALE_CODES);\n\nconst MAPBOXGL_STYLE_UPDATE = 'style.load';\nconst MAPBOXGL_RENDER = 'render';\nconst nop = () => {};\n\nconst MapboxLogo = () => (\n  <div className=\"attrition-logo\">\n    Basemap by:\n    <a\n      className=\"mapboxgl-ctrl-logo\"\n      target=\"_blank\"\n      rel=\"noopener noreferrer\"\n      href=\"https://www.mapbox.com/\"\n      aria-label=\"Mapbox logo\"\n    />\n  </div>\n);\n\nexport const Attribution = ({showMapboxLogo = true}) => {\n  const isPalm = hasMobileWidth(breakPointValues);\n\n  const memoizedComponents = useMemo(() => {\n    if (!showMapboxLogo) {\n      return (\n        <StyledAttrbution>\n          <a\n            href=\"http://www.openstreetmap.org/copyright\"\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n          >\n            © OpenStreetMap\n          </a>\n        </StyledAttrbution>\n      );\n    }\n\n    return (\n      <StyledAttrbution>\n        {isPalm ? <MapboxLogo /> : null}\n        <div className=\"attrition-link\">\n          <a href=\"https://kepler.gl/policy/\" target=\"_blank\" rel=\"noopener noreferrer\">\n            © kepler.gl |{' '}\n          </a>\n          <a href=\"https://www.mapbox.com/about/maps/\" target=\"_blank\" rel=\"noopener noreferrer\">\n            © Mapbox |{' '}\n          </a>\n          <a\n            href=\"http://www.openstreetmap.org/copyright\"\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n          >\n            © OpenStreetMap |{' '}\n          </a>\n          <a href=\"https://www.mapbox.com/map-feedback/\" target=\"_blank\" rel=\"noopener noreferrer\">\n            <strong>Improve this map </strong>\n            {!isPalm ? <strong> | </strong> : null}\n          </a>\n          {!isPalm ? <MapboxLogo /> : null}\n        </div>\n      </StyledAttrbution>\n    );\n  }, [showMapboxLogo, isPalm]);\n\n  return memoizedComponents;\n};\n\nMapContainerFactory.deps = [MapPopoverFactory, MapControlFactory, EditorFactory];\n\ntype MapboxStyle = string | object | undefined;\ntype PropSelector<R> = Selector<MapContainerProps, R>;\n\ninterface 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  onMapToggleLayer?: Function;\n  onMapStyleLoaded?: Function;\n  onMapRender?: Function;\n  getMapboxRef?: (mapbox?: MapRef | null, index?: number) => void;\n  index?: number;\n\n  locale?: any;\n  editor?: any;\n  MapComponent?: typeof MapboxGLMap;\n  deckGlProps?: any;\n  onDeckInitialized?: (a: any, b: any) => void;\n  onViewStateChange?: (viewport: Viewport) => void;\n\n  topMapContainerProps: any;\n  bottomMapContainerProps: any;\n}\n\nexport default function MapContainerFactory(\n  MapPopover,\n  MapControl,\n  Editor\n): React.ComponentType<MapContainerProps> {\n  class MapContainer extends Component<MapContainerProps> {\n    displayName = 'MapContainer';\n    static defaultProps = {\n      MapComponent: MapboxGLMap,\n      deckGlProps: {},\n      index: 0,\n      primary: true\n    };\n\n    state = {\n      // Determines whether attribution should be visible based the result of loading the map style\n      showMapboxAttribution: true\n    };\n\n    constructor(props) {\n      super(props);\n    }\n\n    componentDidMount() {\n      if (!this._ref.current) {\n        return;\n      }\n      observeDimensions(this._ref.current, this._handleResize);\n    }\n\n    componentWillUnmount() {\n      // unbind mapboxgl event listener\n      if (this._map) {\n        this._map?.off(MAPBOXGL_STYLE_UPDATE, nop);\n        this._map?.off(MAPBOXGL_RENDER, nop);\n      }\n      if (!this._ref.current) {\n        return;\n      }\n      unobserveDimensions(this._ref.current);\n    }\n\n    _deck: any = null;\n    _map: mapboxgl.Map | null = null;\n    _ref = createRef<HTMLDivElement>();\n    _deckGLErrorsElapsed: {[id: string]: number} = {};\n\n    previousLayers = {\n      // [layers.id]: mapboxLayerConfig\n    };\n\n    _handleResize = dimensions => {\n      const {primary} = this.props;\n      if (primary) {\n        const {mapStateActions} = this.props;\n        if (dimensions && dimensions.width > 0 && dimensions.height > 0) {\n          mapStateActions.updateMap(dimensions);\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    polygonFilters = createSelector(this.filtersSelector, filters =>\n      filters.filter(f => f.type === FILTER_TYPES.polygon)\n    );\n\n    mapboxLayersSelector = createSelector(\n      this.layersSelector,\n      this.layerDataSelector,\n      this.layerOrderSelector,\n      this.layersToRenderSelector,\n      generateMapboxLayers\n    );\n\n    /* component private functions */\n    _onCloseMapPopover = () => {\n      this.props.visStateActions.onLayerClick(null);\n    };\n\n    _onLayerSetDomain = (idx: number, colorDomain: VisualChannelDomain) => {\n      this.props.visStateActions.layerConfigChange(this.props.visState.layers[idx], {\n        colorDomain\n      } as Partial<LayerBaseConfig>);\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      if (update && update.style) {\n        // No attributions are needed if the style doesn't reference Mapbox sources\n        this.setState({showMapboxAttribution: isStyleUsingMapboxTiles(update.style)});\n      }\n\n      if (typeof this.props.onMapStyleLoaded === 'function') {\n        this.props.onMapStyleLoaded(this._map);\n      }\n    };\n\n    _setMapboxMap: React.Ref<MapRef> = mapbox => {\n      if (!this._map && mapbox) {\n        this._map = mapbox.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\n        this._map.on(MAPBOXGL_RENDER, () => {\n          if (typeof this.props.onMapRender === 'function') {\n            this.props.onMapRender(this._map);\n          }\n        });\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(mapbox, this.props.index);\n      }\n    };\n\n    _onDeckInitialized(gl) {\n      if (this.props.onDeckInitialized) {\n        this.props.onDeckInitialized(this._deck, gl);\n      }\n    }\n\n    _onBeforeRender = ({gl}) => {\n      setLayerBlending(gl, this.props.visState.layerBlending);\n    };\n\n    _onDeckError = (error, layer) => {\n      const errorMessage = `An error in deck.gl: ${error.message} in ${layer.id}`;\n      const notificationId = `${layer.id}-${error.message}`;\n\n      // Throttle error notifications, as React doesn't like too many state changes from here.\n      const lastShown = this._deckGLErrorsElapsed[notificationId];\n      if (!lastShown || lastShown < Date.now() - THROTTLE_NOTIFICATION_TIME) {\n        this._deckGLErrorsElapsed[notificationId] = Date.now();\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: errorMessage,\n            id: notificationId\n          })\n        );\n      }\n    };\n\n    /* component render functions */\n\n    /* eslint-disable complexity */\n    _renderMapPopover() {\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          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        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 = {};\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 = new WebMercatorViewport(mapState);\n        const lngLat = clicked ? clicked.coordinate : pinned.coordinate;\n        pinnedPosition = this._getHoverXY(viewport, lngLat);\n        layerPinnedProp = getLayerHoverProp({\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            />\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            />\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(layersForDeck, options = {primaryMap: false}) {\n      const {\n        mapState,\n        mapStyle,\n        visState,\n        visStateActions,\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        deckGlProps,\n        index\n      } = this.props;\n\n      const deckGlLayers = computeDeckLayers(\n        {\n          visState,\n          mapState,\n          mapStyle\n        },\n        {\n          mapIndex: index,\n          primaryMap: options.primaryMap,\n          mapboxApiAccessToken,\n          mapboxApiUrl,\n          layersForDeck\n        },\n        this._onLayerSetDomain,\n        deckGlProps\n      );\n\n      const views = deckGlProps?.views\n        ? deckGlProps?.views()\n        : new MapView({legacyMeterSizes: true});\n\n      return (\n        <DeckGL\n          id=\"default-deckgl-overlay\"\n          {...deckGlProps}\n          views={views}\n          layers={deckGlLayers}\n          controller={true}\n          viewState={mapState}\n          onBeforeRender={this._onBeforeRender}\n          onHover={visStateActions.onLayerHover}\n          onClick={visStateActions.onLayerClick}\n          onError={this._onDeckError}\n          ref={comp => {\n            if (comp && comp.deck && !this._deck) {\n              this._deck = comp.deck;\n            }\n          }}\n          onWebGLInitialized={gl => this._onDeckInitialized(gl)}\n        />\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\n    _renderDrawEditor() {\n      const {visState, mapControls, visStateActions, index} = this.props;\n      const {layers, datasets, editor} = visState;\n      const isEdit = mapControls.mapDraw ? mapControls.mapDraw.active : false;\n      const layersToRender = this.layersToRenderSelector(this.props);\n\n      return (\n        <Editor\n          index={index}\n          datasets={datasets}\n          editor={editor}\n          filters={this.polygonFilters(this.props)}\n          isEnabled={isEdit}\n          layers={layers}\n          layersToRender={layersToRender}\n          onDeleteFeature={visStateActions.deleteFeature}\n          onSelect={visStateActions.setSelectedFeature}\n          onUpdate={visStateActions.setFeatures}\n          onTogglePolygonFilter={visStateActions.setPolygonFilterLayer}\n          style={{\n            pointerEvents: isEdit ? 'all' : 'none',\n            position: 'absolute',\n            display: editor.visible ? 'block' : 'none'\n          }}\n        />\n      );\n    }\n\n    _onViewportChange = viewState => {\n      onViewPortChange(\n        viewState,\n        this.props.mapStateActions.updateMap,\n        this.props.onViewStateChange,\n        this.props.primary\n      );\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        MapComponent = MapboxGLMap,\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        mapControls,\n        isExport,\n        locale,\n        uiStateActions,\n        visStateActions,\n        index,\n        primary,\n        bottomMapContainerProps,\n        topMapContainerProps\n      } = this.props;\n\n      const {layers, datasets, editor, interactionConfig, hoverInfo} = 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 mapProps = {\n        ...mapState,\n        width: '100%',\n        height: '100%',\n        preserveDrawingBuffer: true,\n        mapboxApiAccessToken: currentStyle?.accessToken || mapboxApiAccessToken,\n        mapboxApiUrl,\n        onViewportChange: this._onViewportChange,\n        transformRequest\n      };\n\n      const hasGeocoderLayer = Boolean(layers.find(l => l.id === GEOCODER_LAYER_ID));\n      const isSplit = Boolean(mapState.isSplit);\n\n      return (\n        <>\n          <MapControl\n            datasets={datasets}\n            availableLocales={LOCALE_CODES_ARRAY}\n            dragRotate={mapState.dragRotate}\n            isSplit={isSplit}\n            primary={primary}\n            isExport={isExport}\n            layers={layers}\n            layersToRender={layersToRender}\n            mapIndex={index}\n            mapControls={mapControls}\n            readOnly={this.props.readOnly}\n            scale={mapState.scale || 1}\n            top={interactionConfig.geocoder && interactionConfig.geocoder.enabled ? 52 : 0}\n            editor={editor}\n            locale={locale}\n            onTogglePerspective={mapStateActions.togglePerspective}\n            onToggleSplitMap={mapStateActions.toggleSplitMap}\n            onMapToggleLayer={this._handleMapToggleLayer}\n            onToggleMapControl={this._toggleMapControl}\n            onSetEditorMode={visStateActions.setEditorMode}\n            onSetLocale={uiStateActions.setLocale}\n            onToggleEditorVisibility={visStateActions.toggleEditorVisibility}\n            mapHeight={mapState.height}\n          />\n          <MapComponent\n            key=\"bottom\"\n            {...mapProps}\n            mapStyle={mapStyle.bottomMapStyle}\n            {...bottomMapContainerProps}\n            ref={this._setMapboxMap}\n            getCursor={hoverInfo ? () => 'pointer' : undefined}\n            onMouseMove={this.props.visStateActions.onMouseMove}\n          >\n            {this._renderDeckOverlay(layersForDeck, {primaryMap: true})}\n            {this._renderMapboxOverlays()}\n            {this._renderDrawEditor()}\n          </MapComponent>\n          {mapStyle.topMapStyle || hasGeocoderLayer ? (\n            <div style={MAP_STYLE.top}>\n              <MapComponent\n                key=\"top\"\n                {...mapProps}\n                mapStyle={mapStyle.topMapStyle}\n                {...topMapContainerProps}\n              >\n                {this._renderDeckOverlay({[GEOCODER_LAYER_ID]: hasGeocoderLayer})}\n              </MapComponent>\n            </div>\n          ) : null}\n          {this._renderMapPopover()}\n          {!isSplit || index === 1 ? (\n            <Attribution showMapboxLogo={this.state.showMapboxAttribution} />\n          ) : null}\n        </>\n      );\n    }\n\n    render() {\n      const {mapStyle} = this.props;\n      return (\n        <StyledMapContainer ref={this._ref} style={MAP_STYLE.container}>\n          {mapStyle.bottomMapStyle && this._renderMap()}\n        </StyledMapContainer>\n      );\n    }\n  }\n\n  return MapContainer;\n}\n"]}