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

package/dist/esm/common/file-uploader/file-upload.js

@@ -0,0 +1,445 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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, _templateObject0, _templateObject1, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16;
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+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; })(); }
+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; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component, createRef } from 'react';
+import styled from 'styled-components';
+import { injectIntl } from 'react-intl';
+import UploadButton from './upload-button';
+import { DragNDrop, FileType } from '../icons';
+import FileUploadProgress from './file-upload-progress';
+import FileDrop from './file-drop';
+import { GUIDES_FILE_FORMAT_DOC, REMOTE_FILE_FORMATS } from '@kepler.gl/constants';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { fetchRemoteFileAsKeplerFile, getFileNameForRemoteUrl, isRemoteDatasetUrl } from '@kepler.gl/processors';
+import { media } from '@kepler.gl/styles';
+import { isChrome, getApplicationConfig } from '@kepler.gl/utils';
+import Markdown from 'markdown-to-jsx';
+import { Button, InputLight } from '../styled-components';
+import LinkRenderer from '../link-renderer';
+var fileIconColor = '#D3D8E0';
+var StyledUploadMessage = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  color: ", ";\n  font-size: 14px;\n  margin-bottom: 12px;\n\n  ", ";\n"])), function (props) {
+  return props.theme.textColorLT;
+}, media.portable(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    font-size: 12px;\n  "]))));
+export var WarningMsg = styled.span(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  margin-top: 10px;\n  color: ", ";\n  font-weight: 500;\n"])), function (props) {
+  return props.theme.errorColor;
+});
+var StyledFileDrop = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  background-color: white;\n  border-radius: 4px;\n  border-style: ", ";\n  border-width: 1px;\n  border-color: ", ";\n  text-align: center;\n  width: 100%;\n  min-height: 360px;\n  padding: 24px 12px 16px;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n\n  .file-type-row {\n    opacity: 0.5;\n  }\n  ", ";\n"])), function (props) {
+  return props.$dragOver ? 'solid' : 'dashed';
+}, function (props) {
+  return props.$dragOver ? props.theme.textColorLT : props.theme.subtextColorLT;
+}, media.portable(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n    padding: 16px 8px 12px;\n    min-height: 280px;\n  "]))));
+var StyledDropBody = styled.div(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  flex: 1;\n  width: 100%;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: space-evenly;\n"])));
+var StyledActionLine = styled.div(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  color: ", ";\n  font-size: 14px;\n  font-weight: 600;\n  line-height: 20px;\n\n  .upload-button {\n    font-size: 14px;\n    font-weight: 600;\n    color: ", ";\n    text-decoration: none;\n  }\n"])), function (props) {
+  return props.theme.modalTitleColor;
+}, function (props) {
+  return props.theme.linkBtnColor;
+});
+var StyledDragNDropIcon = styled.div(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  color: ", ";\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n"])), fileIconColor);
+var StyledFileTypeFow = styled.div(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n  width: 100%;\n"])));
+var StyledFileUpload = styled.div(_templateObject0 || (_templateObject0 = _taggedTemplateLiteral(["\n  .file-drop {\n    position: relative;\n  }\n"])));
+var StyledMessage = styled.div(_templateObject1 || (_templateObject1 = _taggedTemplateLiteral(["\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  margin-bottom: 32px;\n\n  .loading-action {\n    margin-right: 10px;\n  }\n  .loading-spinner {\n    margin-left: 10px;\n  }\n"])));
+var StyledDragFileWrapper = styled.div(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  width: 100%;\n"])));
+var StyledDisclaimer = styled(StyledMessage)(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["\n  flex-shrink: 0;\n  margin: 12px 12px 0;\n"])));
+var StyledRemoteUrlForm = styled.div(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  gap: 4px;\n  width: 100%;\n  max-width: 420px;\n  margin: 8px auto 0;\n"])));
+var StyledRemoteUrlRow = styled.div(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: row;\n  gap: 8px;\n  align-items: stretch;\n  justify-content: center;\n  width: 100%;\n"])));
+var StyledRemoteUrlInput = styled(InputLight)(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["\n  flex: 1;\n  min-width: 0;\n  max-width: 300px;\n"])));
+var StyledRemoteFormatSelect = styled.select(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["\n  ", ";\n  width: 88px;\n  flex-shrink: 0;\n  height: auto;\n  box-sizing: border-box;\n  padding: 0 6px;\n  cursor: pointer;\n"])), function (props) {
+  return props.theme.inputLT;
+});
+var StyledRemoteFetchButton = styled(Button)(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["\n  height: auto;\n  box-sizing: border-box;\n  padding: 0 12px;\n  flex-shrink: 0;\n"])));
+var REMOTE_DOWNLOAD_SHARE = 0.85;
+function scaleFileProgress(progress, start, end) {
+  return Object.keys(progress).reduce(function (accu, key) {
+    var item = progress[key];
+    accu[key] = _objectSpread(_objectSpread({}, item), {}, {
+      percent: start + (item.percent || 0) * (end - start)
+    });
+    return accu;
+  }, {});
+}
+function getCombinedLoadProgress(_ref) {
+  var fileLoading = _ref.fileLoading,
+    fileLoadingProgress = _ref.fileLoadingProgress,
+    remoteProgress = _ref.remoteProgress;
+  var isRemoteFetch = Object.keys(remoteProgress).length > 0;
+  if (!isRemoteFetch) {
+    return fileLoadingProgress;
+  }
+  if (fileLoading) {
+    return scaleFileProgress(fileLoadingProgress, REMOTE_DOWNLOAD_SHARE, 1);
+  }
+  return scaleFileProgress(remoteProgress, 0, REMOTE_DOWNLOAD_SHARE);
+}
+function FileUploadFactory() {
+  /** @augments {Component<FileUploadProps>} */
+  var FileUpload = /*#__PURE__*/function (_Component) {
+    function FileUpload() {
+      var _this;
+      _classCallCheck(this, FileUpload);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, FileUpload, [].concat(args));
+      _defineProperty(_this, "state", {
+        dragOver: false,
+        fileLoading: false,
+        files: [],
+        errorFiles: [],
+        remoteUrl: '',
+        remoteFormat: 'auto',
+        remoteError: null,
+        remoteLoading: false,
+        remoteProgress: {}
+      });
+      _defineProperty(_this, "frame", /*#__PURE__*/createRef());
+      _defineProperty(_this, "_isValidFileType", function (filename) {
+        var _this$props$fileExten = _this.props.fileExtensions,
+          fileExtensions = _this$props$fileExten === void 0 ? [] : _this$props$fileExten;
+        var fileExt = fileExtensions.find(function (ext) {
+          return filename.endsWith(ext);
+        });
+        return Boolean(fileExt);
+      });
+      /** @param {FileList} fileList */
+      _defineProperty(_this, "_handleFileInput", function (fileList, event) {
+        if (event) {
+          event.stopPropagation();
+        }
+        var files = _toConsumableArray(fileList).filter(Boolean);
+        var _this$props$disableEx = _this.props.disableExtensionFilter,
+          disableExtensionFilter = _this$props$disableEx === void 0 ? false : _this$props$disableEx;
+
+        // TODO - move this code out of the component
+        var filesToLoad = [];
+        var errorFiles = [];
+        var _iterator = _createForOfIteratorHelper(files),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var file = _step.value;
+            if (disableExtensionFilter || _this._isValidFileType(file.name)) {
+              filesToLoad.push(file);
+            } else {
+              errorFiles.push(file.name);
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        var nextState = {
+          files: filesToLoad,
+          errorFiles: errorFiles,
+          dragOver: false
+        };
+        _this.setState(nextState, function () {
+          return nextState.files.length ? _this.props.onFileUpload(nextState.files) : null;
+        });
+      });
+      _defineProperty(_this, "_toggleDragState", function (newState) {
+        _this.setState({
+          dragOver: newState
+        });
+      });
+      _defineProperty(_this, "_onRemoteUrlChange", function (event) {
+        var remoteUrl = event.target.value;
+        _this.setState({
+          remoteUrl: remoteUrl,
+          remoteError: remoteUrl && !isRemoteDatasetUrl(remoteUrl) ? {
+            message: 'Incorrect URL'
+          } : null
+        });
+      });
+      _defineProperty(_this, "_onRemoteFormatChange", function (event) {
+        _this.setState({
+          remoteFormat: event.target.value
+        });
+      });
+      _defineProperty(_this, "_onRemoteUrlKeyDown", function (event) {
+        if (event.key === 'Enter') {
+          event.preventDefault();
+          _this._handleLoadRemoteFile();
+        }
+      });
+      _defineProperty(_this, "_handleLoadRemoteFile", /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var _this$state, remoteUrl, remoteFormat, remoteError, intl, showFormatSelector, format, fileName, downloading, lastUpdate, file;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _this$state = _this.state, remoteUrl = _this$state.remoteUrl, remoteFormat = _this$state.remoteFormat, remoteError = _this$state.remoteError;
+              intl = _this.props.intl;
+              showFormatSelector = getApplicationConfig().enableRemoteFileFormatSelector;
+              format = showFormatSelector && remoteFormat !== 'auto' ? remoteFormat : undefined;
+              if (!(!remoteUrl || remoteError || _this.state.remoteLoading)) {
+                _context.next = 7;
+                break;
+              }
+              if (!remoteUrl) {
+                _this.setState({
+                  remoteError: {
+                    message: 'Incorrect URL'
+                  }
+                });
+              }
+              return _context.abrupt("return");
+            case 7:
+              if (isRemoteDatasetUrl(remoteUrl)) {
+                _context.next = 10;
+                break;
+              }
+              _this.setState({
+                remoteError: {
+                  message: 'Incorrect URL'
+                }
+              });
+              return _context.abrupt("return");
+            case 10:
+              fileName = getFileNameForRemoteUrl(remoteUrl, format);
+              downloading = intl.formatMessage({
+                id: 'fileUploader.downloading'
+              });
+              _this.setState({
+                remoteLoading: true,
+                remoteError: null,
+                remoteProgress: _defineProperty({}, fileName, {
+                  fileName: fileName,
+                  percent: 0,
+                  message: downloading,
+                  error: null
+                })
+              });
+              _context.prev = 13;
+              lastUpdate = 0;
+              _context.next = 17;
+              return fetchRemoteFileAsKeplerFile(remoteUrl, format, function (_ref3) {
+                var percent = _ref3.percent;
+                var now = Date.now();
+                if (percent < 1 && now - lastUpdate < 100) {
+                  return;
+                }
+                lastUpdate = now;
+                _this.setState(function (prev) {
+                  var name = Object.keys(prev.remoteProgress)[0] || fileName;
+                  return {
+                    remoteProgress: _defineProperty({}, name, {
+                      fileName: name,
+                      percent: percent,
+                      message: downloading,
+                      error: null
+                    })
+                  };
+                });
+              });
+            case 17:
+              file = _context.sent;
+              _this.setState({
+                files: [file],
+                errorFiles: [],
+                dragOver: false
+              }, function () {
+                return _this.props.onFileUpload([file]);
+              });
+              _context.next = 24;
+              break;
+            case 21:
+              _context.prev = 21;
+              _context.t0 = _context["catch"](13);
+              _this.setState({
+                remoteLoading: false,
+                remoteProgress: {},
+                remoteError: {
+                  message: _context.t0 instanceof Error ? _context.t0.message : "Failed to load ".concat(remoteUrl)
+                }
+              });
+            case 24:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[13, 21]]);
+      })));
+      return _this;
+    }
+    _inherits(FileUpload, _Component);
+    return _createClass(FileUpload, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        var _this$state2 = this.state,
+          dragOver = _this$state2.dragOver,
+          files = _this$state2.files,
+          errorFiles = _this$state2.errorFiles,
+          remoteUrl = _this$state2.remoteUrl,
+          remoteFormat = _this$state2.remoteFormat,
+          remoteError = _this$state2.remoteError,
+          remoteLoading = _this$state2.remoteLoading,
+          remoteProgress = _this$state2.remoteProgress;
+        var _this$props = this.props,
+          fileLoading = _this$props.fileLoading,
+          fileLoadingProgress = _this$props.fileLoadingProgress,
+          theme = _this$props.theme,
+          intl = _this$props.intl;
+        var _this$props2 = this.props,
+          _this$props2$fileExte = _this$props2.fileExtensions,
+          fileExtensions = _this$props2$fileExte === void 0 ? [] : _this$props2$fileExte,
+          _this$props2$fileForm = _this$props2.fileFormatNames,
+          fileFormatNames = _this$props2$fileForm === void 0 ? [] : _this$props2$fileForm;
+        var showFormatSelector = getApplicationConfig().enableRemoteFileFormatSelector;
+        var fileUploadInfoText = "".concat(intl.formatMessage({
+          id: 'fileUploader.configUploadMessage'
+        }, {
+          fileFormatNames: fileFormatNames.map(function (format) {
+            return "**".concat(format, "**");
+          }).join(', ')
+        }), "(").concat(GUIDES_FILE_FORMAT_DOC, ").");
+        return /*#__PURE__*/React.createElement(StyledFileUpload, {
+          className: "file-uploader",
+          ref: this.frame
+        }, FileDrop ? /*#__PURE__*/React.createElement(FileDrop, {
+          frame: this.frame.current || document,
+          onDragOver: function onDragOver() {
+            return _this2._toggleDragState(true);
+          },
+          onDragLeave: function onDragLeave() {
+            return _this2._toggleDragState(false);
+          },
+          onDrop: this._handleFileInput,
+          className: "file-uploader__file-drop"
+        }, /*#__PURE__*/React.createElement(StyledUploadMessage, {
+          className: "file-upload__message"
+        }, /*#__PURE__*/React.createElement(Markdown, {
+          options: {
+            overrides: {
+              a: {
+                component: LinkRenderer
+              }
+            }
+          }
+        }, fileUploadInfoText)), /*#__PURE__*/React.createElement(StyledFileDrop, {
+          $dragOver: dragOver
+        }, /*#__PURE__*/React.createElement(StyledDropBody, null, /*#__PURE__*/React.createElement(StyledFileTypeFow, {
+          className: "file-type-row"
+        }, fileExtensions.map(function (ext) {
+          return /*#__PURE__*/React.createElement(FileType, {
+            key: ext,
+            ext: ext,
+            height: "50px",
+            fontSize: "9px"
+          });
+        })), fileLoading || remoteLoading ? /*#__PURE__*/React.createElement(FileUploadProgress, {
+          fileLoadingProgress: getCombinedLoadProgress({
+            fileLoading: fileLoading,
+            fileLoadingProgress: fileLoadingProgress,
+            remoteProgress: remoteProgress
+          }),
+          theme: theme
+        }) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledDragNDropIcon, {
+          style: {
+            opacity: dragOver ? 0.5 : 1
+          },
+          className: "file-upload-display-message"
+        }, /*#__PURE__*/React.createElement(DragNDrop, {
+          height: "36px"
+        }), errorFiles.length ? /*#__PURE__*/React.createElement(WarningMsg, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.fileNotSupported',
+          values: {
+            errorFiles: errorFiles.join(', ')
+          }
+        })) : null), !files.length ? /*#__PURE__*/React.createElement(StyledDragFileWrapper, null, /*#__PURE__*/React.createElement(StyledActionLine, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.dropMessage',
+          values: {
+            browse: /*#__PURE__*/React.createElement(UploadButton, {
+              key: "browse",
+              onUpload: this._handleFileInput
+            }, intl.formatMessage({
+              id: 'fileUploader.browseFiles'
+            }))
+          }
+        })), /*#__PURE__*/React.createElement(StyledRemoteUrlForm, {
+          className: "file-uploader__remote-url",
+          onClick: function onClick(event) {
+            return event.stopPropagation();
+          }
+        }, /*#__PURE__*/React.createElement(StyledRemoteUrlRow, null, /*#__PURE__*/React.createElement(StyledRemoteUrlInput, {
+          type: "url",
+          value: remoteUrl,
+          "aria-label": intl.formatMessage({
+            id: 'fileUploader.urlPlaceholder'
+          }),
+          placeholder: intl.formatMessage({
+            id: 'fileUploader.urlPlaceholder'
+          }),
+          onChange: this._onRemoteUrlChange,
+          onKeyDown: this._onRemoteUrlKeyDown,
+          disabled: remoteLoading
+        }), showFormatSelector ? /*#__PURE__*/React.createElement(StyledRemoteFormatSelect, {
+          className: "file-uploader__remote-format",
+          "aria-label": intl.formatMessage({
+            id: 'fileUploader.format'
+          }),
+          value: remoteFormat,
+          onChange: this._onRemoteFormatChange,
+          disabled: remoteLoading
+        }, REMOTE_FILE_FORMATS.map(function (format) {
+          return /*#__PURE__*/React.createElement("option", {
+            key: format,
+            value: format
+          }, format === 'auto' ? intl.formatMessage({
+            id: 'fileUploader.formatAuto'
+          }) : format.toUpperCase());
+        })) : null, /*#__PURE__*/React.createElement(StyledRemoteFetchButton, {
+          type: "button",
+          cta: true,
+          small: true,
+          disabled: !remoteUrl || remoteLoading,
+          onClick: this._handleLoadRemoteFile
+        }, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.fetch'
+        }))), remoteError ? /*#__PURE__*/React.createElement(WarningMsg, null, remoteError.message) : null)) : null)), fileLoading || remoteLoading ? null : /*#__PURE__*/React.createElement(StyledDisclaimer, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.disclaimer'
+        })))) : null, /*#__PURE__*/React.createElement(WarningMsg, null, isChrome() ? /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.chromeMessage'
+        }) : ''));
+      }
+    }], [{
+      key: "getDerivedStateFromProps",
+      value: function getDerivedStateFromProps(props, state) {
+        if (state.fileLoading && props.fileLoading === false && state.files.length) {
+          return {
+            files: [],
+            fileLoading: props.fileLoading,
+            remoteLoading: false,
+            remoteProgress: {}
+          };
+        }
+        return _objectSpread({
+          fileLoading: props.fileLoading
+        }, props.fileLoading ? {
+          remoteLoading: false
+        } : {});
+      }
+    }]);
+  }(Component);
+  return injectIntl(FileUpload);
+}
+export default FileUploadFactory;
+export var FileUpload = FileUploadFactory();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createRef","styled","injectIntl","UploadButton","DragNDrop","FileType","FileUploadProgress","FileDrop","GUIDES_FILE_FORMAT_DOC","REMOTE_FILE_FORMATS","FormattedMessage","fetchRemoteFileAsKeplerFile","getFileNameForRemoteUrl","isRemoteDatasetUrl","media","isChrome","getApplicationConfig","Markdown","Button","InputLight","LinkRenderer","fileIconColor","StyledUploadMessage","div","_templateObject","_taggedTemplateLiteral","props","theme","textColorLT","portable","_templateObject2","WarningMsg","span","_templateObject3","errorColor","StyledFileDrop","_templateObject4","$dragOver","subtextColorLT","_templateObject5","StyledDropBody","_templateObject6","StyledActionLine","_templateObject7","modalTitleColor","linkBtnColor","StyledDragNDropIcon","_templateObject8","StyledFileTypeFow","_templateObject9","StyledFileUpload","_templateObject0","StyledMessage","_templateObject1","StyledDragFileWrapper","_templateObject10","StyledDisclaimer","_templateObject11","StyledRemoteUrlForm","_templateObject12","StyledRemoteUrlRow","_templateObject13","StyledRemoteUrlInput","_templateObject14","StyledRemoteFormatSelect","select","_templateObject15","inputLT","StyledRemoteFetchButton","_templateObject16","REMOTE_DOWNLOAD_SHARE","scaleFileProgress","progress","start","end","Object","keys","reduce","accu","key","item","_objectSpread","percent","getCombinedLoadProgress","_ref","fileLoading","fileLoadingProgress","remoteProgress","isRemoteFetch","length","FileUploadFactory","FileUpload","_Component","_this","_classCallCheck","_len","arguments","args","Array","_key","_callSuper","concat","_defineProperty","dragOver","files","errorFiles","remoteUrl","remoteFormat","remoteError","remoteLoading","filename","_this$props$fileExten","fileExtensions","fileExt","find","ext","endsWith","Boolean","fileList","event","stopPropagation","_toConsumableArray","filter","_this$props$disableEx","disableExtensionFilter","filesToLoad","_iterator","_createForOfIteratorHelper","_step","s","n","done","file","value","_isValidFileType","name","push","err","e","f","nextState","setState","onFileUpload","newState","target","message","preventDefault","_handleLoadRemoteFile","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_this$state","intl","showFormatSelector","format","fileName","downloading","lastUpdate","wrap","_callee$","_context","prev","next","state","enableRemoteFileFormatSelector","undefined","abrupt","formatMessage","id","error","_ref3","now","Date","sent","t0","Error","stop","_inherits","_createClass","render","_this2","_this$state2","_this$props","_this$props2","_this$props2$fileExte","_this$props2$fileForm","fileFormatNames","fileUploadInfoText","map","join","createElement","className","ref","frame","current","document","onDragOver","_toggleDragState","onDragLeave","onDrop","_handleFileInput","options","overrides","a","component","height","fontSize","Fragment","style","opacity","values","browse","onUpload","onClick","type","placeholder","onChange","_onRemoteUrlChange","onKeyDown","_onRemoteUrlKeyDown","disabled","_onRemoteFormatChange","toUpperCase","cta","small","getDerivedStateFromProps"],"sources":["../../../../src/common/file-uploader/file-upload.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, createRef} from 'react';\nimport styled from 'styled-components';\nimport {injectIntl, WrappedComponentProps} from 'react-intl';\nimport UploadButton from './upload-button';\nimport {DragNDrop, FileType} from '../icons';\nimport FileUploadProgress from './file-upload-progress';\nimport FileDrop from './file-drop';\nimport {FileLoading, FileLoadingProgress} from '@kepler.gl/types';\n\nimport {GUIDES_FILE_FORMAT_DOC, REMOTE_FILE_FORMATS} from '@kepler.gl/constants';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {\n  fetchRemoteFileAsKeplerFile,\n  getFileNameForRemoteUrl,\n  isRemoteDatasetUrl\n} from '@kepler.gl/processors';\nimport {media} from '@kepler.gl/styles';\nimport {isChrome, getApplicationConfig} from '@kepler.gl/utils';\nimport Markdown from 'markdown-to-jsx';\n\nimport {Button, InputLight} from '../styled-components';\nimport LinkRenderer from '../link-renderer';\n\nconst fileIconColor = '#D3D8E0';\n\nconst StyledUploadMessage = styled.div`\n  color: ${props => props.theme.textColorLT};\n  font-size: 14px;\n  margin-bottom: 12px;\n\n  ${media.portable`\n    font-size: 12px;\n  `};\n`;\n\nexport const WarningMsg = styled.span`\n  margin-top: 10px;\n  color: ${props => props.theme.errorColor};\n  font-weight: 500;\n`;\n\ninterface StyledFileDropProps {\n  $dragOver?: boolean;\n}\n\nconst StyledFileDrop = styled.div<StyledFileDropProps>`\n  background-color: white;\n  border-radius: 4px;\n  border-style: ${props => (props.$dragOver ? 'solid' : 'dashed')};\n  border-width: 1px;\n  border-color: ${props =>\n    props.$dragOver ? props.theme.textColorLT : props.theme.subtextColorLT};\n  text-align: center;\n  width: 100%;\n  min-height: 360px;\n  padding: 24px 12px 16px;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n\n  .file-type-row {\n    opacity: 0.5;\n  }\n  ${media.portable`\n    padding: 16px 8px 12px;\n    min-height: 280px;\n  `};\n`;\n\nconst StyledDropBody = styled.div`\n  flex: 1;\n  width: 100%;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: space-evenly;\n`;\n\nconst StyledActionLine = styled.div`\n  color: ${props => props.theme.modalTitleColor};\n  font-size: 14px;\n  font-weight: 600;\n  line-height: 20px;\n\n  .upload-button {\n    font-size: 14px;\n    font-weight: 600;\n    color: ${props => props.theme.linkBtnColor};\n    text-decoration: none;\n  }\n`;\n\nconst StyledDragNDropIcon = styled.div`\n  color: ${fileIconColor};\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n`;\n\nconst StyledFileTypeFow = styled.div`\n  width: 100%;\n`;\n\nconst StyledFileUpload = styled.div`\n  .file-drop {\n    position: relative;\n  }\n`;\n\nconst StyledMessage = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  margin-bottom: 32px;\n\n  .loading-action {\n    margin-right: 10px;\n  }\n  .loading-spinner {\n    margin-left: 10px;\n  }\n`;\n\nconst StyledDragFileWrapper = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  width: 100%;\n`;\n\nconst StyledDisclaimer = styled(StyledMessage)`\n  flex-shrink: 0;\n  margin: 12px 12px 0;\n`;\n\nconst StyledRemoteUrlForm = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  gap: 4px;\n  width: 100%;\n  max-width: 420px;\n  margin: 8px auto 0;\n`;\n\nconst StyledRemoteUrlRow = styled.div`\n  display: flex;\n  flex-direction: row;\n  gap: 8px;\n  align-items: stretch;\n  justify-content: center;\n  width: 100%;\n`;\n\nconst StyledRemoteUrlInput = styled(InputLight)`\n  flex: 1;\n  min-width: 0;\n  max-width: 300px;\n`;\n\nconst StyledRemoteFormatSelect = styled.select`\n  ${props => props.theme.inputLT};\n  width: 88px;\n  flex-shrink: 0;\n  height: auto;\n  box-sizing: border-box;\n  padding: 0 6px;\n  cursor: pointer;\n`;\n\nconst StyledRemoteFetchButton = styled(Button)`\n  height: auto;\n  box-sizing: border-box;\n  padding: 0 12px;\n  flex-shrink: 0;\n`;\n\nconst REMOTE_DOWNLOAD_SHARE = 0.85;\n\nfunction scaleFileProgress(\n  progress: FileLoadingProgress,\n  start: number,\n  end: number\n): FileLoadingProgress {\n  return Object.keys(progress).reduce<FileLoadingProgress>((accu, key) => {\n    const item = progress[key];\n    accu[key] = {\n      ...item,\n      percent: start + (item.percent || 0) * (end - start)\n    };\n    return accu;\n  }, {});\n}\n\nfunction getCombinedLoadProgress({\n  fileLoading,\n  fileLoadingProgress,\n  remoteProgress\n}: {\n  fileLoading: FileLoading | false;\n  fileLoadingProgress: FileLoadingProgress;\n  remoteProgress: FileLoadingProgress;\n}): FileLoadingProgress {\n  const isRemoteFetch = Object.keys(remoteProgress).length > 0;\n  if (!isRemoteFetch) {\n    return fileLoadingProgress;\n  }\n  if (fileLoading) {\n    return scaleFileProgress(fileLoadingProgress, REMOTE_DOWNLOAD_SHARE, 1);\n  }\n  return scaleFileProgress(remoteProgress, 0, REMOTE_DOWNLOAD_SHARE);\n}\n\ntype FileUploadProps = {\n  onFileUpload: (files: File[]) => void;\n  fileLoading: FileLoading | false;\n  fileLoadingProgress: FileLoadingProgress;\n  theme: object;\n  /** A list of names of supported formats suitable to present to user */\n  fileFormatNames?: string[];\n  /** A list of typically 3 letter extensions (without '.') for file matching */\n  fileExtensions?: string[];\n  /** Set to true if app wants to do its own file filtering */\n  disableExtensionFilter?: boolean;\n} & WrappedComponentProps;\n\ntype FileUploadState = {\n  dragOver: boolean;\n  fileLoading: FileLoading | false;\n  files: File[];\n  errorFiles: string[];\n  remoteUrl: string;\n  remoteFormat: string;\n  remoteError: {message: string} | null;\n  remoteLoading: boolean;\n  remoteProgress: FileLoadingProgress;\n};\n\nfunction FileUploadFactory() {\n  /** @augments {Component<FileUploadProps>} */\n  class FileUpload extends Component<FileUploadProps, FileUploadState> {\n    state: FileUploadState = {\n      dragOver: false,\n      fileLoading: false,\n      files: [],\n      errorFiles: [],\n      remoteUrl: '',\n      remoteFormat: 'auto',\n      remoteError: null,\n      remoteLoading: false,\n      remoteProgress: {}\n    };\n\n    static getDerivedStateFromProps(props, state) {\n      if (state.fileLoading && props.fileLoading === false && state.files.length) {\n        return {\n          files: [],\n          fileLoading: props.fileLoading,\n          remoteLoading: false,\n          remoteProgress: {}\n        };\n      }\n      return {\n        fileLoading: props.fileLoading,\n        ...(props.fileLoading ? {remoteLoading: false} : {})\n      };\n    }\n\n    frame = createRef<HTMLDivElement>();\n\n    _isValidFileType = filename => {\n      const {fileExtensions = []} = this.props;\n      const fileExt = fileExtensions.find(ext => filename.endsWith(ext));\n\n      return Boolean(fileExt);\n    };\n\n    /** @param {FileList} fileList */\n    _handleFileInput = (fileList: FileList, event: any) => {\n      if (event) {\n        event.stopPropagation();\n      }\n\n      const files = [...fileList].filter(Boolean);\n\n      const {disableExtensionFilter = false} = this.props;\n\n      // TODO - move this code out of the component\n      const filesToLoad: File[] = [];\n      const errorFiles: string[] = [];\n      for (const file of files) {\n        if (disableExtensionFilter || this._isValidFileType(file.name)) {\n          filesToLoad.push(file);\n        } else {\n          errorFiles.push(file.name);\n        }\n      }\n\n      const nextState = {files: filesToLoad, errorFiles, dragOver: false};\n\n      this.setState(nextState, () =>\n        nextState.files.length ? this.props.onFileUpload(nextState.files) : null\n      );\n    };\n\n    _toggleDragState = newState => {\n      this.setState({dragOver: newState});\n    };\n\n    _onRemoteUrlChange = (event: React.ChangeEvent<HTMLInputElement>) => {\n      const remoteUrl = event.target.value;\n      this.setState({\n        remoteUrl,\n        remoteError: remoteUrl && !isRemoteDatasetUrl(remoteUrl) ? {message: 'Incorrect URL'} : null\n      });\n    };\n\n    _onRemoteFormatChange = (event: React.ChangeEvent<HTMLSelectElement>) => {\n      this.setState({remoteFormat: event.target.value});\n    };\n\n    _onRemoteUrlKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {\n      if (event.key === 'Enter') {\n        event.preventDefault();\n        this._handleLoadRemoteFile();\n      }\n    };\n\n    _handleLoadRemoteFile = async () => {\n      const {remoteUrl, remoteFormat, remoteError} = this.state;\n      const {intl} = this.props;\n      const showFormatSelector = getApplicationConfig().enableRemoteFileFormatSelector;\n      const format = showFormatSelector && remoteFormat !== 'auto' ? remoteFormat : undefined;\n      if (!remoteUrl || remoteError || this.state.remoteLoading) {\n        if (!remoteUrl) {\n          this.setState({remoteError: {message: 'Incorrect URL'}});\n        }\n        return;\n      }\n      if (!isRemoteDatasetUrl(remoteUrl)) {\n        this.setState({remoteError: {message: 'Incorrect URL'}});\n        return;\n      }\n\n      const fileName = getFileNameForRemoteUrl(remoteUrl, format);\n      const downloading = intl.formatMessage({id: 'fileUploader.downloading'});\n      this.setState({\n        remoteLoading: true,\n        remoteError: null,\n        remoteProgress: {\n          [fileName]: {\n            fileName,\n            percent: 0,\n            message: downloading,\n            error: null\n          }\n        }\n      });\n\n      try {\n        let lastUpdate = 0;\n        const file = await fetchRemoteFileAsKeplerFile(remoteUrl, format, ({percent}) => {\n          const now = Date.now();\n          if (percent < 1 && now - lastUpdate < 100) {\n            return;\n          }\n          lastUpdate = now;\n          this.setState(prev => {\n            const name = Object.keys(prev.remoteProgress)[0] || fileName;\n            return {\n              remoteProgress: {\n                [name]: {\n                  fileName: name,\n                  percent,\n                  message: downloading,\n                  error: null\n                }\n              }\n            };\n          });\n        });\n        this.setState(\n          {\n            files: [file],\n            errorFiles: [],\n            dragOver: false\n          },\n          () => this.props.onFileUpload([file])\n        );\n      } catch (error) {\n        this.setState({\n          remoteLoading: false,\n          remoteProgress: {},\n          remoteError: {\n            message: error instanceof Error ? error.message : `Failed to load ${remoteUrl}`\n          }\n        });\n      }\n    };\n\n    render() {\n      const {\n        dragOver,\n        files,\n        errorFiles,\n        remoteUrl,\n        remoteFormat,\n        remoteError,\n        remoteLoading,\n        remoteProgress\n      } = this.state;\n      const {fileLoading, fileLoadingProgress, theme, intl} = this.props;\n      const {fileExtensions = [], fileFormatNames = []} = this.props;\n      const showFormatSelector = getApplicationConfig().enableRemoteFileFormatSelector;\n      const fileUploadInfoText = `${intl.formatMessage(\n        {\n          id: 'fileUploader.configUploadMessage'\n        },\n        {\n          fileFormatNames: fileFormatNames.map(format => `**${format}**`).join(', ')\n        }\n      )}(${GUIDES_FILE_FORMAT_DOC}).`;\n      return (\n        <StyledFileUpload className=\"file-uploader\" ref={this.frame}>\n          {FileDrop ? (\n            <FileDrop\n              frame={this.frame.current || document}\n              onDragOver={() => this._toggleDragState(true)}\n              onDragLeave={() => this._toggleDragState(false)}\n              onDrop={this._handleFileInput}\n              className=\"file-uploader__file-drop\"\n            >\n              <StyledUploadMessage className=\"file-upload__message\">\n                <Markdown\n                  options={{\n                    overrides: {\n                      a: {\n                        component: LinkRenderer\n                      }\n                    }\n                  }}\n                >\n                  {fileUploadInfoText}\n                </Markdown>\n              </StyledUploadMessage>\n              <StyledFileDrop $dragOver={dragOver}>\n                <StyledDropBody>\n                  <StyledFileTypeFow className=\"file-type-row\">\n                    {fileExtensions.map(ext => (\n                      <FileType key={ext} ext={ext} height=\"50px\" fontSize=\"9px\" />\n                    ))}\n                  </StyledFileTypeFow>\n                  {fileLoading || remoteLoading ? (\n                    <FileUploadProgress\n                      fileLoadingProgress={getCombinedLoadProgress({\n                        fileLoading,\n                        fileLoadingProgress,\n                        remoteProgress\n                      })}\n                      theme={theme}\n                    />\n                  ) : (\n                    <>\n                      <StyledDragNDropIcon\n                        style={{opacity: dragOver ? 0.5 : 1}}\n                        className=\"file-upload-display-message\"\n                      >\n                        <DragNDrop height=\"36px\" />\n                        {errorFiles.length ? (\n                          <WarningMsg>\n                            <FormattedMessage\n                              id={'fileUploader.fileNotSupported'}\n                              values={{errorFiles: errorFiles.join(', ')}}\n                            />\n                          </WarningMsg>\n                        ) : null}\n                      </StyledDragNDropIcon>\n                      {!files.length ? (\n                        <StyledDragFileWrapper>\n                          <StyledActionLine>\n                            <FormattedMessage\n                              id={'fileUploader.dropMessage'}\n                              values={{\n                                browse: (\n                                  <UploadButton key=\"browse\" onUpload={this._handleFileInput}>\n                                    {intl.formatMessage({id: 'fileUploader.browseFiles'})}\n                                  </UploadButton>\n                                )\n                              }}\n                            />\n                          </StyledActionLine>\n                          <StyledRemoteUrlForm\n                            className=\"file-uploader__remote-url\"\n                            onClick={event => event.stopPropagation()}\n                          >\n                            <StyledRemoteUrlRow>\n                              <StyledRemoteUrlInput\n                                type=\"url\"\n                                value={remoteUrl}\n                                aria-label={intl.formatMessage({\n                                  id: 'fileUploader.urlPlaceholder'\n                                })}\n                                placeholder={intl.formatMessage({\n                                  id: 'fileUploader.urlPlaceholder'\n                                })}\n                                onChange={this._onRemoteUrlChange}\n                                onKeyDown={this._onRemoteUrlKeyDown}\n                                disabled={remoteLoading}\n                              />\n                              {showFormatSelector ? (\n                                <StyledRemoteFormatSelect\n                                  className=\"file-uploader__remote-format\"\n                                  aria-label={intl.formatMessage({id: 'fileUploader.format'})}\n                                  value={remoteFormat}\n                                  onChange={this._onRemoteFormatChange}\n                                  disabled={remoteLoading}\n                                >\n                                  {REMOTE_FILE_FORMATS.map(format => (\n                                    <option key={format} value={format}>\n                                      {format === 'auto'\n                                        ? intl.formatMessage({id: 'fileUploader.formatAuto'})\n                                        : format.toUpperCase()}\n                                    </option>\n                                  ))}\n                                </StyledRemoteFormatSelect>\n                              ) : null}\n                              <StyledRemoteFetchButton\n                                type=\"button\"\n                                cta\n                                small\n                                disabled={!remoteUrl || remoteLoading}\n                                onClick={this._handleLoadRemoteFile}\n                              >\n                                <FormattedMessage id={'fileUploader.fetch'} />\n                              </StyledRemoteFetchButton>\n                            </StyledRemoteUrlRow>\n                            {remoteError ? <WarningMsg>{remoteError.message}</WarningMsg> : null}\n                          </StyledRemoteUrlForm>\n                        </StyledDragFileWrapper>\n                      ) : null}\n                    </>\n                  )}\n                </StyledDropBody>\n                {fileLoading || remoteLoading ? null : (\n                  <StyledDisclaimer>\n                    <FormattedMessage id={'fileUploader.disclaimer'} />\n                  </StyledDisclaimer>\n                )}\n              </StyledFileDrop>\n            </FileDrop>\n          ) : null}\n\n          <WarningMsg>\n            {isChrome() ? <FormattedMessage id={'fileUploader.chromeMessage'} /> : ''}\n          </WarningMsg>\n        </StyledFileUpload>\n      );\n    }\n  }\n\n  return injectIntl(FileUpload);\n}\n\nexport default FileUploadFactory;\nexport const FileUpload = FileUploadFactory();\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/file-uploader/upload-button.js

@@ -0,0 +1,51 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useRef } from 'react';
+import styled from 'styled-components';
+var Wrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: inline-block;\n  color: ", ";\n  font-size: 12px;\n  text-decoration: underline;\n\n  &:hover {\n    cursor: pointer;\n    font-weight: 500;\n  }\n"])), function (props) {
+  return props.theme.textColorLT;
+});
+var inputStyle = {
+  display: 'none'
+};
+/*
+Inspired by https://github.com/okonet/react-dropzone/blob/master/src/index.js
+*/
+/** @type {typeof import('./upload-button').UploadButton} */
+var UploadButton = function UploadButton(_ref) {
+  var onUpload = _ref.onUpload,
+    children = _ref.children;
+  var _fileInput = useRef(null);
+  var _onClick = useCallback(function () {
+    if (_fileInput.current) {
+      // @ts-ignore create ref with useRef<HTMLInputElement>
+      _fileInput.current.value = null;
+      // @ts-ignore create ref with useRef<HTMLInputElement>
+      _fileInput.current.click();
+    }
+  }, [_fileInput]);
+  var _onChange = useCallback(function (event) {
+    var files = event.target.files;
+    if (!files) {
+      return;
+    }
+    onUpload(files, event);
+  }, [onUpload]);
+  return /*#__PURE__*/React.createElement(Wrapper, {
+    className: "upload-button"
+  }, /*#__PURE__*/React.createElement("input", {
+    type: "file",
+    ref: _fileInput,
+    style: inputStyle,
+    onChange: _onChange,
+    className: "upload-button-input"
+  }), /*#__PURE__*/React.createElement("span", {
+    className: "file-upload__upload-button-span",
+    onClick: _onClick
+  }, children));
+};
+export default UploadButton;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZUNhbGxiYWNrIiwidXNlUmVmIiwic3R5bGVkIiwiV3JhcHBlciIsImRpdiIsIl90ZW1wbGF0ZU9iamVjdCIsIl90YWdnZWRUZW1wbGF0ZUxpdGVyYWwiLCJwcm9wcyIsInRoZW1lIiwidGV4dENvbG9yTFQiLCJpbnB1dFN0eWxlIiwiZGlzcGxheSIsIlVwbG9hZEJ1dHRvbiIsIl9yZWYiLCJvblVwbG9hZCIsImNoaWxkcmVuIiwiX2ZpbGVJbnB1dCIsIl9vbkNsaWNrIiwiY3VycmVudCIsInZhbHVlIiwiY2xpY2siLCJfb25DaGFuZ2UiLCJldmVudCIsImZpbGVzIiwidGFyZ2V0IiwiY3JlYXRlRWxlbWVudCIsImNsYXNzTmFtZSIsInR5cGUiLCJyZWYiLCJzdHlsZSIsIm9uQ2hhbmdlIiwib25DbGljayJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21tb24vZmlsZS11cGxvYWRlci91cGxvYWQtYnV0dG9uLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgUmVhY3QsIHt1c2VDYWxsYmFjaywgdXNlUmVmfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ3N0eWxlZC1jb21wb25lbnRzJztcblxuY29uc3QgV3JhcHBlciA9IHN0eWxlZC5kaXZgXG4gIGRpc3BsYXk6IGlubGluZS1ibG9jaztcbiAgY29sb3I6ICR7cHJvcHMgPT4gcHJvcHMudGhlbWUudGV4dENvbG9yTFR9O1xuICBmb250LXNpemU6IDEycHg7XG4gIHRleHQtZGVjb3JhdGlvbjogdW5kZXJsaW5lO1xuXG4gICY6aG92ZXIge1xuICAgIGN1cnNvcjogcG9pbnRlcjtcbiAgICBmb250LXdlaWdodDogNTAwO1xuICB9XG5gO1xuY29uc3QgaW5wdXRTdHlsZSA9IHtkaXNwbGF5OiAnbm9uZSd9O1xuXG5pbnRlcmZhY2UgVXBsb2FkQnV0dG9uUHJvcHMge1xuICBvblVwbG9hZDogKGZpbGVzOiBGaWxlTGlzdCwgZXZlbnQ6IGFueSkgPT4gdm9pZDtcbiAgY2hpbGRyZW4/OiBSZWFjdC5SZWFjdE5vZGU7XG59XG5cbi8qXG5JbnNwaXJlZCBieSBodHRwczovL2dpdGh1Yi5jb20vb2tvbmV0L3JlYWN0LWRyb3B6b25lL2Jsb2IvbWFzdGVyL3NyYy9pbmRleC5qc1xuKi9cbi8qKiBAdHlwZSB7dHlwZW9mIGltcG9ydCgnLi91cGxvYWQtYnV0dG9uJykuVXBsb2FkQnV0dG9ufSAqL1xuY29uc3QgVXBsb2FkQnV0dG9uOiBSZWFjdC5GQzxVcGxvYWRCdXR0b25Qcm9wcz4gPSAoe29uVXBsb2FkLCBjaGlsZHJlbn0pID0+IHtcbiAgY29uc3QgX2ZpbGVJbnB1dCA9IHVzZVJlZihudWxsKTtcblxuICBjb25zdCBfb25DbGljayA9IHVzZUNhbGxiYWNrKCgpID0+IHtcbiAgICBpZiAoX2ZpbGVJbnB1dC5jdXJyZW50KSB7XG4gICAgICAvLyBAdHMtaWdub3JlIGNyZWF0ZSByZWYgd2l0aCB1c2VSZWY8SFRNTElucHV0RWxlbWVudD5cbiAgICAgIF9maWxlSW5wdXQuY3VycmVudC52YWx1ZSA9IG51bGw7XG4gICAgICAvLyBAdHMtaWdub3JlIGNyZWF0ZSByZWYgd2l0aCB1c2VSZWY8SFRNTElucHV0RWxlbWVudD5cbiAgICAgIF9maWxlSW5wdXQuY3VycmVudC5jbGljaygpO1xuICAgIH1cbiAgfSwgW19maWxlSW5wdXRdKTtcblxuICBjb25zdCBfb25DaGFuZ2UgPSB1c2VDYWxsYmFjayhcbiAgICBldmVudCA9PiB7XG4gICAgICBjb25zdCB7XG4gICAgICAgIHRhcmdldDoge2ZpbGVzfVxuICAgICAgfSA9IGV2ZW50O1xuXG4gICAgICBpZiAoIWZpbGVzKSB7XG4gICAgICAgIHJldHVybjtcbiAgICAgIH1cblxuICAgICAgb25VcGxvYWQoZmlsZXMsIGV2ZW50KTtcbiAgICB9LFxuICAgIFtvblVwbG9hZF1cbiAgKTtcblxuICByZXR1cm4gKFxuICAgIDxXcmFwcGVyIGNsYXNzTmFtZT1cInVwbG9hZC1idXR0b25cIj5cbiAgICAgIDxpbnB1dFxuICAgICAgICB0eXBlPVwiZmlsZVwiXG4gICAgICAgIHJlZj17X2ZpbGVJbnB1dH1cbiAgICAgICAgc3R5bGU9e2lucHV0U3R5bGV9XG4gICAgICAgIG9uQ2hhbmdlPXtfb25DaGFuZ2V9XG4gICAgICAgIGNsYXNzTmFtZT1cInVwbG9hZC1idXR0b24taW5wdXRcIlxuICAgICAgLz5cbiAgICAgIDxzcGFuIGNsYXNzTmFtZT1cImZpbGUtdXBsb2FkX191cGxvYWQtYnV0dG9uLXNwYW5cIiBvbkNsaWNrPXtfb25DbGlja30+XG4gICAgICAgIHtjaGlsZHJlbn1cbiAgICAgIDwvc3Bhbj5cbiAgICA8L1dyYXBwZXI+XG4gICk7XG59O1xuXG5leHBvcnQgZGVmYXVsdCBVcGxvYWRCdXR0b247XG4iXSwibWFwcGluZ3MiOiI7O0FBQUE7QUFDQTs7QUFFQSxPQUFPQSxLQUFLLElBQUdDLFdBQVcsRUFBRUMsTUFBTSxRQUFPLE9BQU87QUFDaEQsT0FBT0MsTUFBTSxNQUFNLG1CQUFtQjtBQUV0QyxJQUFNQyxPQUFPLEdBQUdELE1BQU0sQ0FBQ0UsR0FBRyxDQUFBQyxlQUFBLEtBQUFBLGVBQUEsR0FBQUMsc0JBQUEseUtBRWYsVUFBQUMsS0FBSztFQUFBLE9BQUlBLEtBQUssQ0FBQ0MsS0FBSyxDQUFDQyxXQUFXO0FBQUEsRUFRMUM7QUFDRCxJQUFNQyxVQUFVLEdBQUc7RUFBQ0MsT0FBTyxFQUFFO0FBQU0sQ0FBQztBQU9wQztBQUNBO0FBQ0E7QUFDQTtBQUNBLElBQU1DLFlBQXlDLEdBQUcsU0FBNUNBLFlBQXlDQSxDQUFBQyxJQUFBLEVBQTZCO0VBQUEsSUFBeEJDLFFBQVEsR0FBQUQsSUFBQSxDQUFSQyxRQUFRO0lBQUVDLFFBQVEsR0FBQUYsSUFBQSxDQUFSRSxRQUFRO0VBQ3BFLElBQU1DLFVBQVUsR0FBR2YsTUFBTSxDQUFDLElBQUksQ0FBQztFQUUvQixJQUFNZ0IsUUFBUSxHQUFHakIsV0FBVyxDQUFDLFlBQU07SUFDakMsSUFBSWdCLFVBQVUsQ0FBQ0UsT0FBTyxFQUFFO01BQ3RCO01BQ0FGLFVBQVUsQ0FBQ0UsT0FBTyxDQUFDQyxLQUFLLEdBQUcsSUFBSTtNQUMvQjtNQUNBSCxVQUFVLENBQUNFLE9BQU8sQ0FBQ0UsS0FBSyxDQUFDLENBQUM7SUFDNUI7RUFDRixDQUFDLEVBQUUsQ0FBQ0osVUFBVSxDQUFDLENBQUM7RUFFaEIsSUFBTUssU0FBUyxHQUFHckIsV0FBVyxDQUMzQixVQUFBc0IsS0FBSyxFQUFJO0lBQ1AsSUFDV0MsS0FBSyxHQUNaRCxLQUFLLENBRFBFLE1BQU0sQ0FBR0QsS0FBSztJQUdoQixJQUFJLENBQUNBLEtBQUssRUFBRTtNQUNWO0lBQ0Y7SUFFQVQsUUFBUSxDQUFDUyxLQUFLLEVBQUVELEtBQUssQ0FBQztFQUN4QixDQUFDLEVBQ0QsQ0FBQ1IsUUFBUSxDQUNYLENBQUM7RUFFRCxvQkFDRWYsS0FBQSxDQUFBMEIsYUFBQSxDQUFDdEIsT0FBTztJQUFDdUIsU0FBUyxFQUFDO0VBQWUsZ0JBQ2hDM0IsS0FBQSxDQUFBMEIsYUFBQTtJQUNFRSxJQUFJLEVBQUMsTUFBTTtJQUNYQyxHQUFHLEVBQUVaLFVBQVc7SUFDaEJhLEtBQUssRUFBRW5CLFVBQVc7SUFDbEJvQixRQUFRLEVBQUVULFNBQVU7SUFDcEJLLFNBQVMsRUFBQztFQUFxQixDQUNoQyxDQUFDLGVBQ0YzQixLQUFBLENBQUEwQixhQUFBO0lBQU1DLFNBQVMsRUFBQyxpQ0FBaUM7SUFBQ0ssT0FBTyxFQUFFZDtFQUFTLEdBQ2pFRixRQUNHLENBQ0MsQ0FBQztBQUVkLENBQUM7QUFFRCxlQUFlSCxZQUFZIiwiaWdub3JlTGlzdCI6W119

package/dist/esm/common/flex-container.js

@@ -0,0 +1,10 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import styled from 'styled-components';
+export var FlexContainer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  gap: 8px;\n  flex-wrap: wrap;\n"])));
+export var FlexColContainer = styled(FlexContainer)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  flex-direction: column;\n"])));
+export var FlexContainerGrow = styled(FlexContainer)(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  flex-grow: 1;\n"])));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzdHlsZWQiLCJGbGV4Q29udGFpbmVyIiwiZGl2IiwiX3RlbXBsYXRlT2JqZWN0IiwiX3RhZ2dlZFRlbXBsYXRlTGl0ZXJhbCIsIkZsZXhDb2xDb250YWluZXIiLCJfdGVtcGxhdGVPYmplY3QyIiwiRmxleENvbnRhaW5lckdyb3ciLCJfdGVtcGxhdGVPYmplY3QzIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1vbi9mbGV4LWNvbnRhaW5lci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgc3R5bGVkIGZyb20gJ3N0eWxlZC1jb21wb25lbnRzJztcblxuZXhwb3J0IGNvbnN0IEZsZXhDb250YWluZXIgPSBzdHlsZWQuZGl2YFxuICBkaXNwbGF5OiBmbGV4O1xuICBnYXA6IDhweDtcbiAgZmxleC13cmFwOiB3cmFwO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhDb2xDb250YWluZXIgPSBzdHlsZWQoRmxleENvbnRhaW5lcilgXG4gIGZsZXgtZGlyZWN0aW9uOiBjb2x1bW47XG5gO1xuXG5leHBvcnQgY29uc3QgRmxleENvbnRhaW5lckdyb3cgPSBzdHlsZWQoRmxleENvbnRhaW5lcilgXG4gIGZsZXgtZ3JvdzogMTtcbmA7XG4iXSwibWFwcGluZ3MiOiI7O0FBQUE7QUFDQTs7QUFFQSxPQUFPQSxNQUFNLE1BQU0sbUJBQW1CO0FBRXRDLE9BQU8sSUFBTUMsYUFBYSxHQUFHRCxNQUFNLENBQUNFLEdBQUcsQ0FBQUMsZUFBQSxLQUFBQSxlQUFBLEdBQUFDLHNCQUFBLDZEQUl0QztBQUVELE9BQU8sSUFBTUMsZ0JBQWdCLEdBQUdMLE1BQU0sQ0FBQ0MsYUFBYSxDQUFDLENBQUFLLGdCQUFBLEtBQUFBLGdCQUFBLEdBQUFGLHNCQUFBLHFDQUVwRDtBQUVELE9BQU8sSUFBTUcsaUJBQWlCLEdBQUdQLE1BQU0sQ0FBQ0MsYUFBYSxDQUFDLENBQUFPLGdCQUFBLEtBQUFBLGdCQUFBLEdBQUFKLHNCQUFBLDJCQUVyRCIsImlnbm9yZUxpc3QiOltdfQ==