@kepler.gl/components 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/map-container.js

@@ -0,0 +1,903 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Droppable = exports.Attribution = void 0;
+exports["default"] = MapContainerFactory;
+exports.isSplitSelector = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+var _reactMapGl = require("react-map-gl");
+var _react2 = _interopRequireDefault(require("@deck.gl/react"));
+var _reselect = require("reselect");
+var _core = require("@dnd-kit/core");
+var _lodash = _interopRequireDefault(require("lodash.debounce"));
+var _mapPopover = _interopRequireDefault(require("./map/map-popover"));
+var _mapControl = _interopRequireDefault(require("./map/map-control"));
+var _styledComponents2 = 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 _mapViewStateContext = require("./map-view-state-context");
+var _errorBoundary = _interopRequireDefault(require("./common/error-boundary"));
+var _localization = require("@kepler.gl/localization");
+var _core2 = require("@deck.gl/core");
+var _reducers = require("@kepler.gl/reducers");
+var _templateObject, _templateObject2; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// libraries
+// components
+// utils
+// default-settings
+// Contexts
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+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) { (0, _defineProperty2["default"])(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 = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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; })(); }
+// 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;
+
+/** @type {{[key: string]: React.CSSProperties}} */
+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(_localization.LOCALE_CODES);
+var StyledMap = (0, _styledComponents["default"])(_styledComponents2.StyledMapContainer)(function (_ref) {
+  var _ref$mixBlendMode = _ref.mixBlendMode,
+    mixBlendMode = _ref$mixBlendMode === void 0 ? 'normal' : _ref$mixBlendMode;
+  return "\n  #default-deckgl-overlay {\n    mix-blend-mode: ".concat(mixBlendMode, ";\n  };\n  *[").concat((0, _utils.getApplicationConfig)().mapLibCssClass, "-children] {\n    position: absolute;\n  }\n");
+});
+var MAPBOXGL_STYLE_UPDATE = 'style.load';
+var MAPBOXGL_RENDER = 'render';
+var nop = function nop() {
+  return;
+};
+var MapLibLogo = function MapLibLogo() {
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: "attrition-logo"
+  }, "Basemap by:", /*#__PURE__*/_react["default"].createElement("a", {
+    style: {
+      marginLeft: '5px'
+    },
+    className: "".concat((0, _utils.getApplicationConfig)().mapLibCssClass, "-ctrl-logo"),
+    target: "_blank",
+    rel: "noopener noreferrer",
+    href: (0, _utils.getApplicationConfig)().mapLibUrl,
+    "aria-label": "".concat((0, _utils.getApplicationConfig)().mapLibName, " logo")
+  }));
+};
+var StyledDroppable = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\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 isSplitSelector = exports.isSplitSelector = function isSplitSelector(props) {
+  return props.visState.splitMaps && props.visState.splitMaps.length > 1;
+};
+var Droppable = exports.Droppable = function Droppable(_ref2) {
+  var containerId = _ref2.containerId;
+  var _useDroppable = (0, _core.useDroppable)({
+      id: containerId,
+      data: {
+        type: _constants.DROPPABLE_MAP_CONTAINER_TYPE,
+        index: containerId
+      },
+      disabled: !containerId
+    }),
+    isOver = _useDroppable.isOver,
+    setNodeRef = _useDroppable.setNodeRef;
+  return /*#__PURE__*/_react["default"].createElement(StyledDroppable, {
+    ref: setNodeRef,
+    isOver: isOver
+  });
+};
+var StyledDatasetAttributionsContainer = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  max-width: ", ";\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  color: ", ";\n  margin-right: 2px;\n  line-height: ", ";\n  :hover {\n    white-space: inherit;\n  }\n"])), function (props) {
+  return props.isPalm ? '130px' : '180px';
+}, function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.isPalm ? '1em' : '1.4em';
+});
+var DatasetAttributions = function DatasetAttributions(_ref3) {
+  var datasetAttributions = _ref3.datasetAttributions,
+    isPalm = _ref3.isPalm;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement(StyledDatasetAttributionsContainer, {
+    isPalm: isPalm
+  }, datasetAttributions.map(function (ds, idx) {
+    return /*#__PURE__*/_react["default"].createElement("a", (0, _extends2["default"])({}, ds.url ? {
+      href: ds.url
+    } : null, {
+      target: "_blank",
+      rel: "noopener noreferrer",
+      key: "".concat(ds.title, "_").concat(idx)
+    }), ds.title, idx !== datasetAttributions.length - 1 ? ', ' : null);
+  })) : null);
+};
+var Attribution = exports.Attribution = function Attribution(_ref4) {
+  var _ref4$showMapboxLogo = _ref4.showMapboxLogo,
+    showMapboxLogo = _ref4$showMapboxLogo === void 0 ? true : _ref4$showMapboxLogo,
+    _ref4$showOsmBasemapA = _ref4.showOsmBasemapAttribution,
+    showOsmBasemapAttribution = _ref4$showOsmBasemapA === void 0 ? false : _ref4$showOsmBasemapA,
+    datasetAttributions = _ref4.datasetAttributions;
+  var isPalm = (0, _utils.hasMobileWidth)(_styles.breakPointValues);
+  var memoizedComponents = (0, _react.useMemo)(function () {
+    if (!showMapboxLogo) {
+      return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledAttrbution, null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.EndHorizontalFlexbox, null, /*#__PURE__*/_react["default"].createElement(DatasetAttributions, {
+        datasetAttributions: datasetAttributions,
+        isPalm: isPalm
+      }), showOsmBasemapAttribution ? /*#__PURE__*/_react["default"].createElement("div", {
+        className: "attrition-link"
+      }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, /*#__PURE__*/_react["default"].createElement("a", {
+        href: "http://www.openstreetmap.org/copyright",
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, "\xA9 OpenStreetMap")) : null));
+    }
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledAttrbution, null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.EndHorizontalFlexbox, null, /*#__PURE__*/_react["default"].createElement(DatasetAttributions, {
+      datasetAttributions: datasetAttributions,
+      isPalm: isPalm
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "attrition-link"
+    }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|") : null, isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, null) : null, /*#__PURE__*/_react["default"].createElement("a", {
+      href: "https://kepler.gl/policy/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 kepler.gl |", ' '), !isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, null) : null)));
+  }, [showMapboxLogo, showOsmBasemapAttribution, datasetAttributions, isPalm]);
+  return memoizedComponents;
+};
+MapContainerFactory.deps = [_mapPopover["default"], _mapControl["default"], _editor["default"]];
+function MapContainerFactory(MapPopover, MapControl, Editor) {
+  var MapContainer = /*#__PURE__*/function (_Component) {
+    function MapContainer(_props) {
+      var _this;
+      (0, _classCallCheck2["default"])(this, MapContainer);
+      _this = _callSuper(this, MapContainer, [_props]);
+      (0, _defineProperty2["default"])(_this, "displayName", 'MapContainer');
+      (0, _defineProperty2["default"])(_this, "state", {
+        // Determines whether attribution should be visible based the result of loading the map style
+        showMapboxAttribution: true
+      });
+      (0, _defineProperty2["default"])(_this, "_deck", null);
+      (0, _defineProperty2["default"])(_this, "_map", null);
+      (0, _defineProperty2["default"])(_this, "_ref", /*#__PURE__*/(0, _react.createRef)());
+      (0, _defineProperty2["default"])(_this, "_deckGLErrorsElapsed", {});
+      (0, _defineProperty2["default"])(_this, "previousLayers", {
+        // [layers.id]: mapboxLayerConfig
+      });
+      (0, _defineProperty2["default"])(_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);
+          }
+        }
+      });
+      (0, _defineProperty2["default"])(_this, "layersSelector", function (props) {
+        return props.visState.layers;
+      });
+      (0, _defineProperty2["default"])(_this, "layerDataSelector", function (props) {
+        return props.visState.layerData;
+      });
+      (0, _defineProperty2["default"])(_this, "splitMapSelector", function (props) {
+        return props.visState.splitMaps;
+      });
+      (0, _defineProperty2["default"])(_this, "splitMapIndexSelector", function (props) {
+        return props.index;
+      });
+      (0, _defineProperty2["default"])(_this, "mapLayersSelector", (0, _reselect.createSelector)(_this.splitMapSelector, _this.splitMapIndexSelector, _utils.getMapLayersFromSplitMaps));
+      (0, _defineProperty2["default"])(_this, "layerOrderSelector", function (props) {
+        return props.visState.layerOrder;
+      });
+      (0, _defineProperty2["default"])(_this, "layersToRenderSelector", (0, _reselect.createSelector)(_this.layersSelector, _this.layerDataSelector, _this.mapLayersSelector, _reducers.prepareLayersToRender));
+      (0, _defineProperty2["default"])(_this, "layersForDeckSelector", (0, _reselect.createSelector)(_this.layersSelector, _this.layerDataSelector, _reducers.prepareLayersForDeck));
+      (0, _defineProperty2["default"])(_this, "filtersSelector", function (props) {
+        return props.visState.filters;
+      });
+      (0, _defineProperty2["default"])(_this, "polygonFiltersSelector", (0, _reselect.createSelector)(_this.filtersSelector, function (filters) {
+        return filters.filter(function (f) {
+          return f.type === _constants.FILTER_TYPES.polygon && f.enabled !== false;
+        });
+      }));
+      (0, _defineProperty2["default"])(_this, "featuresSelector", function (props) {
+        return props.visState.editor.features;
+      });
+      (0, _defineProperty2["default"])(_this, "selectedFeatureSelector", function (props) {
+        return props.visState.editor.selectedFeature;
+      });
+      (0, _defineProperty2["default"])(_this, "featureCollectionSelector", (0, _reselect.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
+      (0, _defineProperty2["default"])(_this, "selectedPolygonIndexSelector", (0, _reselect.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);
+        });
+      }));
+      (0, _defineProperty2["default"])(_this, "selectedFeatureIndexArraySelector", (0, _reselect.createSelector)(function (value) {
+        return value;
+      }, function (value) {
+        return value < 0 ? [] : [value];
+      }));
+      (0, _defineProperty2["default"])(_this, "generateMapboxLayerMethodSelector", function (props) {
+        var _props$generateMapbox;
+        return (_props$generateMapbox = props.generateMapboxLayers) !== null && _props$generateMapbox !== void 0 ? _props$generateMapbox : _layers.generateMapboxLayers;
+      });
+      (0, _defineProperty2["default"])(_this, "mapboxLayersSelector", (0, _reselect.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
+      (0, _defineProperty2["default"])(_this, "mapStyleTypeSelector", function (props) {
+        return props.mapStyle.styleType;
+      });
+      (0, _defineProperty2["default"])(_this, "mapStyleBackgroundColorSelector", function (props) {
+        return props.mapStyle.backgroundColor;
+      });
+      (0, _defineProperty2["default"])(_this, "styleSelector", (0, _reselect.createSelector)(_this.mapStyleTypeSelector, _this.mapStyleBackgroundColorSelector, function (styleType, backgroundColor) {
+        return _objectSpread(_objectSpread({}, MAP_STYLE.container), styleType === _constants.NO_MAP_ID ? {
+          backgroundColor: (0, _utils.rgbToHex)(backgroundColor)
+        } : {});
+      }));
+      /* component private functions */
+      (0, _defineProperty2["default"])(_this, "_onCloseMapPopover", function () {
+        _this.props.visStateActions.onLayerClick(null);
+      });
+      (0, _defineProperty2["default"])(_this, "_onLayerHover", function (_idx, info) {
+        _this.props.visStateActions.onLayerHover(info, _this.props.index);
+      });
+      (0, _defineProperty2["default"])(_this, "_onLayerSetDomain", function (idx, colorDomain) {
+        _this.props.visStateActions.layerConfigChange(_this.props.visState.layers[idx], {
+          colorDomain: colorDomain.domain
+        });
+      });
+      (0, _defineProperty2["default"])(_this, "_onLayerFilteredItemsChange", function (idx, event) {
+        _this.props.visStateActions.layerFilteredItemsChange(_this.props.visState.layers[idx], event);
+      });
+      (0, _defineProperty2["default"])(_this, "_handleMapToggleLayer", function (layerId) {
+        var _this$props2 = _this.props,
+          _this$props2$index = _this$props2.index,
+          mapIndex = _this$props2$index === void 0 ? 0 : _this$props2$index,
+          visStateActions = _this$props2.visStateActions;
+        visStateActions.toggleLayerForMap(mapIndex, layerId);
+      });
+      (0, _defineProperty2["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"])(_this, "_setMapRef", function (mapRef) {
+        if (!_this._map && mapRef) {
+          _this._map = (0, _utils.getApplicationConfig)().getMap(mapRef);
+          // 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(mapRef, _this.props.index);
+        }
+      });
+      (0, _defineProperty2["default"])(_this, "_onBeforeRender", function (_ref5) {
+        var gl = _ref5.gl;
+        (0, _utils.setLayerBlending)(gl, _this.props.visState.layerBlending);
+      });
+      (0, _defineProperty2["default"])(_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() - _constants.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((0, _utils.errorNotification)({
+            message: "".concat(errorMessageFull, " ").concat(extraLayerMessage),
+            id: errorMessageFull // treat the error message as id
+          }));
+        }
+      });
+      (0, _defineProperty2["default"])(_this, "_onViewportChangePropagateDebounced", (0, _lodash["default"])(function () {
+        var _this$context;
+        var viewState = (_this$context = _this.context) === null || _this$context === void 0 ? void 0 : _this$context.getInternalViewState(_this.props.index);
+        (0, _utils.onViewPortChange)(viewState, _this.props.mapStateActions.updateMap, _this.props.onViewStateChange, _this.props.primary, _this.props.index);
+      }, DEBOUNCE_VIEWPORT_PROPAGATE));
+      (0, _defineProperty2["default"])(_this, "_onViewportChange", function (viewport) {
+        var viewState = viewport.viewState;
+        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;
+        setInternalViewState(viewState, _this.props.index);
+        _this._onViewportChangePropagateDebounced();
+      });
+      (0, _defineProperty2["default"])(_this, "_onLayerHoverDebounced", (0, _lodash["default"])(function (data, index) {
+        _this.props.visStateActions.onLayerHover(data, index);
+      }, DEBOUNCE_MOUSE_MOVE_PROPAGATE));
+      (0, _defineProperty2["default"])(_this, "_onMouseMoveDebounced", (0, _lodash["default"])(function (event, viewport) {
+        _this.props.visStateActions.onMouseMove((0, _utils.normalizeEvent)(event, viewport));
+      }, DEBOUNCE_MOUSE_MOVE_PROPAGATE));
+      (0, _defineProperty2["default"])(_this, "_toggleMapControl", function (panelId) {
+        var _this$props3 = _this.props,
+          index = _this$props3.index,
+          uiStateActions = _this$props3.uiStateActions;
+        uiStateActions.toggleMapControl(panelId, Number(index));
+      });
+      return _this;
+    }
+    (0, _inherits2["default"])(MapContainer, _Component);
+    return (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 || _this$_map.off(MAPBOXGL_STYLE_UPDATE, nop);
+          (_this$_map2 = this._map) === null || _this$_map2 === 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);
+        }
+      }
+
+      /**
+       * 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: "_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$props4 = this.props,
+          mapState = _this$props4.mapState,
+          _this$props4$visState = _this$props4.visState,
+          hoverInfo = _this$props4$visState.hoverInfo,
+          clicked = _this$props4$visState.clicked,
+          datasets = _this$props4$visState.datasets,
+          interactionConfig = _this$props4$visState.interactionConfig,
+          animationConfig = _this$props4$visState.animationConfig,
+          layers = _this$props4$visState.layers,
+          _this$props4$visState2 = _this$props4$visState.mousePos,
+          mousePosition = _this$props4$visState2.mousePosition,
+          coordinate = _this$props4$visState2.coordinate,
+          pinned = _this$props4$visState2.pinned;
+        var layersToRender = this.layersToRenderSelector(this.props);
+        if (!mousePosition || !interactionConfig.tooltip) {
+          return null;
+        }
+        var layerHoverProp = (0, _reducers.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 = (0, _utils.getViewportFromMapState)(mapState);
+          var lngLat = clicked ? clicked.coordinate : pinned.coordinate;
+          pinnedPosition = this._getHoverXY(viewport, lngLat);
+          layerPinnedProp = (0, _reducers.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["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,
+          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["default"].createElement(MapPopover, (0, _extends2["default"])({
+          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,
+          _this2 = this;
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+          primaryMap: false
+        };
+        var _this$props5 = this.props,
+          mapStyle = _this$props5.mapStyle,
+          visState = _this$props5.visState,
+          mapState = _this$props5.mapState,
+          visStateActions = _this$props5.visStateActions,
+          mapboxApiAccessToken = _this$props5.mapboxApiAccessToken,
+          mapboxApiUrl = _this$props5.mapboxApiUrl,
+          deckGlProps = _this$props5.deckGlProps,
+          index = _this$props5.index,
+          mapControls = _this$props5.mapControls,
+          deckRenderCallbacks = _this$props5.deckRenderCallbacks,
+          theme = _this$props5.theme,
+          generateDeckGLLayers = _this$props5.generateDeckGLLayers,
+          onMouseMove = _this$props5.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 _ref6 = mapDraw || {},
+          _ref6$active = _ref6.active,
+          editorMenuActive = _ref6$active === void 0 ? false : _ref6$active;
+        var isEditorDrawingMode = _layers.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 = (0, _utils.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 : _reducers.computeDeckLayers;
+        var deckGlLayers = generateDeckGLLayersMethod({
+          visState: visState,
+          mapState: internalMapState,
+          mapStyle: mapStyle
+        }, {
+          mapIndex: index,
+          primaryMap: primaryMap,
+          mapboxApiAccessToken: mapboxApiAccessToken,
+          mapboxApiUrl: mapboxApiUrl,
+          layersForDeck: layersForDeck,
+          editorInfo: primaryMap ? {
+            editor: editor,
+            editorMenuActive: editorMenuActive,
+            onSetFeatures: setFeatures,
+            setSelectedFeature: setSelectedFeature,
+            // @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
+        }, deckGlProps);
+        var extraDeckParams = {};
+        if (primaryMap) {
+          extraDeckParams.getTooltip = function (info) {
+            return _layers.EditorLayerUtils.getTooltip(info, {
+              editorMenuActive: editorMenuActive,
+              editor: editor,
+              theme: theme
+            });
+          };
+          extraDeckParams.getCursor = function (_ref7) {
+            var isDragging = _ref7.isDragging;
+            var editorCursor = _layers.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) ? (0, _utils.computeDeckEffects)({
+          visState: visState,
+          mapState: mapState
+        }) : [];
+        var views = deckGlProps !== null && deckGlProps !== void 0 && deckGlProps.views ? deckGlProps === null || deckGlProps === void 0 ? void 0 : deckGlProps.views() : new _core2.MapView({
+          legacyMeterSizes: true
+        });
+        var allDeckGlProps = _objectSpread(_objectSpread({}, deckGlProps), {}, {
+          pickingRadius: _constants.DEFAULT_PICKING_RADIUS,
+          views: views,
+          layers: deckGlLayers,
+          effects: effects
+        });
+        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["default"].createElement("div", isInteractive ? {
+          onMouseMove: primaryMap ? function (event) {
+            onMouseMove === null || onMouseMove === void 0 || onMouseMove(event);
+            _this2._onMouseMoveDebounced(event, viewport);
+          } : undefined
+        } : {
+          style: {
+            pointerEvents: 'none'
+          }
+        }, /*#__PURE__*/_react["default"].createElement(_react2["default"], (0, _extends2["default"])({
+          id: "default-deckgl-overlay",
+          onLoad: function onLoad() {
+            if (typeof (deckRenderCallbacks === null || deckRenderCallbacks === void 0 ? void 0 : deckRenderCallbacks.onDeckLoad) === 'function') {
+              deckRenderCallbacks.onDeckLoad();
+            }
+          }
+        }, allDeckGlProps, {
+          controller: isInteractive ? {
+            doubleClickZoom: !isEditorDrawingMode,
+            dragRotate: this.props.mapState.dragRotate
+          } : false,
+          initialViewState: internalViewState,
+          onBeforeRender: this._onBeforeRender,
+          onViewStateChange: isInteractive ? this._onViewportChange : undefined
+        }, extraDeckParams, {
+          onHover: isInteractive ? function (data) {
+            var res = _layers.EditorLayerUtils.onHover(data, {
+              editorMenuActive: editorMenuActive,
+              editor: editor,
+              hoverInfo: hoverInfo
+            });
+            if (res) return;
+            _this2._onLayerHoverDebounced(data, index);
+          } : null,
+          onClick: function onClick(data, event) {
+            // @ts-ignore
+            (0, _utils.normalizeEvent)(event.srcEvent, viewport);
+            var res = _layers.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;
+            }
+          },
+          onWebGLInitialized: function onWebGLInitialized(gl) {
+            return _this2._onDeckInitialized(gl);
+          },
+          onAfterRender: function onAfterRender() {
+            if (typeof (deckRenderCallbacks === null || deckRenderCallbacks === void 0 ? void 0 : deckRenderCallbacks.onDeckAfterRender) === 'function') {
+              deckRenderCallbacks.onDeckAfterRender(allDeckGlProps);
+            }
+          }
+        }), children));
+      }
+    }, {
+      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: "_renderMap",
+      value: /* eslint-disable complexity */
+      function _renderMap() {
+        var _mapStyle$mapStyles, _this$context3, _mapStyle$bottomMapSt;
+        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.Map : _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,
+          theme = _this$props6.theme,
+          _this$props6$datasetA = _this$props6.datasetAttributions,
+          datasetAttributions = _this$props6$datasetA === void 0 ? [] : _this$props6$datasetA,
+          _this$props6$containe = _this$props6.containerId,
+          containerId = _this$props6$containe === void 0 ? 0 : _this$props6$containe;
+        var layers = visState.layers,
+          datasets = visState.datasets,
+          editor = visState.editor,
+          interactionConfig = visState.interactionConfig;
+        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 internalViewState = (_this$context3 = this.context) === null || _this$context3 === void 0 ? void 0 : _this$context3.getInternalViewState(index);
+        var mapProps = _objectSpread(_objectSpread({}, internalViewState), {}, {
+          preserveDrawingBuffer: true,
+          mapboxAccessToken: (currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.accessToken) || mapboxApiAccessToken,
+          baseApiUrl: mapboxApiUrl,
+          mapLib: (0, _utils.getApplicationConfig)().getMapLib(),
+          transformRequest: this.props.transformRequest || (0, _utils.transformRequest)((currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.accessToken) || mapboxApiAccessToken)
+        });
+        var hasGeocoderLayer = Boolean(layers.find(function (l) {
+          return l.id === _constants.GEOCODER_LAYER_ID;
+        }));
+        var isSplit = Boolean(mapState.isSplit);
+        var deck = this._renderDeckOverlay(layersForDeck, {
+          primaryMap: true,
+          isInteractive: true,
+          children: /*#__PURE__*/_react["default"].createElement(MapComponent, (0, _extends2["default"])({
+            key: "bottom"
+          }, mapProps, {
+            mapStyle: (_mapStyle$bottomMapSt = mapStyle.bottomMapStyle) !== null && _mapStyle$bottomMapSt !== void 0 ? _mapStyle$bottomMapSt : _constants.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;
+        }
+        return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(MapControl, {
+          mapState: mapState,
+          datasets: datasets,
+          availableLocales: LOCALE_CODES_ARRAY,
+          dragRotate: mapState.dragRotate,
+          isSplit: isSplit,
+          primary: Boolean(primary),
+          isExport: isExport,
+          layers: layers,
+          layersToRender: layersToRender,
+          mapIndex: index || 0,
+          mapControls: mapControls,
+          readOnly: this.props.readOnly,
+          scale: mapState.scale || 1,
+          top: interactionConfig.geocoder && interactionConfig.geocoder.enabled ? theme.mapControlTop : 0,
+          editor: editor,
+          locale: locale,
+          onTogglePerspective: mapStateActions.togglePerspective,
+          onToggleSplitMap: mapStateActions.toggleSplitMap,
+          onMapToggleLayer: this._handleMapToggleLayer,
+          onToggleMapControl: this._toggleMapControl,
+          onToggleSplitMapViewport: mapStateActions.toggleSplitMapViewport,
+          onSetEditorMode: visStateActions.setEditorMode,
+          onSetLocale: uiStateActions.setLocale,
+          onToggleEditorVisibility: visStateActions.toggleEditorVisibility,
+          onLayerVisConfigChange: visStateActions.layerVisConfigChange,
+          mapHeight: mapState.height
+        }), isSplitSelector(this.props) && /*#__PURE__*/_react["default"].createElement(Droppable, {
+          containerId: containerId
+        }), deck, this._renderMapboxOverlays(), /*#__PURE__*/_react["default"].createElement(Editor, {
+          index: index || 0,
+          datasets: datasets,
+          editor: editor,
+          filters: this.polygonFiltersSelector(this.props),
+          layers: layers,
+          onDeleteFeature: visStateActions.deleteFeature,
+          onSelect: visStateActions.setSelectedFeature,
+          onTogglePolygonFilter: visStateActions.setPolygonFilterLayer,
+          onSetEditorMode: visStateActions.setEditorMode,
+          style: {
+            pointerEvents: 'all',
+            position: 'absolute',
+            display: editor.visible ? 'block' : 'none'
+          }
+        }), this.props.children, mapStyle.topMapStyle ? /*#__PURE__*/_react["default"].createElement(MapComponent, (0, _extends2["default"])({
+          key: "top",
+          viewState: internalViewState,
+          mapStyle: mapStyle.topMapStyle,
+          style: MAP_STYLE.top,
+          mapboxAccessToken: mapProps.mapboxAccessToken,
+          baseApiUrl: mapProps.baseApiUrl,
+          mapLib: (0, _utils.getApplicationConfig)().getMapLib()
+        }, topMapContainerProps)) : null, hasGeocoderLayer ? this._renderDeckOverlay((0, _defineProperty2["default"])({}, _constants.GEOCODER_LAYER_ID, hasGeocoderLayer), {
+          primaryMap: false,
+          isInteractive: false
+        }) : null, this._renderMapPopover(), this.props.primary ? /*#__PURE__*/_react["default"].createElement(Attribution, {
+          showMapboxLogo: this.state.showMapboxAttribution,
+          showOsmBasemapAttribution: true,
+          datasetAttributions: datasetAttributions
+        }) : null);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var visState = this.props.visState;
+        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;
+        }
+        return /*#__PURE__*/_react["default"].createElement(StyledMap, {
+          ref: this._ref,
+          style: this.styleSelector(this.props),
+          onContextMenu: function onContextMenu(event) {
+            return event.preventDefault();
+          },
+          mixBlendMode: visState.overlayBlending
+        }, mapContent);
+      }
+    }]);
+  }(_react.Component);
+  (0, _defineProperty2["default"])(MapContainer, "contextType", _mapViewStateContext.MapViewStateContext);
+  (0, _defineProperty2["default"])(MapContainer, "defaultProps", {
+    MapComponent: _reactMapGl.Map,
+    deckGlProps: {},
+    index: 0,
+    primary: true
+  });
+  return (0, _styledComponents.withTheme)(MapContainer);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_reactMapGl","_react2","_interopRequireDefault","_reselect","_core","_lodash","_mapPopover","_mapControl","_styledComponents2","_editor","_layers","_utils","_styles","_constants","_mapViewStateContext","_errorBoundary","_localization","_core2","_reducers","_templateObject","_templateObject2","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ownKeys","keys","getOwnPropertySymbols","o","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","_callSuper","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","Boolean","prototype","valueOf","DEBOUNCE_VIEWPORT_PROPAGATE","DEBOUNCE_MOUSE_MOVE_PROPAGATE","MAP_STYLE","container","display","position","width","height","top","pointerEvents","LOCALE_CODES_ARRAY","LOCALE_CODES","StyledMap","styled","StyledMapContainer","_ref","_ref$mixBlendMode","mixBlendMode","concat","getApplicationConfig","mapLibCssClass","MAPBOXGL_STYLE_UPDATE","MAPBOXGL_RENDER","nop","MapLibLogo","createElement","className","style","marginLeft","target","rel","href","mapLibUrl","mapLibName","StyledDroppable","div","_taggedTemplateLiteral2","props","isOver","theme","dndOverBackgroundColor","isSplitSelector","exports","visState","splitMaps","Droppable","_ref2","containerId","_useDroppable","useDroppable","id","data","type","DROPPABLE_MAP_CONTAINER_TYPE","index","disabled","setNodeRef","ref","StyledDatasetAttributionsContainer","isPalm","labelColor","DatasetAttributions","_ref3","datasetAttributions","Fragment","map","ds","idx","_extends2","url","key","title","Attribution","_ref4","_ref4$showMapboxLogo","showMapboxLogo","_ref4$showOsmBasemapA","showOsmBasemapAttribution","hasMobileWidth","breakPointValues","memoizedComponents","useMemo","StyledAttrbution","EndHorizontalFlexbox","MapContainerFactory","deps","MapPopoverFactory","MapControlFactory","EditorFactory","MapPopover","MapControl","Editor","MapContainer","_Component","_this","_classCallCheck2","showMapboxAttribution","createRef","dimensions","_this$props","primary","mapStateActions","updateMap","layers","layerData","createSelector","splitMapSelector","splitMapIndexSelector","getMapLayersFromSplitMaps","layerOrder","layersSelector","layerDataSelector","mapLayersSelector","prepareLayersToRender","prepareLayersForDeck","filters","filtersSelector","f","FILTER_TYPES","polygon","enabled","editor","features","selectedFeature","polygonFiltersSelector","featuresSelector","polygonFilters","value","featureCollectionSelector","selectedFeatureSelector","collection","findIndex","_props$generateMapbox","generateMapboxLayers","layerOrderSelector","layersToRenderSelector","generateMapboxLayerMethodSelector","layer","layersToRender","generateMapboxLayerMethod","mapStyle","styleType","backgroundColor","mapStyleTypeSelector","mapStyleBackgroundColorSelector","NO_MAP_ID","rgbToHex","visStateActions","onLayerClick","_idx","info","onLayerHover","colorDomain","layerConfigChange","domain","event","layerFilteredItemsChange","layerId","_this$props2","_this$props2$index","mapIndex","toggleLayerForMap","update","previousLayers","_updateMapboxLayers","setState","isStyleUsingMapboxTiles","onMapStyleLoaded","_map","mapRef","getMap","on","_onMapboxStyleUpdate","onMapRender","getMapboxRef","_ref5","gl","setLayerBlending","layerBlending","error","errorMessage","message","layerMessage","errorMessageFull","lastShown","_deckGLErrorsElapsed","Date","now","THROTTLE_NOTIFICATION_TIME","extraLayerMessage","_topMostLayer$props","topMostLayer","parent","layerSetIsValid","uiStateActions","addNotification","errorNotification","debounce","_this$context","viewState","context","getInternalViewState","onViewPortChange","onViewStateChange","viewport","isExport","setInternalViewState","_onViewportChangePropagateDebounced","onMouseMove","normalizeEvent","panelId","_this$props3","toggleMapControl","Number","_inherits2","_createClass2","componentDidMount","current","observeDimensions","_handleResize","componentWillUnmount","_this$_map","_this$_map2","off","unobserveDimensions","_onDeckInitialized","onDeckInitialized","_deck","_isOKToRenderEffects","viewIndex","_this$_deck","viewManager","_viewports","_renderMapPopover","_this$props$visState$","hoverInfo","_this$props4","mapState","_this$props4$visState","clicked","datasets","interactionConfig","animationConfig","_this$props4$visState2","mousePos","mousePosition","coordinate","pinned","tooltip","layerHoverProp","getLayerHoverProp","compareMode","config","pinnedPosition","x","y","layerPinnedProp","getViewportFromMapState","lngLat","_getHoverXY","primaryData","compareType","commonProp","onClose","_onCloseMapPopover","zoom","canvas","undefined","frozen","isBase","onSetFeatures","setFeatures","setSelectedFeature","featureCollection","screenCoord","project","_renderDeckOverlay","layersForDeck","_this$context2","_this2","options","primaryMap","_this$props5","mapboxApiAccessToken","mapboxApiUrl","deckGlProps","mapControls","deckRenderCallbacks","generateDeckGLLayers","isInteractive","children","mapDraw","_ref6","_ref6$active","active","editorMenuActive","isEditorDrawingMode","EditorLayerUtils","isDrawingActive","mode","internalViewState","internalMapState","editorFeatureSelectedIndex","selectedPolygonIndexSelector","generateDeckGLLayersMethod","computeDeckLayers","deckGlLayers","editorInfo","selectedFeatureIndexes","selectedFeatureIndexArraySelector","_onLayerHover","onSetLayerDomain","_onLayerSetDomain","onFilteredItemsChange","_onLayerFilteredItemsChange","extraDeckParams","getTooltip","getCursor","_ref7","isDragging","editorCursor","effects","computeDeckEffects","views","MapView","legacyMeterSizes","allDeckGlProps","pickingRadius","DEFAULT_PICKING_RADIUS","onDeckRender","_onMouseMoveDebounced","onLoad","onDeckLoad","controller","doubleClickZoom","dragRotate","initialViewState","onBeforeRender","_onBeforeRender","_onViewportChange","onHover","res","_onLayerHoverDebounced","onClick","srcEvent","onError","_onDeckError","comp","deck","onWebGLInitialized","onAfterRender","onDeckAfterRender","mapboxLayers","mapboxLayersSelector","updateMapboxLayers","_renderMapboxOverlays","isStyleLoaded","_renderMap","_mapStyle$mapStyles","_this$context3","_mapStyle$bottomMapSt","_this$props6","_this$props6$MapCompo","MapComponent","Map","locale","bottomMapContainerProps","topMapContainerProps","_this$props6$datasetA","_this$props6$containe","layersForDeckSelector","currentStyle","mapStyles","mapProps","preserveDrawingBuffer","mapboxAccessToken","accessToken","baseApiUrl","mapLib","getMapLib","transformRequest","hasGeocoderLayer","find","l","GEOCODER_LAYER_ID","isSplit","bottomMapStyle","EMPTY_MAPBOX_STYLE","_setMapRef","availableLocales","readOnly","scale","geocoder","mapControlTop","onTogglePerspective","togglePerspective","onToggleSplitMap","toggleSplitMap","onMapToggleLayer","_handleMapToggleLayer","onToggleMapControl","_toggleMapControl","onToggleSplitMapViewport","toggleSplitMapViewport","onSetEditorMode","setEditorMode","onSetLocale","setLocale","onToggleEditorVisibility","toggleEditorVisibility","onLayerVisConfigChange","layerVisConfigChange","mapHeight","onDeleteFeature","deleteFeature","onSelect","onTogglePolygonFilter","setPolygonFilterLayer","visible","topMapStyle","state","render","mapContent","styleSelector","onContextMenu","preventDefault","overlayBlending","Component","MapViewStateContext","withTheme"],"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, useMemo} from 'react';\nimport styled, {withTheme} from 'styled-components';\nimport {Map, MapRef} from 'react-map-gl';\nimport {PickInfo} from '@deck.gl/core/lib/deck';\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 {\n  StyledMapContainer,\n  StyledAttrbution,\n  EndHorizontalFlexbox\n} from './common/styled-components';\n\nimport EditorFactory from './editor/editor';\n\n// utils\nimport {\n  generateMapboxLayers,\n  updateMapboxLayers,\n  LayerBaseConfig,\n  VisualChannelDomain,\n  EditorLayerUtils\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  getViewportFromMapState,\n  normalizeEvent,\n  rgbToHex,\n  computeDeckEffects,\n  getApplicationConfig\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  DEFAULT_PICKING_RADIUS,\n  NO_MAP_ID,\n  EMPTY_MAPBOX_STYLE,\n  DROPPABLE_MAP_CONTAINER_TYPE\n} from '@kepler.gl/constants';\n\n// Contexts\nimport {MapViewStateContext} from './map-view-state-context';\n\nimport ErrorBoundary from './common/error-boundary';\nimport {DatasetAttribution} from './types';\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// 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/** @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: 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}\n\nconst StyledMap = styled(StyledMapContainer)<StyledMapContainerProps>(\n  ({mixBlendMode = 'normal'}) => `\n  #default-deckgl-overlay {\n    mix-blend-mode: ${mixBlendMode};\n  };\n  *[${getApplicationConfig().mapLibCssClass}-children] {\n    position: absolute;\n  }\n`\n);\n\nconst MAPBOXGL_STYLE_UPDATE = 'style.load';\nconst MAPBOXGL_RENDER = 'render';\nconst nop = () => {\n  return;\n};\n\nconst MapLibLogo = () => (\n  <div className=\"attrition-logo\">\n    Basemap by:\n    <a\n      style={{marginLeft: '5px'}}\n      className={`${getApplicationConfig().mapLibCssClass}-ctrl-logo`}\n      target=\"_blank\"\n      rel=\"noopener noreferrer\"\n      href={getApplicationConfig().mapLibUrl}\n      aria-label={`${getApplicationConfig().mapLibName} logo`}\n    />\n  </div>\n);\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\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\ninterface StyledDatasetAttributionsContainerProps {\n  isPalm: boolean;\n}\n\nconst StyledDatasetAttributionsContainer = styled.div<StyledDatasetAttributionsContainerProps>`\n  max-width: ${props => (props.isPalm ? '130px' : '180px')};\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  color: ${props => props.theme.labelColor};\n  margin-right: 2px;\n  line-height: ${props => (props.isPalm ? '1em' : '1.4em')};\n  :hover {\n    white-space: inherit;\n  }\n`;\n\nconst DatasetAttributions = ({\n  datasetAttributions,\n  isPalm\n}: {\n  datasetAttributions: DatasetAttribution[];\n  isPalm: boolean;\n}) => (\n  <>\n    {datasetAttributions?.length ? (\n      <StyledDatasetAttributionsContainer isPalm={isPalm}>\n        {datasetAttributions.map((ds, idx) => (\n          <a\n            {...(ds.url ? {href: ds.url} : null)}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n            key={`${ds.title}_${idx}`}\n          >\n            {ds.title}\n            {idx !== datasetAttributions.length - 1 ? ', ' : null}\n          </a>\n        ))}\n      </StyledDatasetAttributionsContainer>\n    ) : null}\n  </>\n);\n\nexport const Attribution: React.FC<{\n  showMapboxLogo: boolean;\n  showOsmBasemapAttribution: boolean;\n  datasetAttributions: DatasetAttribution[];\n}> = ({showMapboxLogo = true, showOsmBasemapAttribution = false, datasetAttributions}) => {\n  const isPalm = hasMobileWidth(breakPointValues);\n\n  const memoizedComponents = useMemo(() => {\n    if (!showMapboxLogo) {\n      return (\n        <StyledAttrbution>\n          <EndHorizontalFlexbox>\n            <DatasetAttributions datasetAttributions={datasetAttributions} isPalm={isPalm} />\n            {showOsmBasemapAttribution ? (\n              <div className=\"attrition-link\">\n                {datasetAttributions?.length ? <span className=\"pipe-separator\">|</span> : null}\n                <a\n                  href=\"http://www.openstreetmap.org/copyright\"\n                  target=\"_blank\"\n                  rel=\"noopener noreferrer\"\n                >\n                  © OpenStreetMap\n                </a>\n              </div>\n            ) : null}\n          </EndHorizontalFlexbox>\n        </StyledAttrbution>\n      );\n    }\n\n    return (\n      <StyledAttrbution>\n        <EndHorizontalFlexbox>\n          <DatasetAttributions datasetAttributions={datasetAttributions} isPalm={isPalm} />\n          <div className=\"attrition-link\">\n            {datasetAttributions?.length ? <span className=\"pipe-separator\">|</span> : null}\n            {isPalm ? <MapLibLogo /> : null}\n            <a href=\"https://kepler.gl/policy/\" target=\"_blank\" rel=\"noopener noreferrer\">\n              © kepler.gl |{' '}\n            </a>\n            {!isPalm ? <MapLibLogo /> : null}\n          </div>\n        </EndHorizontalFlexbox>\n      </StyledAttrbution>\n    );\n  }, [showMapboxLogo, showOsmBasemapAttribution, datasetAttributions, 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\ntype GetMapRef = ReturnType<ReturnType<typeof getApplicationConfig>['getMap']>;\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  locale?: any;\n  theme?: any;\n  editor?: any;\n  MapComponent?: typeof Map;\n  deckGlProps?: any;\n  onDeckInitialized?: (a: any, b: any) => void;\n  onViewStateChange?: (viewport: Viewport) => void;\n\n  topMapContainerProps: any;\n  bottomMapContainerProps: any;\n  transformRequest?: any;\n\n  datasetAttributions?: DatasetAttribution[];\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\nexport default function MapContainerFactory(\n  MapPopover: ReturnType<typeof MapPopoverFactory>,\n  MapControl: ReturnType<typeof MapControlFactory>,\n  Editor: ReturnType<typeof EditorFactory>\n): React.ComponentType<MapContainerProps> {\n  class MapContainer extends Component<MapContainerProps> {\n    displayName = 'MapContainer';\n\n    static contextType = MapViewStateContext;\n\n    declare context: React.ContextType<typeof MapViewStateContext>;\n\n    static defaultProps = {\n      MapComponent: Map,\n      deckGlProps: {},\n      index: 0,\n      primary: true\n    };\n\n    constructor(props) {\n      super(props);\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    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: GetMapRef | 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, 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    styleSelector = createSelector(\n      this.mapStyleTypeSelector,\n      this.mapStyleBackgroundColorSelector,\n      (styleType, backgroundColor) => ({\n        ...MAP_STYLE.container,\n        ...(styleType === NO_MAP_ID ? {backgroundColor: rgbToHex(backgroundColor)} : {})\n      })\n    );\n\n    /* component private functions */\n    _onCloseMapPopover = () => {\n      this.props.visStateActions.onLayerClick(null);\n    };\n\n    _onLayerHover = (_idx: number, info: PickInfo<any> | null) => {\n      this.props.visStateActions.onLayerHover(info, this.props.index);\n    };\n\n    _onLayerSetDomain = (idx: number, colorDomain: {domain: VisualChannelDomain}) => {\n      this.props.visStateActions.layerConfigChange(this.props.visState.layers[idx], {\n        colorDomain: colorDomain.domain\n      } as Partial<LayerBaseConfig>);\n    };\n\n    _onLayerFilteredItemsChange = (idx, event) => {\n      this.props.visStateActions.layerFilteredItemsChange(this.props.visState.layers[idx], event);\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    _setMapRef = mapRef => {\n      if (!this._map && mapRef) {\n        this._map = getApplicationConfig().getMap(mapRef);\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(mapRef, 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    /**\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 = ({gl}) => {\n      setLayerBlending(gl, this.props.visState.layerBlending);\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      const deckGlLayers = generateDeckGLLayersMethod(\n        {\n          visState,\n          mapState: internalMapState,\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                // @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        },\n        deckGlProps\n      );\n\n      const extraDeckParams: {\n        getTooltip?: (info: any) => object | null;\n        getCursor?: ({isDragging}: {isDragging: boolean}) => string;\n      } = {};\n      if (primaryMap) {\n        extraDeckParams.getTooltip = info =>\n          EditorLayerUtils.getTooltip(info, {\n            editorMenuActive,\n            editor,\n            theme\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})\n        : [];\n\n      const views = deckGlProps?.views\n        ? deckGlProps?.views()\n        : new MapView({legacyMeterSizes: true});\n\n      let allDeckGlProps = {\n        ...deckGlProps,\n        pickingRadius: DEFAULT_PICKING_RADIUS,\n        views,\n        layers: deckGlLayers,\n        effects\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                  }\n                : false\n            }\n            initialViewState={internalViewState}\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              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            onWebGLInitialized={gl => this._onDeckInitialized(gl)}\n            onAfterRender={() => {\n              if (typeof deckRenderCallbacks?.onDeckAfterRender === 'function') {\n                deckRenderCallbacks.onDeckAfterRender(allDeckGlProps);\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} = 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      setInternalViewState(viewState, this.props.index);\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    _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 = Map,\n        mapboxApiAccessToken,\n        mapboxApiUrl,\n        mapControls,\n        isExport,\n        locale,\n        uiStateActions,\n        visStateActions,\n        index,\n        primary,\n        bottomMapContainerProps,\n        topMapContainerProps,\n        theme,\n        datasetAttributions = [],\n        containerId = 0\n      } = this.props;\n\n      const {layers, datasets, editor, interactionConfig} = 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 internalViewState = this.context?.getInternalViewState(index);\n      const mapProps = {\n        ...internalViewState,\n        preserveDrawingBuffer: true,\n        mapboxAccessToken: currentStyle?.accessToken || mapboxApiAccessToken,\n        baseApiUrl: mapboxApiUrl,\n        mapLib: getApplicationConfig().getMapLib(),\n        transformRequest:\n          this.props.transformRequest ||\n          transformRequest(currentStyle?.accessToken || mapboxApiAccessToken)\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          <MapComponent\n            key=\"bottom\"\n            {...mapProps}\n            mapStyle={mapStyle.bottomMapStyle ?? EMPTY_MAPBOX_STYLE}\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      return (\n        <>\n          <MapControl\n            mapState={mapState}\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            layersToRender={layersToRender}\n            mapIndex={index || 0}\n            mapControls={mapControls}\n            readOnly={this.props.readOnly}\n            scale={mapState.scale || 1}\n            top={\n              interactionConfig.geocoder && interactionConfig.geocoder.enabled\n                ? theme.mapControlTop\n                : 0\n            }\n            editor={editor}\n            locale={locale}\n            onTogglePerspective={mapStateActions.togglePerspective}\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            onToggleEditorVisibility={visStateActions.toggleEditorVisibility}\n            onLayerVisConfigChange={visStateActions.layerVisConfigChange}\n            mapHeight={mapState.height}\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            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          {this.props.children}\n          {mapStyle.topMapStyle ? (\n            <MapComponent\n              key=\"top\"\n              viewState={internalViewState}\n              mapStyle={mapStyle.topMapStyle}\n              style={MAP_STYLE.top}\n              mapboxAccessToken={mapProps.mapboxAccessToken}\n              baseApiUrl={mapProps.baseApiUrl}\n              mapLib={getApplicationConfig().getMapLib()}\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          {this.props.primary ? (\n            <Attribution\n              showMapboxLogo={this.state.showMapboxAttribution}\n              showOsmBasemapAttribution={true}\n              datasetAttributions={datasetAttributions}\n            />\n          ) : null}\n        </>\n      );\n    }\n\n    render() {\n      const {visState} = 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      return (\n        <StyledMap\n          ref={this._ref}\n          style={this.styleSelector(this.props)}\n          onContextMenu={event => event.preventDefault()}\n          mixBlendMode={visState.overlayBlending}\n        >\n          {mapContent}\n        </StyledMap>\n      );\n    }\n  }\n\n  return withTheme(MapContainer);\n}\n"],"mappings":"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","ignoreList":[]}