@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/components/plot-container.js

@@ -0,0 +1,275 @@
+"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 _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _reselect = require("reselect");
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reactMapGl = require("react-map-gl");
+
+var _lodash = _interopRequireDefault(require("lodash.debounce"));
+
+var _notificationsUtils = require("../utils/notifications-utils");
+
+var _mapContainer = _interopRequireDefault(require("./map-container"));
+
+var _mapsLayout = _interopRequireDefault(require("./maps-layout"));
+
+var _exportUtils = require("../utils/export-utils");
+
+var _mapboxGlStyleEditor = require("../utils/map-style-utils/mapbox-gl-style-editor");
+
+var _dataUtils = require("../utils/data-utils");
+
+var _projectionUtils = require("../utils/projection-utils");
+
+var _defaultSettings = require("../constants/default-settings");
+
+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;
+var propTypes = {
+  width: _propTypes["default"].number.isRequired,
+  height: _propTypes["default"].number.isRequired,
+  exportImageSetting: _propTypes["default"].object.isRequired,
+  addNotification: _propTypes["default"].func.isRequired,
+  mapFields: _propTypes["default"].object.isRequired,
+  setExportImageSetting: _propTypes["default"].object.isRequired,
+  setExportImageDataUri: _propTypes["default"].func.isRequired,
+  setExportImageError: _propTypes["default"].func.isRequired,
+  splitMaps: _propTypes["default"].arrayOf(_propTypes["default"].object)
+};
+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  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;
+});
+
+var deckGlProps = {
+  glOptions: {
+    preserveDrawingBuffer: true,
+    useDevicePixels: false
+  }
+};
+
+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); // _onMapRender defined in cloud-native
+
+      (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, _exportUtils.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, _mapboxGlStyleEditor.scaleMapStyleByResolution)(mapStyle.bottomMapStyle, scale),
+          topMapStyle: (0, _mapboxGlStyleEditor.scaleMapStyleByResolution)(mapStyle.topMapStyle, scale)
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_retrieveNewScreenshot", function () {
+        if (_this.plottingAreaRef.current) {
+          (0, _exportUtils.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, _notificationsUtils.exportImageError)({
+                err: err
+              }));
+            }
+          });
+        }
+      });
+      _this._generateThumbnail = null;
+      _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,
+            splitMaps = _this$props.splitMaps,
+            maskPolygon = _this$props.maskPolygon;
+        var _exportImageSetting$i = exportImageSetting.imageSize,
+            imageSize = _exportImageSetting$i === void 0 ? {} : _exportImageSetting$i,
+            legend = exportImageSetting.legend;
+        var mapState = mapFields.mapState;
+        var isSplit = splitMaps && splitMaps.length > 1;
+        var size = {
+          width: imageSize.imageW || 1,
+          height: 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 = mapFields.layers.filter(function (layer, idx) {
+            return layer.id !== _defaultSettings.GEOCODER_LAYER_ID && layer.shouldRenderLayer(mapFields.layerData[idx]);
+          });
+          var bounds = (0, _dataUtils.findMapBounds)(renderedLayers);
+          var centerAndZoom = (0, _projectionUtils.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,
+          generateThumbnail: this._generateThumbnail,
+          isExport: true,
+          deckGlProps: deckGlProps,
+          maskPolygon: maskPolygon
+        });
+
+        var mapContainers = !isSplit ? /*#__PURE__*/_react["default"].createElement(MapContainer, (0, _extends2["default"])({
+          index: 0,
+          primary: true
+        }, mapProps)) : /*#__PURE__*/_react["default"].createElement(MapsLayout, {
+          isExport: true
+        }, splitMaps.map(function (settings, index) {
+          return /*#__PURE__*/_react["default"].createElement(MapContainer, (0, _extends2["default"])({
+            key: index,
+            index: index,
+            primary: index === 1
+          }, mapProps, {
+            mapLayers: splitMaps[index].layers
+          }));
+        }));
+        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);
+
+  PlotContainer.propsTypes = propTypes;
+  return PlotContainer;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/components/plot-container.js"],"names":["CLASS_FILTER","DOM_FILTER_FUNC","node","includes","className","OUT_OF_SCREEN_POSITION","propTypes","width","PropTypes","number","isRequired","height","exportImageSetting","object","addNotification","func","mapFields","setExportImageSetting","setExportImageDataUri","setExportImageError","splitMaps","arrayOf","PlotContainerFactory","deps","MapContainerFactory","MapsLayoutFactory","StyledPlotContainer","styled","div","StyledMapContainer","props","deckGlProps","glOptions","preserveDrawingBuffer","useDevicePixels","MapContainer","MapsLayout","PlotContainer","mapStyle","imageSize","mapState","scale","imageW","imageH","isSplit","mapStyleSelector","mapScaleSelector","bottomMapStyle","topMapStyle","plottingAreaRef","current","filter","then","err","enableErrorNotification","_generateThumbnail","_retrieveNewScreenshot","processing","prevProps","checks","shouldRetrieveScreenshot","some","item","maskPolygon","legend","length","size","newMapState","zoom","Math","log2","center","renderedLayers","layers","layer","idx","id","GEOCODER_LAYER_ID","shouldRenderLayer","layerData","bounds","centerAndZoom","Number","isFinite","longitude","latitude","mapProps","scaledMapStyleSelector","mapControls","mapLegend","show","active","MapComponent","StaticMap","generateThumbnail","isExport","mapContainers","map","settings","index","Component","propsTypes"],"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 PropTypes from 'prop-types';\nimport {createSelector} from 'reselect';\nimport styled from 'styled-components';\nimport {StaticMap} from 'react-map-gl';\nimport debounce from 'lodash.debounce';\nimport {exportImageError} from 'utils/notifications-utils';\nimport MapContainerFactory from './map-container';\nimport MapsLayoutFactory from './maps-layout';\nimport {convertToPng, getScaleFromImageSize} from 'utils/export-utils';\nimport {scaleMapStyleByResolution} from 'utils/map-style-utils/mapbox-gl-style-editor';\n\nimport {findMapBounds} from 'utils/data-utils';\nimport {getCenterAndZoomFromBounds} from 'utils/projection-utils';\nimport {GEOCODER_LAYER_ID} from 'constants/default-settings';\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\nconst propTypes = {\n  width: PropTypes.number.isRequired,\n  height: PropTypes.number.isRequired,\n  exportImageSetting: PropTypes.object.isRequired,\n  addNotification: PropTypes.func.isRequired,\n  mapFields: PropTypes.object.isRequired,\n  setExportImageSetting: PropTypes.object.isRequired,\n  setExportImageDataUri: PropTypes.func.isRequired,\n  setExportImageError: PropTypes.func.isRequired,\n  splitMaps: PropTypes.arrayOf(PropTypes.object)\n};\n\nPlotContainerFactory.deps = [MapContainerFactory, MapsLayoutFactory];\n\n// Remove mapbox logo in exported map, because it contains non-ascii characters\nconst StyledPlotContainer = styled.div`\n  position: absolute;\n  top: ${OUT_OF_SCREEN_POSITION}px;\n  left: ${OUT_OF_SCREEN_POSITION}px;\n`;\n\nconst StyledMapContainer = styled.div`\n  width: ${props => props.width}px;\n  height: ${props => props.height}px;\n  display: flex;\n`;\n\nconst deckGlProps = {\n  glOptions: {\n    preserveDrawingBuffer: true,\n    useDevicePixels: false\n  }\n};\n\nexport default function PlotContainerFactory(MapContainer, MapsLayout) {\n  class PlotContainer extends Component {\n    constructor(props) {\n      super(props);\n      // _onMapRender defined in cloud-native\n      this._generateThumbnail = null;\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();\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    _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, maskPolygon} = this.props;\n      const {imageSize = {}, legend} = exportImageSetting;\n      const {mapState} = mapFields;\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 = mapFields.layers.filter(\n          (layer, idx) =>\n            layer.id !== GEOCODER_LAYER_ID && layer.shouldRenderLayer(mapFields.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        generateThumbnail: this._generateThumbnail,\n        isExport: true,\n        deckGlProps,\n        maskPolygon\n      };\n\n      const mapContainers = !isSplit ? (\n        <MapContainer index={0} primary={true} {...mapProps} />\n      ) : (\n        <MapsLayout isExport={true}>\n          {splitMaps.map((settings, index) => (\n            <MapContainer\n              key={index}\n              index={index}\n              primary={index === 1}\n              {...mapProps}\n              mapLayers={splitMaps[index].layers}\n            />\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\n  PlotContainer.propsTypes = propTypes;\n  return PlotContainer;\n}\n"]}

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

@@ -0,0 +1,63 @@
+"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("./..");
+
+// 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.
+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/components/side-panel/common/dataset-info.js

@@ -0,0 +1,43 @@
+"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("../../../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/components/side-panel/common/dataset-tag.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = DatasetTagFactory;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _templateObject;
+
+var DatasetTagWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  color: ", ";\n  font-size: 11px;\n  letter-spacing: 0.2px;\n  overflow: auto;\n\n  .dataset-color {\n    flex-shrink: 0;\n    margin-top: 5px;\n  }\n\n  .dataset-name {\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n"])), function (props) {
+  return props.theme.textColor;
+});
+
+function DatasetTagFactory() {
+  var DatasetTag = function DatasetTag(_ref) {
+    var onClick = _ref.onClick,
+        dataset = _ref.dataset;
+    return /*#__PURE__*/_react["default"].createElement(DatasetTagWrapper, {
+      className: "source-data-tag",
+      onClick: onClick
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.DatasetSquare, {
+      className: "dataset-color",
+      color: dataset.color
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "dataset-name",
+      title: dataset.label
+    }, dataset.label));
+  };
+
+  return DatasetTag;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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