@kepler.gl/components 3.0.0-alpha.0

package/dist/notification-panel.js

@@ -0,0 +1,106 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = NotificationPanelFactory;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _notificationItem = _interopRequireDefault(require("./notification-panel/notification-item"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _templateObject;
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var NotificationPanelContent = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  background: transparent;\n  display: flex;\n  flex-direction: column;\n  align-items: flex-end;\n  padding: 4px;\n  overflow-y: auto;\n  overflow-x: hidden;\n  position: absolute;\n  top: 1em;\n  right: 1em;\n  z-index: 10000;\n  box-sizing: border-box;\n"])));
+
+NotificationPanelFactory.deps = [_notificationItem["default"]];
+
+function NotificationPanelFactory(NotificationItem) {
+  var NotificationPanelUnmemoized = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(NotificationPanelUnmemoized, _Component);
+
+    var _super = _createSuper(NotificationPanelUnmemoized);
+
+    function NotificationPanelUnmemoized() {
+      (0, _classCallCheck2["default"])(this, NotificationPanelUnmemoized);
+      return _super.apply(this, arguments);
+    }
+
+    (0, _createClass2["default"])(NotificationPanelUnmemoized, [{
+      key: "render",
+      value: function render() {
+        var _this = this;
+
+        var globalNotifications = this.props.notifications.filter(function (n) {
+          return n.topic === _constants.DEFAULT_NOTIFICATION_TOPICS.global;
+        });
+        return /*#__PURE__*/_react["default"].createElement(NotificationPanelContent, {
+          className: "notification-panel",
+          style: {
+            display: globalNotifications.length ? 'block' : 'none'
+          }
+        }, globalNotifications.map(function (n) {
+          return /*#__PURE__*/_react["default"].createElement(NotificationItem, {
+            key: n.id,
+            notification: n,
+            removeNotification: _this.props.removeNotification
+          });
+        }));
+      }
+    }]);
+    return NotificationPanelUnmemoized;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(NotificationPanelUnmemoized, "displayName", 'NotificationPanel');
+
+  var NotificationPanel = /*#__PURE__*/_react["default"].memo(NotificationPanelUnmemoized);
+
+  return NotificationPanel;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plot-container.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import MapContainerFactory from './map-container';
+import MapsLayoutFactory from './maps-layout';
+import { ExportImage } from '@kepler.gl/constants';
+import { SplitMap } from '@kepler.gl/types';
+import { setExportImageDataUri, setExportImageError, setExportImageSetting } from '@kepler.gl/actions';
+import { mapFieldsSelector } from './kepler-gl';
+interface PlotContainerProps {
+    width?: number;
+    height?: number;
+    exportImageSetting: ExportImage;
+    addNotification: Function;
+    mapFields: ReturnType<typeof mapFieldsSelector>;
+    setExportImageSetting: typeof setExportImageSetting;
+    setExportImageDataUri: typeof setExportImageDataUri;
+    setExportImageError: typeof setExportImageError;
+    splitMaps?: SplitMap[];
+    enableErrorNotification?: boolean;
+}
+declare function PlotContainerFactory(MapContainer: ReturnType<typeof MapContainerFactory>, MapsLayout: ReturnType<typeof MapsLayoutFactory>): React.ComponentType<PlotContainerProps>;
+declare namespace PlotContainerFactory {
+    var deps: (typeof MapContainerFactory | typeof MapsLayoutFactory)[];
+}
+export default PlotContainerFactory;

package/dist/plot-container.js

@@ -0,0 +1,276 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = PlotContainerFactory;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reselect = require("reselect");
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reactMapGl = require("react-map-gl");
+
+var _lodash = _interopRequireDefault(require("lodash.debounce"));
+
+var _utils = require("@kepler.gl/utils");
+
+var _reducers = require("@kepler.gl/reducers");
+
+var _mapContainer = _interopRequireDefault(require("./map-container"));
+
+var _mapsLayout = _interopRequireDefault(require("./maps-layout"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _templateObject, _templateObject2;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var CLASS_FILTER = ['mapboxgl-control-container', 'attrition-link', 'attrition-logo'];
+
+var DOM_FILTER_FUNC = function DOM_FILTER_FUNC(node) {
+  return !CLASS_FILTER.includes(node.className);
+};
+
+var OUT_OF_SCREEN_POSITION = -9999;
+PlotContainerFactory.deps = [_mapContainer["default"], _mapsLayout["default"]]; // Remove mapbox logo in exported map, because it contains non-ascii characters
+
+var StyledPlotContainer = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  .mapboxgl-ctrl-bottom-left,\n  .mapboxgl-ctrl-bottom-right,\n  .mapbox-attribution-container {\n    display: none;\n  }\n\n  position: absolute;\n  top: ", "px;\n  left: ", "px;\n"])), OUT_OF_SCREEN_POSITION, OUT_OF_SCREEN_POSITION);
+
+var StyledMapContainer = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  width: ", "px;\n  height: ", "px;\n  display: flex;\n"])), function (props) {
+  return props.width;
+}, function (props) {
+  return props.height;
+});
+
+function PlotContainerFactory(MapContainer, MapsLayout) {
+  var PlotContainer = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(PlotContainer, _Component);
+
+    var _super = _createSuper(PlotContainer);
+
+    function PlotContainer(_props) {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, PlotContainer);
+      _this = _super.call(this, _props);
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "plottingAreaRef", /*#__PURE__*/(0, _react.createRef)());
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mapStyleSelector", function (props) {
+        return props.mapFields.mapStyle;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mapScaleSelector", function (props) {
+        var imageSize = props.exportImageSetting.imageSize;
+        var mapState = props.mapFields.mapState;
+
+        if (imageSize.scale) {
+          return imageSize.scale;
+        }
+
+        var scale = (0, _utils.getScaleFromImageSize)(imageSize.imageW, imageSize.imageH, mapState.width * (mapState.isSplit ? 2 : 1), mapState.height);
+        return scale > 0 ? scale : 1;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "scaledMapStyleSelector", (0, _reselect.createSelector)(_this.mapStyleSelector, _this.mapScaleSelector, function (mapStyle, scale) {
+        return _objectSpread(_objectSpread({}, mapStyle), {}, {
+          bottomMapStyle: (0, _utils.scaleMapStyleByResolution)(mapStyle.bottomMapStyle, scale),
+          topMapStyle: (0, _utils.scaleMapStyleByResolution)(mapStyle.topMapStyle, scale)
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onMapRender", function (map) {
+        if (map.isStyleLoaded()) {
+          _this._retrieveNewScreenshot();
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_retrieveNewScreenshot", function () {
+        if (_this.plottingAreaRef.current) {
+          (0, _utils.convertToPng)(_this.plottingAreaRef.current, {
+            filter: DOM_FILTER_FUNC
+          }).then(_this.props.setExportImageDataUri)["catch"](function (err) {
+            _this.props.setExportImageError(err);
+
+            if (_this.props.enableErrorNotification) {
+              _this.props.addNotification((0, _utils.exportImageError)({
+                err: err
+              }));
+            }
+          });
+        }
+      });
+      _this._onMapRender = (0, _lodash["default"])(_this._onMapRender, 500);
+      _this._retrieveNewScreenshot = (0, _lodash["default"])(_this._retrieveNewScreenshot, 500);
+      return _this;
+    }
+
+    (0, _createClass2["default"])(PlotContainer, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.props.setExportImageSetting({
+          processing: true
+        });
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var _this2 = this;
+
+        // re-fetch the new screenshot only when ratio legend or resolution changes
+        var checks = ['ratio', 'resolution', 'legend'];
+        var shouldRetrieveScreenshot = checks.some(function (item) {
+          return _this2.props.exportImageSetting[item] !== prevProps.exportImageSetting[item];
+        });
+
+        if (shouldRetrieveScreenshot) {
+          this.props.setExportImageSetting({
+            processing: true
+          });
+
+          this._retrieveNewScreenshot();
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            exportImageSetting = _this$props.exportImageSetting,
+            mapFields = _this$props.mapFields,
+            _this$props$splitMaps = _this$props.splitMaps,
+            splitMaps = _this$props$splitMaps === void 0 ? [] : _this$props$splitMaps;
+        var mapState = mapFields.mapState,
+            visState = mapFields.visState;
+        var layers = visState.layers,
+            layerData = visState.layerData;
+        var imageSize = exportImageSetting.imageSize,
+            legend = exportImageSetting.legend;
+        var isSplit = splitMaps && splitMaps.length > 1;
+        var size = {
+          width: (imageSize === null || imageSize === void 0 ? void 0 : imageSize.imageW) || 1,
+          height: (imageSize === null || imageSize === void 0 ? void 0 : imageSize.imageH) || 1
+        };
+        var width = size.width / (isSplit ? 2 : 1);
+        var height = size.height;
+        var scale = this.mapScaleSelector(this.props);
+
+        var newMapState = _objectSpread(_objectSpread({}, mapState), {}, {
+          width: width,
+          height: height,
+          zoom: mapState.zoom + (Math.log2(scale) || 0)
+        }); // center and all layer bounds
+
+
+        if (exportImageSetting.center) {
+          var renderedLayers = layers.filter(function (layer, idx) {
+            return layer.id !== _constants.GEOCODER_LAYER_ID && layer.shouldRenderLayer(layerData[idx]);
+          });
+          var bounds = (0, _reducers.findMapBounds)(renderedLayers);
+          var centerAndZoom = (0, _utils.getCenterAndZoomFromBounds)(bounds, {
+            width: width,
+            height: height
+          });
+
+          if (centerAndZoom) {
+            var zoom = Number.isFinite(centerAndZoom.zoom) ? centerAndZoom.zoom : mapState.zoom;
+            newMapState.longitude = centerAndZoom.center[0];
+            newMapState.latitude = centerAndZoom.center[1];
+            newMapState.zoom = zoom + Number(Math.log2(scale) || 0);
+          }
+        }
+
+        var mapProps = _objectSpread(_objectSpread({}, mapFields), {}, {
+          mapStyle: this.scaledMapStyleSelector(this.props),
+          // override viewport based on export settings
+          mapState: newMapState,
+          mapControls: {
+            // override map legend visibility
+            mapLegend: {
+              show: legend,
+              active: true
+            }
+          },
+          MapComponent: _reactMapGl.StaticMap,
+          onMapRender: this._onMapRender,
+          isExport: true,
+          deckGlProps: _objectSpread(_objectSpread({}, mapFields.deckGlProps), {}, {
+            glOptions: {
+              preserveDrawingBuffer: true,
+              useDevicePixels: false
+            }
+          })
+        });
+
+        var mapContainers = !isSplit ? /*#__PURE__*/_react["default"].createElement(MapContainer, (0, _extends2["default"])({
+          index: 0,
+          primary: true
+        }, mapProps)) : /*#__PURE__*/_react["default"].createElement(MapsLayout, {
+          className: "plot-container-maps"
+        }, splitMaps.map(function (settings, index) {
+          return /*#__PURE__*/_react["default"].createElement(MapContainer, (0, _extends2["default"])({
+            key: index,
+            index: index,
+            primary: index === 1
+          }, mapProps));
+        }));
+        return /*#__PURE__*/_react["default"].createElement(StyledPlotContainer, {
+          className: "export-map-instance"
+        }, /*#__PURE__*/_react["default"].createElement(StyledMapContainer, {
+          ref: this.plottingAreaRef,
+          width: size.width,
+          height: size.height
+        }, mapContainers));
+      }
+    }]);
+    return PlotContainer;
+  }(_react.Component);
+
+  return PlotContainer;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/plot-container.tsx"],"names":["CLASS_FILTER","DOM_FILTER_FUNC","node","includes","className","OUT_OF_SCREEN_POSITION","PlotContainerFactory","deps","MapContainerFactory","MapsLayoutFactory","StyledPlotContainer","styled","div","StyledMapContainer","props","width","height","MapContainer","MapsLayout","PlotContainer","mapFields","mapStyle","imageSize","exportImageSetting","mapState","scale","imageW","imageH","isSplit","mapStyleSelector","mapScaleSelector","bottomMapStyle","topMapStyle","map","isStyleLoaded","_retrieveNewScreenshot","plottingAreaRef","current","filter","then","setExportImageDataUri","err","setExportImageError","enableErrorNotification","addNotification","_onMapRender","setExportImageSetting","processing","prevProps","checks","shouldRetrieveScreenshot","some","item","splitMaps","visState","layers","layerData","legend","length","size","newMapState","zoom","Math","log2","center","renderedLayers","layer","idx","id","GEOCODER_LAYER_ID","shouldRenderLayer","bounds","centerAndZoom","Number","isFinite","longitude","latitude","mapProps","scaledMapStyleSelector","mapControls","mapLegend","show","active","MapComponent","StaticMap","onMapRender","isExport","deckGlProps","glOptions","preserveDrawingBuffer","useDevicePixels","mapContainers","settings","index","Component"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// libraries\nimport React, {Component, createRef} from 'react';\nimport {createSelector} from 'reselect';\nimport styled from 'styled-components';\nimport {StaticMap} from 'react-map-gl';\nimport debounce from 'lodash.debounce';\nimport {\n  exportImageError,\n  scaleMapStyleByResolution,\n  getCenterAndZoomFromBounds,\n  convertToPng,\n  getScaleFromImageSize\n} from '@kepler.gl/utils';\nimport {findMapBounds} from '@kepler.gl/reducers';\nimport MapContainerFactory from './map-container';\nimport MapsLayoutFactory from './maps-layout';\n\nimport {GEOCODER_LAYER_ID, ExportImage} from '@kepler.gl/constants';\nimport {SplitMap} from '@kepler.gl/types';\nimport {\n  setExportImageDataUri,\n  setExportImageError,\n  setExportImageSetting\n} from '@kepler.gl/actions';\nimport {mapFieldsSelector} from './kepler-gl';\n\nconst CLASS_FILTER = ['mapboxgl-control-container', 'attrition-link', 'attrition-logo'];\nconst DOM_FILTER_FUNC = node => !CLASS_FILTER.includes(node.className);\nconst OUT_OF_SCREEN_POSITION = -9999;\n\nPlotContainerFactory.deps = [MapContainerFactory, MapsLayoutFactory];\n\n// Remove mapbox logo in exported map, because it contains non-ascii characters\nconst StyledPlotContainer = styled.div`\n  .mapboxgl-ctrl-bottom-left,\n  .mapboxgl-ctrl-bottom-right,\n  .mapbox-attribution-container {\n    display: none;\n  }\n\n  position: absolute;\n  top: ${OUT_OF_SCREEN_POSITION}px;\n  left: ${OUT_OF_SCREEN_POSITION}px;\n`;\n\ninterface StyledMapContainerProps {\n  width?: number;\n  height?: number;\n}\n\nconst StyledMapContainer = styled.div<StyledMapContainerProps>`\n  width: ${props => props.width}px;\n  height: ${props => props.height}px;\n  display: flex;\n`;\n\ninterface PlotContainerProps {\n  width?: number;\n  height?: number;\n  exportImageSetting: ExportImage;\n  addNotification: Function;\n  mapFields: ReturnType<typeof mapFieldsSelector>;\n  setExportImageSetting: typeof setExportImageSetting;\n  setExportImageDataUri: typeof setExportImageDataUri;\n  setExportImageError: typeof setExportImageError;\n  splitMaps?: SplitMap[];\n  enableErrorNotification?: boolean;\n}\n\nexport default function PlotContainerFactory(\n  MapContainer: ReturnType<typeof MapContainerFactory>,\n  MapsLayout: ReturnType<typeof MapsLayoutFactory>\n): React.ComponentType<PlotContainerProps> {\n  class PlotContainer extends Component<PlotContainerProps> {\n    constructor(props) {\n      super(props);\n      this._onMapRender = debounce(this._onMapRender, 500);\n      this._retrieveNewScreenshot = debounce(this._retrieveNewScreenshot, 500);\n    }\n\n    componentDidMount() {\n      this.props.setExportImageSetting({processing: true});\n    }\n\n    componentDidUpdate(prevProps) {\n      // re-fetch the new screenshot only when ratio legend or resolution changes\n      const checks = ['ratio', 'resolution', 'legend'];\n      const shouldRetrieveScreenshot = checks.some(\n        item => this.props.exportImageSetting[item] !== prevProps.exportImageSetting[item]\n      );\n      if (shouldRetrieveScreenshot) {\n        this.props.setExportImageSetting({processing: true});\n        this._retrieveNewScreenshot();\n      }\n    }\n\n    plottingAreaRef = createRef<HTMLDivElement>();\n\n    mapStyleSelector = props => props.mapFields.mapStyle;\n    mapScaleSelector = props => {\n      const {imageSize} = props.exportImageSetting;\n      const {mapState} = props.mapFields;\n      if (imageSize.scale) {\n        return imageSize.scale;\n      }\n\n      const scale = getScaleFromImageSize(\n        imageSize.imageW,\n        imageSize.imageH,\n        mapState.width * (mapState.isSplit ? 2 : 1),\n        mapState.height\n      );\n\n      return scale > 0 ? scale : 1;\n    };\n\n    scaledMapStyleSelector = createSelector(\n      this.mapStyleSelector,\n      this.mapScaleSelector,\n      (mapStyle, scale) => ({\n        ...mapStyle,\n        bottomMapStyle: scaleMapStyleByResolution(mapStyle.bottomMapStyle, scale),\n        topMapStyle: scaleMapStyleByResolution(mapStyle.topMapStyle, scale)\n      })\n    );\n\n    _onMapRender = map => {\n      if (map.isStyleLoaded()) {\n        this._retrieveNewScreenshot();\n      }\n    };\n\n    _retrieveNewScreenshot = () => {\n      if (this.plottingAreaRef.current) {\n        convertToPng(this.plottingAreaRef.current, {filter: DOM_FILTER_FUNC})\n          .then(this.props.setExportImageDataUri)\n          .catch(err => {\n            this.props.setExportImageError(err);\n            if (this.props.enableErrorNotification) {\n              this.props.addNotification(exportImageError({err}));\n            }\n          });\n      }\n    };\n\n    render() {\n      const {exportImageSetting, mapFields, splitMaps = []} = this.props;\n      const {mapState, visState} = mapFields;\n      const {layers, layerData} = visState;\n      const {imageSize, legend} = exportImageSetting;\n\n      const isSplit = splitMaps && splitMaps.length > 1;\n\n      const size = {\n        width: imageSize?.imageW || 1,\n        height: imageSize?.imageH || 1\n      };\n      const width = size.width / (isSplit ? 2 : 1);\n      const height = size.height;\n      const scale = this.mapScaleSelector(this.props);\n      const newMapState = {\n        ...mapState,\n        width,\n        height,\n        zoom: mapState.zoom + (Math.log2(scale) || 0)\n      };\n\n      // center and all layer bounds\n      if (exportImageSetting.center) {\n        const renderedLayers = layers.filter(\n          (layer, idx) => layer.id !== GEOCODER_LAYER_ID && layer.shouldRenderLayer(layerData[idx])\n        );\n        const bounds = findMapBounds(renderedLayers);\n        const centerAndZoom = getCenterAndZoomFromBounds(bounds, {width, height});\n        if (centerAndZoom) {\n          const zoom = Number.isFinite(centerAndZoom.zoom) ? centerAndZoom.zoom : mapState.zoom;\n\n          newMapState.longitude = centerAndZoom.center[0];\n          newMapState.latitude = centerAndZoom.center[1];\n          newMapState.zoom = zoom + Number(Math.log2(scale) || 0);\n        }\n      }\n\n      const mapProps = {\n        ...mapFields,\n        mapStyle: this.scaledMapStyleSelector(this.props),\n\n        // override viewport based on export settings\n        mapState: newMapState,\n        mapControls: {\n          // override map legend visibility\n          mapLegend: {\n            show: legend,\n            active: true\n          }\n        },\n        MapComponent: StaticMap,\n        onMapRender: this._onMapRender,\n        isExport: true,\n        deckGlProps: {\n          ...mapFields.deckGlProps,\n          glOptions: {\n            preserveDrawingBuffer: true,\n            useDevicePixels: false\n          }\n        }\n      };\n\n      const mapContainers = !isSplit ? (\n        <MapContainer index={0} primary={true} {...mapProps} />\n      ) : (\n        <MapsLayout className=\"plot-container-maps\">\n          {splitMaps.map((settings, index) => (\n            <MapContainer key={index} index={index} primary={index === 1} {...mapProps} />\n          ))}\n        </MapsLayout>\n      );\n      return (\n        <StyledPlotContainer className=\"export-map-instance\">\n          <StyledMapContainer ref={this.plottingAreaRef} width={size.width} height={size.height}>\n            {mapContainers}\n          </StyledMapContainer>\n        </StyledPlotContainer>\n      );\n    }\n  }\n  return PlotContainer;\n}\n"]}

