@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/esm/modal-container.js

@@ -0,0 +1,454 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component } from 'react';
+import { css } from 'styled-components';
+import get from 'es-toolkit/compat/get';
+import document from 'global/document';
+import { ALL_FIELD_TYPES } from '@kepler.gl/constants';
+import { exportData, getFileFormatNames, getFileExtensions } from '@kepler.gl/reducers';
+import { exportHtml, exportMap, exportJson, exportImage } from '@kepler.gl/utils';
+import ModalDialogFactory from './modals/modal-dialog';
+
+// modals
+import DeleteDatasetModalFactory from './modals/delete-data-modal';
+import OverWriteMapModalFactory from './modals/overwrite-map-modal';
+import DataTableModalFactory from './modals/data-table-modal';
+import LoadDataModalFactory from './modals/load-data-modal';
+import ExportImageModalFactory from './modals/export-image-modal';
+import ExportDataModalFactory from './modals/export-data-modal';
+import ExportMapModalFactory from './modals/export-map-modal/export-map-modal';
+import ExportVideoModalFactory from './modals/export-video-modal';
+import AddMapStyleModalFactory from './modals/add-map-style-modal';
+import SaveMapModalFactory from './modals/save-map-modal';
+import ShareMapModalFactory from './modals/share-map-modal';
+
+// Breakpoints
+import { media } from '@kepler.gl/styles';
+
+// Template
+import { EXPORT_DATA_TYPE_OPTIONS, EXPORT_MAP_FORMATS, KeyEvent, ADD_DATA_ID, DATA_TABLE_ID, DELETE_DATA_ID, EXPORT_DATA_ID, EXPORT_IMAGE_ID, EXPORT_MAP_ID, EXPORT_VIDEO_ID, ADD_MAP_STYLE_ID, SAVE_MAP_ID, SHARE_MAP_ID, OVERWRITE_MAP_ID } from '@kepler.gl/constants';
+var DataTableModalStyle = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  top: 70px;\n  padding: 0;\n  width: 90vw;\n  max-width: 90vw;\n\n  ", " ", ";\n"])), media.portable(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    padding: 0;\n  "]))), media.palm(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n    padding: 0;\n    margin: 0 auto;\n  "]))));
+var smallModalCss = css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  width: 40%;\n  padding: 40px 40px 32px 40px;\n"])));
+var LoadDataModalStyle = css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  top: 60px;\n"])));
+var ExportVideoModalStyle = css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  max-width: 960px;\n"])));
+var DefaultStyle = css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  max-width: 960px;\n"])));
+ModalContainerFactory.deps = [DeleteDatasetModalFactory, OverWriteMapModalFactory, DataTableModalFactory, LoadDataModalFactory, ExportImageModalFactory, ExportDataModalFactory, ExportMapModalFactory, ExportVideoModalFactory, AddMapStyleModalFactory, ModalDialogFactory, SaveMapModalFactory, ShareMapModalFactory];
+export default function ModalContainerFactory(DeleteDatasetModal, OverWriteMapModal, DataTableModal, LoadDataModal, ExportImageModal, ExportDataModal, ExportMapModal, ExportVideoModal, AddMapStyleModal, ModalDialog, SaveMapModal, ShareMapModal) {
+  /** @augments React.Component<ModalContainerProps> */
+  var ModalContainer = /*#__PURE__*/function (_Component) {
+    function ModalContainer() {
+      var _this;
+      _classCallCheck(this, ModalContainer);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, ModalContainer, [].concat(args));
+      // TODO - remove when prop types are fully exported
+      _defineProperty(_this, "componentDidMount", function () {
+        document.addEventListener('keyup', _this._onKeyUp);
+      });
+      _defineProperty(_this, "_onKeyUp", function (event) {
+        var keyCode = event.keyCode;
+        if (keyCode === KeyEvent.DOM_VK_ESCAPE) {
+          _this._closeModal();
+        }
+      });
+      _defineProperty(_this, "_closeModal", function () {
+        _this.props.uiStateActions.toggleModal(null);
+      });
+      _defineProperty(_this, "_deleteDataset", function (key) {
+        _this.props.visStateActions.removeDataset(key);
+        _this._closeModal();
+      });
+      _defineProperty(_this, "_onAddCustomMapStyle", function () {
+        _this.props.mapStyleActions.addCustomMapStyle();
+        _this._closeModal();
+      });
+      _defineProperty(_this, "_onFileUpload", function (fileList) {
+        _this.props.visStateActions.loadFiles(fileList);
+      });
+      _defineProperty(_this, "_onTilesetAdded", function (tileset, processedMetadata) {
+        _this.props.visStateActions.updateVisData({
+          info: {
+            label: tileset.name,
+            type: tileset.type,
+            format: 'rows'
+          },
+          data: {
+            fields: (processedMetadata === null || processedMetadata === void 0 ? void 0 : processedMetadata.fields) || [],
+            rows: []
+          },
+          metadata: _objectSpread(_objectSpread({}, processedMetadata), tileset.metadata),
+          // Vector tile layer supports GPU filtering for numeric and boolean fields
+          supportedFilterTypes: [ALL_FIELD_TYPES.real, ALL_FIELD_TYPES.integer, ALL_FIELD_TYPES["boolean"]],
+          disableDataOperation: true
+        }, {
+          autoCreateLayers: true,
+          centerMap: true
+        });
+        _this._closeModal();
+      });
+      _defineProperty(_this, "_onExportImage", function () {
+        if (!_this.props.uiState.exportImage.processing) {
+          exportImage(_this.props.uiState.exportImage, "".concat(_this.props.appName, ".png"));
+          _this.props.uiStateActions.cleanupExportImage();
+          _this._closeModal();
+        }
+      });
+      _defineProperty(_this, "_onExportData", function () {
+        exportData(_this.props, _this.props.uiState.exportData);
+        _this._closeModal();
+      });
+      _defineProperty(_this, "_onExportMap", function () {
+        var uiState = _this.props.uiState;
+        var format = uiState.exportMap.format;
+        (format === EXPORT_MAP_FORMATS.HTML ? exportHtml : exportJson)(_this.props, _this.props.uiState.exportMap[format] || {});
+        _this._closeModal();
+      });
+      _defineProperty(_this, "_exportFileToCloud", function (_ref) {
+        var provider = _ref.provider,
+          isPublic = _ref.isPublic,
+          overwrite = _ref.overwrite,
+          closeModal = _ref.closeModal;
+        var toSave = exportMap(_this.props);
+        _this.props.providerActions.exportFileToCloud({
+          mapData: toSave,
+          provider: provider,
+          options: {
+            isPublic: isPublic,
+            overwrite: overwrite,
+            mapIdToOverwrite: _this.props.providerState.savedMapId
+          },
+          closeModal: closeModal,
+          onSuccess: _this.props.onExportToCloudSuccess,
+          onError: _this.props.onExportToCloudError
+        });
+      });
+      _defineProperty(_this, "_onSaveMap", function (provider) {
+        var overwrite = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        _this._exportFileToCloud({
+          provider: provider,
+          isPublic: false,
+          overwrite: overwrite,
+          closeModal: true
+        });
+      });
+      _defineProperty(_this, "_onOverwriteMap", function (provider) {
+        _this._onSaveMap(provider, true);
+      });
+      _defineProperty(_this, "_onShareMapUrl", function (provider) {
+        _this._exportFileToCloud({
+          provider: provider,
+          isPublic: true,
+          overwrite: false,
+          closeModal: false
+        });
+      });
+      _defineProperty(_this, "_onCloseSaveMap", function () {
+        _this.props.providerActions.resetProviderStatus();
+        _this._closeModal();
+      });
+      _defineProperty(_this, "_onLoadCloudMap", function (payload) {
+        _this.props.providerActions.loadCloudMap(_objectSpread(_objectSpread({}, payload), {}, {
+          onSuccess: _this.props.onLoadCloudMapSuccess,
+          onError: _this.props.onLoadCloudMapError
+        }));
+      });
+      return _this;
+    }
+    _inherits(ModalContainer, _Component);
+    return _createClass(ModalContainer, [{
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        document.removeEventListener('keyup', this._onKeyUp);
+      }
+    }, {
+      key: "render",
+      value: /* eslint-disable complexity */
+      function render() {
+        var _this2 = this;
+        var _this$props = this.props,
+          containerW = _this$props.containerW,
+          containerH = _this$props.containerH,
+          mapStyle = _this$props.mapStyle,
+          mapState = _this$props.mapState,
+          uiState = _this$props.uiState,
+          visState = _this$props.visState,
+          rootNode = _this$props.rootNode,
+          visStateActions = _this$props.visStateActions,
+          uiStateActions = _this$props.uiStateActions,
+          providerState = _this$props.providerState;
+        var currentModal = uiState.currentModal,
+          datasetKeyToRemove = uiState.datasetKeyToRemove;
+        var datasets = visState.datasets,
+          layers = visState.layers,
+          editingDataset = visState.editingDataset;
+        var template = null;
+        var modalProps = {};
+
+        // TODO - currentModal is a string
+        // @ts-ignore
+        if (currentModal && currentModal.id && currentModal.template) {
+          // if currentMdoal template is already provided
+          // TODO: need to check whether template is valid
+          // @ts-ignore
+          template = /*#__PURE__*/React.createElement(currentModal.template, null);
+          // @ts-ignore
+          modalProps = currentModal.modalProps;
+        } else {
+          switch (currentModal) {
+            case DATA_TABLE_ID:
+              {
+                var width = containerW * 0.9;
+                template = /*#__PURE__*/React.createElement(DataTableModal, {
+                  datasets: datasets,
+                  dataId: editingDataset,
+                  showDatasetTable: visStateActions.showDatasetTable,
+                  sortTableColumn: visStateActions.sortTableColumn,
+                  pinTableColumn: visStateActions.pinTableColumn,
+                  copyTableColumn: visStateActions.copyTableColumn,
+                  setColumnDisplayFormat: visStateActions.setColumnDisplayFormat,
+                  loadColumnStats: visStateActions.loadColumnStats,
+                  uiStateActions: uiStateActions,
+                  uiState: uiState
+                });
+
+                // TODO: we need to make this width consistent with the css rule defined modal.js:32 max-width: 70vw
+                // @ts-ignore // TODO fix this after add types to Theme
+                modalProps.cssStyle = css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n              ", ";\n              ", ";\n            "])), DataTableModalStyle, media.palm(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n                width: ", "px;\n              "])), width));
+                break;
+              }
+            case DELETE_DATA_ID:
+              {
+                // validate options
+                if (datasetKeyToRemove && datasets && datasets[datasetKeyToRemove]) {
+                  template = /*#__PURE__*/React.createElement(DeleteDatasetModal, {
+                    dataset: datasets[datasetKeyToRemove],
+                    layers: layers
+                  });
+                  modalProps = {
+                    title: 'modal.title.deleteDataset',
+                    cssStyle: smallModalCss,
+                    footer: true,
+                    onConfirm: function onConfirm() {
+                      return _this2._deleteDataset(datasetKeyToRemove);
+                    },
+                    onCancel: this._closeModal,
+                    confirmButton: {
+                      negative: true,
+                      large: true,
+                      children: 'modal.button.delete'
+                    }
+                  };
+                }
+                break; // in case we add a new case after this one
+              }
+            case ADD_DATA_ID:
+              template = /*#__PURE__*/React.createElement(LoadDataModal, _extends({}, providerState, {
+                onClose: this._closeModal,
+                onFileUpload: this._onFileUpload,
+                onTilesetAdded: this._onTilesetAdded,
+                onLoadCloudMap: this._onLoadCloudMap,
+                loadFiles: uiState.loadFiles,
+                fileLoading: visState.fileLoading,
+                fileLoadingProgress: visState.fileLoadingProgress,
+                fileFormatNames: getFileFormatNames(this.props.visState),
+                fileExtensions: getFileExtensions(this.props.visState)
+              }));
+              modalProps = {
+                title: 'modal.title.addDataToMap',
+                cssStyle: LoadDataModalStyle,
+                footer: false,
+                onConfirm: this._closeModal
+              };
+              break;
+            case EXPORT_IMAGE_ID:
+              template = /*#__PURE__*/React.createElement(ExportImageModal, {
+                exportImage: uiState.exportImage,
+                mapW: containerW,
+                mapH: containerH,
+                onUpdateImageSetting: uiStateActions.setExportImageSetting,
+                cleanupExportImage: uiStateActions.cleanupExportImage
+              });
+              modalProps = {
+                title: 'modal.title.exportImage',
+                cssStyle: '',
+                footer: true,
+                onCancel: this._closeModal,
+                onConfirm: this._onExportImage,
+                confirmButton: {
+                  large: true,
+                  disabled: uiState.exportImage.processing,
+                  children: 'modal.button.download'
+                }
+              };
+              break;
+            case EXPORT_DATA_ID:
+              template = /*#__PURE__*/React.createElement(ExportDataModal, _extends({}, uiState.exportData, {
+                supportedDataTypes: EXPORT_DATA_TYPE_OPTIONS,
+                datasets: datasets,
+                applyCPUFilter: this.props.visStateActions.applyCPUFilter,
+                onChangeExportDataType: uiStateActions.setExportDataType,
+                onChangeExportSelectedDataset: uiStateActions.setExportSelectedDataset,
+                onChangeExportFiltered: uiStateActions.setExportFiltered
+              }));
+              modalProps = {
+                title: 'modal.title.exportData',
+                cssStyle: '',
+                footer: true,
+                onCancel: this._closeModal,
+                onConfirm: this._onExportData,
+                confirmButton: {
+                  large: true,
+                  children: 'modal.button.export'
+                }
+              };
+              break;
+            case EXPORT_MAP_ID:
+              {
+                var keplerGlConfig = visState.schema.getConfigToSave({
+                  mapStyle: mapStyle,
+                  visState: visState,
+                  mapState: mapState,
+                  uiState: uiState
+                });
+                template = /*#__PURE__*/React.createElement(ExportMapModal, {
+                  config: keplerGlConfig,
+                  options: uiState.exportMap,
+                  onChangeExportMapFormat: uiStateActions.setExportMapFormat,
+                  onEditUserMapboxAccessToken: uiStateActions.setUserMapboxAccessToken,
+                  onChangeExportMapHTMLMode: uiStateActions.setExportHTMLMapMode
+                });
+                modalProps = {
+                  title: 'modal.title.exportMap',
+                  cssStyle: '',
+                  footer: true,
+                  onCancel: this._closeModal,
+                  onConfirm: this._onExportMap,
+                  confirmButton: {
+                    large: true,
+                    children: 'modal.button.export'
+                  }
+                };
+                break;
+              }
+            case EXPORT_VIDEO_ID:
+              template = /*#__PURE__*/React.createElement(ExportVideoModal, {
+                mapboxApiAccessToken: this.props.mapboxApiAccessToken,
+                mapboxApiUrl: this.props.mapboxApiUrl,
+                mapState: mapState,
+                mapStyle: mapStyle,
+                visState: visState,
+                exportVideo: uiState.exportVideo,
+                containerW: containerW,
+                visStateActions: visStateActions,
+                uiStateActions: uiStateActions,
+                onClose: this._closeModal
+              });
+              modalProps = {
+                title: 'modal.title.exportVideo',
+                cssStyle: ExportVideoModalStyle,
+                footer: false,
+                onCancel: this._closeModal
+              };
+              break;
+            case ADD_MAP_STYLE_ID:
+              template = /*#__PURE__*/React.createElement(AddMapStyleModal, {
+                mapboxApiAccessToken: this.props.mapboxApiAccessToken,
+                mapboxApiUrl: this.props.mapboxApiUrl,
+                mapState: this.props.mapState,
+                inputStyle: mapStyle.inputStyle,
+                inputMapStyle: this.props.mapStyleActions.inputMapStyle,
+                loadCustomMapStyle: this.props.mapStyleActions.loadCustomMapStyle
+              });
+              modalProps = {
+                title: 'modal.title.addCustomMapboxStyle',
+                cssStyle: '',
+                footer: true,
+                onCancel: this._closeModal,
+                onConfirm: this._onAddCustomMapStyle,
+                confirmButton: {
+                  large: true,
+                  disabled: mapStyle.inputStyle.error || !mapStyle.inputStyle.url || !mapStyle.inputStyle.label,
+                  children: 'modal.button.addStyle'
+                }
+              };
+              break;
+            case SAVE_MAP_ID:
+              template = /*#__PURE__*/React.createElement(SaveMapModal, _extends({}, providerState, {
+                exportImage: uiState.exportImage,
+                mapInfo: visState.mapInfo,
+                onSetMapInfo: visStateActions.setMapInfo,
+                cleanupExportImage: uiStateActions.cleanupExportImage,
+                onUpdateImageSetting: uiStateActions.setExportImageSetting,
+                onCancel: this._closeModal,
+                onConfirm: function onConfirm(provider) {
+                  return _this2._onSaveMap(provider, false);
+                }
+              }));
+              modalProps = {
+                title: 'modal.title.saveMap',
+                cssStyle: '',
+                footer: false
+              };
+              break;
+            case OVERWRITE_MAP_ID:
+              template = /*#__PURE__*/React.createElement(OverWriteMapModal, _extends({}, providerState, {
+                title: get(visState, ['mapInfo', 'title']),
+                onUpdateImageSetting: uiStateActions.setExportImageSetting,
+                cleanupExportImage: uiStateActions.cleanupExportImage,
+                onConfirm: this._onOverwriteMap,
+                onCancel: this._closeModal
+              }));
+              modalProps = {
+                title: 'Overwrite Existing File?',
+                cssStyle: smallModalCss,
+                footer: false
+              };
+              break;
+            case SHARE_MAP_ID:
+              template = /*#__PURE__*/React.createElement(ShareMapModal, _extends({}, providerState, {
+                onExport: this._onShareMapUrl,
+                cleanupExportImage: uiStateActions.cleanupExportImage,
+                onUpdateImageSetting: uiStateActions.setExportImageSetting
+              }));
+              modalProps = {
+                title: 'modal.title.shareURL',
+                cssStyle: '',
+                onCancel: this._onCloseSaveMap
+              };
+              break;
+            default:
+              break;
+          }
+        }
+        return rootNode ? /*#__PURE__*/React.createElement(ModalDialog, _extends({
+          parentSelector: function parentSelector() {
+            return rootNode;
+          },
+          isOpen: Boolean(currentModal),
+          onCancel: this._closeModal
+        }, modalProps, {
+          cssStyle: DefaultStyle.concat(modalProps.cssStyle)
+        }), template) : null;
+      }
+      /* eslint-enable complexity */
+    }]);
+  }(Component);
+  return ModalContainer;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","css","get","document","ALL_FIELD_TYPES","exportData","getFileFormatNames","getFileExtensions","exportHtml","exportMap","exportJson","exportImage","ModalDialogFactory","DeleteDatasetModalFactory","OverWriteMapModalFactory","DataTableModalFactory","LoadDataModalFactory","ExportImageModalFactory","ExportDataModalFactory","ExportMapModalFactory","ExportVideoModalFactory","AddMapStyleModalFactory","SaveMapModalFactory","ShareMapModalFactory","media","EXPORT_DATA_TYPE_OPTIONS","EXPORT_MAP_FORMATS","KeyEvent","ADD_DATA_ID","DATA_TABLE_ID","DELETE_DATA_ID","EXPORT_DATA_ID","EXPORT_IMAGE_ID","EXPORT_MAP_ID","EXPORT_VIDEO_ID","ADD_MAP_STYLE_ID","SAVE_MAP_ID","SHARE_MAP_ID","OVERWRITE_MAP_ID","DataTableModalStyle","_templateObject","_taggedTemplateLiteral","portable","_templateObject2","palm","_templateObject3","smallModalCss","_templateObject4","LoadDataModalStyle","_templateObject5","ExportVideoModalStyle","_templateObject6","DefaultStyle","_templateObject7","ModalContainerFactory","deps","DeleteDatasetModal","OverWriteMapModal","DataTableModal","LoadDataModal","ExportImageModal","ExportDataModal","ExportMapModal","ExportVideoModal","AddMapStyleModal","ModalDialog","SaveMapModal","ShareMapModal","ModalContainer","_Component","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","_defineProperty","addEventListener","_onKeyUp","event","keyCode","DOM_VK_ESCAPE","_closeModal","props","uiStateActions","toggleModal","key","visStateActions","removeDataset","mapStyleActions","addCustomMapStyle","fileList","loadFiles","tileset","processedMetadata","updateVisData","info","label","name","type","format","data","fields","rows","metadata","_objectSpread","supportedFilterTypes","real","integer","disableDataOperation","autoCreateLayers","centerMap","uiState","processing","appName","cleanupExportImage","HTML","_ref","provider","isPublic","overwrite","closeModal","toSave","providerActions","exportFileToCloud","mapData","options","mapIdToOverwrite","providerState","savedMapId","onSuccess","onExportToCloudSuccess","onError","onExportToCloudError","undefined","_exportFileToCloud","_onSaveMap","resetProviderStatus","payload","loadCloudMap","onLoadCloudMapSuccess","onLoadCloudMapError","_inherits","_createClass","value","componentWillUnmount","removeEventListener","render","_this2","_this$props","containerW","containerH","mapStyle","mapState","visState","rootNode","currentModal","datasetKeyToRemove","datasets","layers","editingDataset","template","modalProps","id","createElement","width","dataId","showDatasetTable","sortTableColumn","pinTableColumn","copyTableColumn","setColumnDisplayFormat","loadColumnStats","cssStyle","_templateObject8","_templateObject9","dataset","title","footer","onConfirm","_deleteDataset","onCancel","confirmButton","negative","large","children","_extends","onClose","onFileUpload","_onFileUpload","onTilesetAdded","_onTilesetAdded","onLoadCloudMap","_onLoadCloudMap","fileLoading","fileLoadingProgress","fileFormatNames","fileExtensions","mapW","mapH","onUpdateImageSetting","setExportImageSetting","_onExportImage","disabled","supportedDataTypes","applyCPUFilter","onChangeExportDataType","setExportDataType","onChangeExportSelectedDataset","setExportSelectedDataset","onChangeExportFiltered","setExportFiltered","_onExportData","keplerGlConfig","schema","getConfigToSave","config","onChangeExportMapFormat","setExportMapFormat","onEditUserMapboxAccessToken","setUserMapboxAccessToken","onChangeExportMapHTMLMode","setExportHTMLMapMode","_onExportMap","mapboxApiAccessToken","mapboxApiUrl","exportVideo","inputStyle","inputMapStyle","loadCustomMapStyle","_onAddCustomMapStyle","error","url","mapInfo","onSetMapInfo","setMapInfo","_onOverwriteMap","onExport","_onShareMapUrl","_onCloseSaveMap","parentSelector","isOpen","Boolean"],"sources":["../../src/modal-container.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component} from 'react';\nimport {css} from 'styled-components';\nimport get from 'es-toolkit/compat/get';\nimport document from 'global/document';\n\nimport {ALL_FIELD_TYPES} from '@kepler.gl/constants';\nimport {\n  exportData,\n  getFileFormatNames,\n  getFileExtensions,\n  MapStyle,\n  ProviderState\n} from '@kepler.gl/reducers';\nimport {exportHtml, exportMap, exportJson, exportImage} from '@kepler.gl/utils';\n\nimport ModalDialogFactory from './modals/modal-dialog';\n\n// modals\nimport DeleteDatasetModalFactory from './modals/delete-data-modal';\nimport OverWriteMapModalFactory from './modals/overwrite-map-modal';\nimport DataTableModalFactory from './modals/data-table-modal';\nimport LoadDataModalFactory from './modals/load-data-modal';\nimport ExportImageModalFactory from './modals/export-image-modal';\nimport ExportDataModalFactory from './modals/export-data-modal';\nimport ExportMapModalFactory from './modals/export-map-modal/export-map-modal';\nimport ExportVideoModalFactory from './modals/export-video-modal';\nimport AddMapStyleModalFactory from './modals/add-map-style-modal';\nimport SaveMapModalFactory from './modals/save-map-modal';\nimport ShareMapModalFactory from './modals/share-map-modal';\n\n// Breakpoints\nimport {media} from '@kepler.gl/styles';\n\n// Template\nimport {\n  EXPORT_DATA_TYPE_OPTIONS,\n  EXPORT_MAP_FORMATS,\n  KeyEvent,\n  ADD_DATA_ID,\n  DATA_TABLE_ID,\n  DELETE_DATA_ID,\n  EXPORT_DATA_ID,\n  EXPORT_IMAGE_ID,\n  EXPORT_MAP_ID,\n  EXPORT_VIDEO_ID,\n  ADD_MAP_STYLE_ID,\n  SAVE_MAP_ID,\n  SHARE_MAP_ID,\n  OVERWRITE_MAP_ID\n} from '@kepler.gl/constants';\n\nimport {MapState, UiState, OnSuccessCallBack, OnErrorCallBack} from '@kepler.gl/types';\n\nimport {\n  VisStateActions,\n  UIStateActions,\n  MapStyleActions,\n  ProviderActions\n} from '@kepler.gl/actions';\nimport {ModalDialogProps} from './common/modal';\nimport {Provider} from '@kepler.gl/cloud-providers';\nimport {VisState} from '@kepler.gl/schemas';\n\nconst DataTableModalStyle = css`\n  top: 70px;\n  padding: 0;\n  width: 90vw;\n  max-width: 90vw;\n\n  ${media.portable`\n    padding: 0;\n  `} ${media.palm`\n    padding: 0;\n    margin: 0 auto;\n  `};\n`;\nconst smallModalCss = css`\n  width: 40%;\n  padding: 40px 40px 32px 40px;\n`;\n\nconst LoadDataModalStyle = css`\n  top: 60px;\n`;\n\nconst ExportVideoModalStyle = css`\n  max-width: 960px;\n`;\n\nconst DefaultStyle = css`\n  max-width: 960px;\n`;\n\nexport type ModalContainerProps = {\n  appName: string;\n  rootNode: React.ReactInstance | null | undefined;\n  containerW: number;\n  containerH: number;\n  mapboxApiAccessToken: string;\n  mapboxApiUrl?: string;\n  mapState: MapState;\n  mapStyle: MapStyle;\n  uiState: UiState;\n  visState: VisState;\n  providerState: ProviderState;\n  visStateActions: typeof VisStateActions;\n  uiStateActions: typeof UIStateActions;\n  mapStyleActions: typeof MapStyleActions;\n  providerActions: typeof ProviderActions;\n  onSaveToStorage?: () => void;\n  cloudProviders: Provider[];\n  onLoadCloudMapSuccess?: OnSuccessCallBack;\n  onLoadCloudMapError?: OnErrorCallBack;\n  onExportToCloudSuccess?: OnSuccessCallBack;\n  onExportToCloudError?: OnErrorCallBack;\n};\n\nModalContainerFactory.deps = [\n  DeleteDatasetModalFactory,\n  OverWriteMapModalFactory,\n  DataTableModalFactory,\n  LoadDataModalFactory,\n  ExportImageModalFactory,\n  ExportDataModalFactory,\n  ExportMapModalFactory,\n  ExportVideoModalFactory,\n  AddMapStyleModalFactory,\n  ModalDialogFactory,\n  SaveMapModalFactory,\n  ShareMapModalFactory\n];\n\nexport default function ModalContainerFactory(\n  DeleteDatasetModal: ReturnType<typeof DeleteDatasetModalFactory>,\n  OverWriteMapModal: ReturnType<typeof OverWriteMapModalFactory>,\n  DataTableModal: ReturnType<typeof DataTableModalFactory>,\n  LoadDataModal: ReturnType<typeof LoadDataModalFactory>,\n  ExportImageModal: ReturnType<typeof ExportImageModalFactory>,\n  ExportDataModal: ReturnType<typeof ExportDataModalFactory>,\n  ExportMapModal: ReturnType<typeof ExportMapModalFactory>,\n  ExportVideoModal: ReturnType<typeof ExportVideoModalFactory>,\n  AddMapStyleModal: ReturnType<typeof AddMapStyleModalFactory>,\n  ModalDialog: ReturnType<typeof ModalDialogFactory>,\n  SaveMapModal: ReturnType<typeof SaveMapModalFactory>,\n  ShareMapModal: ReturnType<typeof ShareMapModalFactory>\n): React.ElementType<ModalContainerProps> {\n  /** @augments React.Component<ModalContainerProps> */\n  class ModalContainer extends Component<ModalContainerProps> {\n    // TODO - remove when prop types are fully exported\n    componentDidMount = () => {\n      document.addEventListener('keyup', this._onKeyUp);\n    };\n    componentWillUnmount() {\n      document.removeEventListener('keyup', this._onKeyUp);\n    }\n\n    _onKeyUp = event => {\n      const keyCode = event.keyCode;\n      if (keyCode === KeyEvent.DOM_VK_ESCAPE) {\n        this._closeModal();\n      }\n    };\n\n    _closeModal = () => {\n      this.props.uiStateActions.toggleModal(null);\n    };\n\n    _deleteDataset = key => {\n      this.props.visStateActions.removeDataset(key);\n      this._closeModal();\n    };\n\n    _onAddCustomMapStyle = () => {\n      this.props.mapStyleActions.addCustomMapStyle();\n      this._closeModal();\n    };\n\n    _onFileUpload = fileList => {\n      this.props.visStateActions.loadFiles(fileList);\n    };\n\n    _onTilesetAdded = (\n      tileset: {name: string; type: string; metadata: Record<string, any>},\n      processedMetadata?: Record<string, any>\n    ) => {\n      this.props.visStateActions.updateVisData(\n        {\n          info: {label: tileset.name, type: tileset.type, format: 'rows'},\n          data: {\n            fields: processedMetadata?.fields || [],\n            rows: []\n          },\n          metadata: {\n            ...processedMetadata,\n            ...tileset.metadata\n          },\n          // Vector tile layer supports GPU filtering for numeric and boolean fields\n          supportedFilterTypes: [\n            ALL_FIELD_TYPES.real,\n            ALL_FIELD_TYPES.integer,\n            ALL_FIELD_TYPES.boolean\n          ],\n          disableDataOperation: true\n        },\n        {\n          autoCreateLayers: true,\n          centerMap: true\n        }\n      );\n      this._closeModal();\n    };\n\n    _onExportImage = () => {\n      if (!this.props.uiState.exportImage.processing) {\n        exportImage(this.props.uiState.exportImage, `${this.props.appName}.png`);\n        this.props.uiStateActions.cleanupExportImage();\n        this._closeModal();\n      }\n    };\n\n    _onExportData = () => {\n      exportData(this.props, this.props.uiState.exportData);\n      this._closeModal();\n    };\n\n    _onExportMap = () => {\n      const {uiState} = this.props;\n      const {format} = uiState.exportMap;\n      (format === EXPORT_MAP_FORMATS.HTML ? exportHtml : exportJson)(\n        this.props,\n        this.props.uiState.exportMap[format] || {}\n      );\n      this._closeModal();\n    };\n\n    _exportFileToCloud = ({provider, isPublic, overwrite, closeModal}) => {\n      const toSave = exportMap(this.props);\n\n      this.props.providerActions.exportFileToCloud({\n        mapData: toSave,\n        provider,\n        options: {\n          isPublic,\n          overwrite,\n          mapIdToOverwrite: this.props.providerState.savedMapId\n        },\n        closeModal,\n        onSuccess: this.props.onExportToCloudSuccess,\n        onError: this.props.onExportToCloudError\n      });\n    };\n\n    _onSaveMap = (provider, overwrite = false) => {\n      this._exportFileToCloud({\n        provider,\n        isPublic: false,\n        overwrite,\n        closeModal: true\n      });\n    };\n\n    _onOverwriteMap = provider => {\n      this._onSaveMap(provider, true);\n    };\n\n    _onShareMapUrl = provider => {\n      this._exportFileToCloud({provider, isPublic: true, overwrite: false, closeModal: false});\n    };\n\n    _onCloseSaveMap = () => {\n      this.props.providerActions.resetProviderStatus();\n      this._closeModal();\n    };\n\n    _onLoadCloudMap = payload => {\n      this.props.providerActions.loadCloudMap({\n        ...payload,\n        onSuccess: this.props.onLoadCloudMapSuccess,\n        onError: this.props.onLoadCloudMapError\n      });\n    };\n\n    /* eslint-disable complexity */\n    render() {\n      const {\n        containerW,\n        containerH,\n        mapStyle,\n        mapState,\n        uiState,\n        visState,\n        rootNode,\n        visStateActions,\n        uiStateActions,\n        providerState\n      } = this.props;\n      const {currentModal, datasetKeyToRemove} = uiState;\n      const {datasets, layers, editingDataset} = visState;\n\n      let template: JSX.Element | null = null;\n      let modalProps: Partial<ModalDialogProps> = {};\n\n      // TODO - currentModal is a string\n      // @ts-ignore\n      if (currentModal && currentModal.id && currentModal.template) {\n        // if currentMdoal template is already provided\n        // TODO: need to check whether template is valid\n        // @ts-ignore\n        template = <currentModal.template />;\n        // @ts-ignore\n        modalProps = currentModal.modalProps;\n      } else {\n        switch (currentModal) {\n          case DATA_TABLE_ID: {\n            const width = containerW * 0.9;\n            template = (\n              <DataTableModal\n                datasets={datasets}\n                dataId={editingDataset}\n                showDatasetTable={visStateActions.showDatasetTable}\n                sortTableColumn={visStateActions.sortTableColumn}\n                pinTableColumn={visStateActions.pinTableColumn}\n                copyTableColumn={visStateActions.copyTableColumn}\n                setColumnDisplayFormat={visStateActions.setColumnDisplayFormat}\n                loadColumnStats={visStateActions.loadColumnStats}\n                uiStateActions={uiStateActions}\n                uiState={uiState}\n              />\n            );\n\n            // TODO: we need to make this width consistent with the css rule defined modal.js:32 max-width: 70vw\n            // @ts-ignore // TODO fix this after add types to Theme\n            modalProps.cssStyle = css`\n              ${DataTableModalStyle};\n              ${media.palm`\n                width: ${width}px;\n              `};\n            `;\n            break;\n          }\n          case DELETE_DATA_ID: {\n            // validate options\n            if (datasetKeyToRemove && datasets && datasets[datasetKeyToRemove]) {\n              template = (\n                <DeleteDatasetModal dataset={datasets[datasetKeyToRemove]} layers={layers} />\n              );\n              modalProps = {\n                title: 'modal.title.deleteDataset',\n                cssStyle: smallModalCss,\n                footer: true,\n                onConfirm: () => this._deleteDataset(datasetKeyToRemove),\n                onCancel: this._closeModal,\n                confirmButton: {\n                  negative: true,\n                  large: true,\n                  children: 'modal.button.delete'\n                }\n              };\n            }\n            break; // in case we add a new case after this one\n          }\n          case ADD_DATA_ID:\n            template = (\n              <LoadDataModal\n                {...providerState}\n                onClose={this._closeModal}\n                onFileUpload={this._onFileUpload}\n                onTilesetAdded={this._onTilesetAdded}\n                onLoadCloudMap={this._onLoadCloudMap}\n                loadFiles={uiState.loadFiles}\n                fileLoading={visState.fileLoading}\n                fileLoadingProgress={visState.fileLoadingProgress}\n                fileFormatNames={getFileFormatNames(this.props.visState)}\n                fileExtensions={getFileExtensions(this.props.visState)}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.addDataToMap',\n              cssStyle: LoadDataModalStyle,\n              footer: false,\n              onConfirm: this._closeModal\n            };\n            break;\n          case EXPORT_IMAGE_ID:\n            template = (\n              <ExportImageModal\n                exportImage={uiState.exportImage}\n                mapW={containerW}\n                mapH={containerH}\n                onUpdateImageSetting={uiStateActions.setExportImageSetting}\n                cleanupExportImage={uiStateActions.cleanupExportImage}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.exportImage',\n              cssStyle: '',\n              footer: true,\n              onCancel: this._closeModal,\n              onConfirm: this._onExportImage,\n              confirmButton: {\n                large: true,\n                disabled: uiState.exportImage.processing,\n                children: 'modal.button.download'\n              }\n            };\n            break;\n          case EXPORT_DATA_ID:\n            template = (\n              <ExportDataModal\n                {...uiState.exportData}\n                supportedDataTypes={EXPORT_DATA_TYPE_OPTIONS}\n                datasets={datasets}\n                applyCPUFilter={this.props.visStateActions.applyCPUFilter}\n                onChangeExportDataType={uiStateActions.setExportDataType}\n                onChangeExportSelectedDataset={uiStateActions.setExportSelectedDataset}\n                onChangeExportFiltered={uiStateActions.setExportFiltered}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.exportData',\n              cssStyle: '',\n              footer: true,\n              onCancel: this._closeModal,\n              onConfirm: this._onExportData,\n              confirmButton: {\n                large: true,\n                children: 'modal.button.export'\n              }\n            };\n            break;\n          case EXPORT_MAP_ID: {\n            const keplerGlConfig = visState.schema.getConfigToSave({\n              mapStyle,\n              visState,\n              mapState,\n              uiState\n            });\n            template = (\n              <ExportMapModal\n                config={keplerGlConfig}\n                options={uiState.exportMap}\n                onChangeExportMapFormat={uiStateActions.setExportMapFormat}\n                onEditUserMapboxAccessToken={uiStateActions.setUserMapboxAccessToken}\n                onChangeExportMapHTMLMode={uiStateActions.setExportHTMLMapMode}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.exportMap',\n              cssStyle: '',\n              footer: true,\n              onCancel: this._closeModal,\n              onConfirm: this._onExportMap,\n              confirmButton: {\n                large: true,\n                children: 'modal.button.export'\n              }\n            };\n            break;\n          }\n          case EXPORT_VIDEO_ID:\n            template = (\n              <ExportVideoModal\n                mapboxApiAccessToken={this.props.mapboxApiAccessToken}\n                mapboxApiUrl={this.props.mapboxApiUrl}\n                mapState={mapState}\n                mapStyle={mapStyle}\n                visState={visState}\n                exportVideo={uiState.exportVideo}\n                containerW={containerW}\n                visStateActions={visStateActions}\n                uiStateActions={uiStateActions}\n                onClose={this._closeModal}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.exportVideo',\n              cssStyle: ExportVideoModalStyle,\n              footer: false,\n              onCancel: this._closeModal\n            };\n            break;\n          case ADD_MAP_STYLE_ID:\n            template = (\n              <AddMapStyleModal\n                mapboxApiAccessToken={this.props.mapboxApiAccessToken}\n                mapboxApiUrl={this.props.mapboxApiUrl}\n                mapState={this.props.mapState}\n                inputStyle={mapStyle.inputStyle}\n                inputMapStyle={this.props.mapStyleActions.inputMapStyle}\n                loadCustomMapStyle={this.props.mapStyleActions.loadCustomMapStyle}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.addCustomMapboxStyle',\n              cssStyle: '',\n              footer: true,\n              onCancel: this._closeModal,\n              onConfirm: this._onAddCustomMapStyle,\n              confirmButton: {\n                large: true,\n                disabled:\n                  mapStyle.inputStyle.error ||\n                  !mapStyle.inputStyle.url ||\n                  !mapStyle.inputStyle.label,\n                children: 'modal.button.addStyle'\n              }\n            };\n            break;\n          case SAVE_MAP_ID:\n            template = (\n              <SaveMapModal\n                {...providerState}\n                exportImage={uiState.exportImage}\n                mapInfo={visState.mapInfo}\n                onSetMapInfo={visStateActions.setMapInfo}\n                cleanupExportImage={uiStateActions.cleanupExportImage}\n                onUpdateImageSetting={uiStateActions.setExportImageSetting}\n                onCancel={this._closeModal}\n                onConfirm={provider => this._onSaveMap(provider, false)}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.saveMap',\n              cssStyle: '',\n              footer: false\n            };\n            break;\n          case OVERWRITE_MAP_ID:\n            template = (\n              <OverWriteMapModal\n                {...providerState}\n                title={get(visState, ['mapInfo', 'title'])}\n                onUpdateImageSetting={uiStateActions.setExportImageSetting}\n                cleanupExportImage={uiStateActions.cleanupExportImage}\n                onConfirm={this._onOverwriteMap}\n                onCancel={this._closeModal}\n              />\n            );\n            modalProps = {\n              title: 'Overwrite Existing File?',\n              cssStyle: smallModalCss,\n              footer: false\n            };\n            break;\n          case SHARE_MAP_ID:\n            template = (\n              <ShareMapModal\n                {...providerState}\n                onExport={this._onShareMapUrl}\n                cleanupExportImage={uiStateActions.cleanupExportImage}\n                onUpdateImageSetting={uiStateActions.setExportImageSetting}\n              />\n            );\n            modalProps = {\n              title: 'modal.title.shareURL',\n              cssStyle: '',\n              onCancel: this._onCloseSaveMap\n            };\n            break;\n          default:\n            break;\n        }\n      }\n\n      return rootNode ? (\n        <ModalDialog\n          parentSelector={() => rootNode as HTMLElement}\n          isOpen={Boolean(currentModal)}\n          onCancel={this._closeModal}\n          {...modalProps}\n          cssStyle={DefaultStyle.concat(modalProps.cssStyle)}\n        >\n          {template}\n        </ModalDialog>\n      ) : null;\n    }\n    /* eslint-enable complexity */\n  }\n\n  return ModalContainer;\n}\n"],"mappings":"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","ignoreList":[]}