package/dist/side-panel/cloud-storage-dropdown.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const CloudStorageDropdown: ({ show, onClose }: {
+    show: any;
+    onClose: any;
+}) => JSX.Element;
+export default CloudStorageDropdown;

package/dist/side-panel/cloud-storage-dropdown.js

@@ -0,0 +1,62 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _ = require("../");var CloudStorageItems = [{
+  label: 'Save',
+  icon: _.Icons.Save2,
+  key: 'data',
+  onClick: function onClick(props) {
+    return props.onSaveMap;
+  }
+}, {
+  label: 'Settings',
+  icon: _.Icons.Gear,
+  key: 'settings',
+  onClick: function onClick(props) {
+    return props.onExportData;
+  }
+}];
+var PanelHeaderDropdown = (0, _.PanelHeaderDropdownFactory)();
+
+var CloudStorageDropdown = function CloudStorageDropdown(_ref) {
+  var show = _ref.show,
+      onClose = _ref.onClose;
+  return /*#__PURE__*/_react["default"].createElement(PanelHeaderDropdown, {
+    items: CloudStorageItems,
+    show: show,
+    onClose: onClose,
+    id: "cloud-storage"
+  });
+};
+
+var _default = CloudStorageDropdown;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/common/dataset-info.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DatasetInfoProps } from './types';
+export default function DatasetInfoFactory(): ({ dataset }: DatasetInfoProps) => JSX.Element;

package/dist/side-panel/common/dataset-info.js

@@ -0,0 +1,63 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = DatasetInfoFactory;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _d3Format = require("d3-format");
+
+var _localization = require("@kepler.gl/localization");
+
+var _templateObject;
+
+var numFormat = (0, _d3Format.format)(',');
+
+var StyledDataRowCount = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  font-size: 11px;\n  color: ", ";\n  padding-left: 19px;\n"])), function (props) {
+  return props.theme.subtextColor;
+});
+
+function DatasetInfoFactory() {
+  var DatasetInfo = function DatasetInfo(_ref) {
+    var dataset = _ref.dataset;
+    return /*#__PURE__*/_react["default"].createElement(StyledDataRowCount, {
+      className: "source-data-rows"
+    }, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'datasetInfo.rowCount',
+      values: {
+        rowCount: numFormat(dataset.dataContainer.numRows())
+      }
+    }));
+  };
+
+  return DatasetInfo;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/common/dataset-tag.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { DatasetTagProps } from './types';
+export default function DatasetTagFactory(): React.FC<DatasetTagProps>;