@kepler.gl/components 3.0.0-alpha.0

package/dist/common/file-uploader/file-drop.js

@@ -0,0 +1,252 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _window = _interopRequireDefault(require("global/window"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/** @typedef {import('./file-drop').FileDropProps} FileDropProps */
+
+/** @augments React.PureComponent<FileDropProps> */
+var FileDrop = /*#__PURE__*/function (_React$PureComponent) {
+  (0, _inherits2["default"])(FileDrop, _React$PureComponent);
+
+  var _super = _createSuper(FileDrop);
+
+  function FileDrop() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, FileDrop);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "frameDragCounter", 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", {
+      draggingOverFrame: false,
+      draggingOverTarget: false
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "resetDragging", function () {
+      _this.frameDragCounter = 0;
+
+      _this.setState({
+        draggingOverFrame: false,
+        draggingOverTarget: false
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleWindowDragOverOrDrop", function (event) {
+      // This prevents the browser from trying to load whatever file the user dropped on the window
+      event.preventDefault();
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleFrameDrag", function (event) {
+      // Only allow dragging of files
+      if (!FileDrop.eventHasFiles(event)) return; // We are listening for events on the 'frame', so every time the user drags over any element in the frame's tree,
+      // the event bubbles up to the frame. By keeping count of how many "dragenters" we get, we can tell if they are still
+      // "draggingOverFrame" (b/c you get one "dragenter" initially, and one "dragenter"/one "dragleave" for every bubble)
+      // This is far better than a "dragover" handler, which would be calling `setState` continuously.
+
+      _this.frameDragCounter += event.type === 'dragenter' ? 1 : -1;
+
+      if (_this.frameDragCounter === 1) {
+        _this.setState({
+          draggingOverFrame: true
+        });
+
+        if (_this.props.onFrameDragEnter) _this.props.onFrameDragEnter(event);
+        return;
+      }
+
+      if (_this.frameDragCounter === 0) {
+        _this.setState({
+          draggingOverFrame: false
+        });
+
+        if (_this.props.onFrameDragLeave) _this.props.onFrameDragLeave(event);
+        return;
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleFrameDrop", function (event) {
+      event.preventDefault();
+
+      if (!_this.state.draggingOverTarget) {
+        _this.resetDragging();
+
+        if (_this.props.onFrameDrop) _this.props.onFrameDrop(event);
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleDragOver", function (event) {
+      if (FileDrop.eventHasFiles(event)) {
+        _this.setState({
+          draggingOverTarget: true
+        });
+
+        if (!FileDrop.isIE() && _this.props.dropEffect) event.dataTransfer.dropEffect = _this.props.dropEffect;
+        if (_this.props.onDragOver) _this.props.onDragOver(event);
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleDragLeave", function (event) {
+      _this.setState({
+        draggingOverTarget: false
+      });
+
+      if (_this.props.onDragLeave) _this.props.onDragLeave(event);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleDrop", function (event) {
+      if (_this.props.onDrop && FileDrop.eventHasFiles(event)) {
+        var files = event.dataTransfer ? event.dataTransfer.files : null;
+
+        _this.props.onDrop(files, event);
+      }
+
+      _this.resetDragging();
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "stopFrameListeners", function (frame) {
+      if (frame) {
+        frame.removeEventListener('dragenter', _this.handleFrameDrag);
+        frame.removeEventListener('dragleave', _this.handleFrameDrag);
+        frame.removeEventListener('drop', _this.handleFrameDrop);
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "startFrameListeners", function (frame) {
+      if (frame) {
+        frame.addEventListener('dragenter', _this.handleFrameDrag);
+        frame.addEventListener('dragleave', _this.handleFrameDrag);
+        frame.addEventListener('drop', _this.handleFrameDrop);
+      }
+    });
+    return _this;
+  }
+
+  (0, _createClass2["default"])(FileDrop, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.startFrameListeners(this.props.frame);
+      this.resetDragging();
+
+      _window["default"].addEventListener('dragover', this.handleWindowDragOverOrDrop);
+
+      _window["default"].addEventListener('drop', this.handleWindowDragOverOrDrop);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (prevProps.frame !== this.props.frame) {
+        this.resetDragging();
+        this.stopFrameListeners(prevProps.frame);
+        this.startFrameListeners(this.props.frame);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.stopFrameListeners(this.props.frame);
+
+      _window["default"].removeEventListener('dragover', this.handleWindowDragOverOrDrop);
+
+      _window["default"].removeEventListener('drop', this.handleWindowDragOverOrDrop);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          children = _this$props.children,
+          className = _this$props.className,
+          targetClassName = _this$props.targetClassName,
+          draggingOverFrameClassName = _this$props.draggingOverFrameClassName,
+          draggingOverTargetClassName = _this$props.draggingOverTargetClassName;
+      var _this$state = this.state,
+          draggingOverTarget = _this$state.draggingOverTarget,
+          draggingOverFrame = _this$state.draggingOverFrame;
+      var fileDropTargetClassName = targetClassName;
+      if (draggingOverFrame) fileDropTargetClassName += " ".concat(draggingOverFrameClassName);
+      if (draggingOverTarget) fileDropTargetClassName += " ".concat(draggingOverTargetClassName);
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: className,
+        onDragOver: this.handleDragOver,
+        onDragLeave: this.handleDragLeave,
+        onDrop: this.handleDrop
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: fileDropTargetClassName
+      }, children));
+    }
+  }]);
+  return FileDrop;
+}(_react["default"].PureComponent);
+
+(0, _defineProperty2["default"])(FileDrop, "isIE", function () {
+  return _window["default"] && _window["default"].navigator && ((_window["default"].navigator.userAgent || []).includes('MSIE') || (_window["default"].navigator.appVersion || []).includes('Trident/'));
+});
+(0, _defineProperty2["default"])(FileDrop, "eventHasFiles", function (event) {
+  // In most browsers this is an array, but in IE11 it's an Object :(
+  var hasFiles = false;
+
+  if (event.dataTransfer) {
+    var types = event.dataTransfer.types;
+
+    for (var keyOrIndex in types) {
+      if (types[keyOrIndex] === 'Files') {
+        hasFiles = true;
+        break;
+      }
+    }
+  }
+
+  return hasFiles;
+});
+(0, _defineProperty2["default"])(FileDrop, "defaultProps", {
+  dropEffect: 'copy',
+  frame: _window["default"] ? _window["default"].document : undefined,
+  className: 'file-drop',
+  targetClassName: 'file-drop-target',
+  draggingOverFrameClassName: 'file-drop-dragging-over-frame',
+  draggingOverTargetClassName: 'file-drop-dragging-over-target'
+});
+var _default = FileDrop;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/common/file-uploader/file-drop.tsx"],"names":["FileDrop","draggingOverFrame","draggingOverTarget","frameDragCounter","setState","event","preventDefault","eventHasFiles","type","props","onFrameDragEnter","onFrameDragLeave","state","resetDragging","onFrameDrop","isIE","dropEffect","dataTransfer","onDragOver","onDragLeave","onDrop","files","frame","removeEventListener","handleFrameDrag","handleFrameDrop","addEventListener","startFrameListeners","window","handleWindowDragOverOrDrop","prevProps","stopFrameListeners","children","className","targetClassName","draggingOverFrameClassName","draggingOverTargetClassName","fileDropTargetClassName","handleDragOver","handleDragLeave","handleDrop","React","PureComponent","navigator","userAgent","includes","appVersion","hasFiles","types","keyOrIndex","document","undefined"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/**\n * Copied from https://github.com/sarink/react-file-drop\n * For React 16.8 compatibility\n */\nimport React from 'react';\nimport window from 'global/window';\n\nexport type FileDropProps = {\n  dropEffect?: 'copy' | 'move' | 'link' | 'none';\n  frame?: typeof document | typeof window | HTMLElement;\n  className?: string;\n  targetClassName?: string;\n  draggingOverFrameClassName?: string;\n  draggingOverTargetClassName?: string;\n  onDragOver?: (event: any) => void;\n  onDragLeave?: (event: any) => void;\n  onDrop?: (fileList: FileList, event: any) => void;\n  onFrameDragEnter?: (event: any) => void;\n  onFrameDragLeave?: (event: any) => void;\n  onFrameDrop?: (event: any) => void;\n};\n\n/** @typedef {import('./file-drop').FileDropProps} FileDropProps */\n\n/** @augments React.PureComponent<FileDropProps> */\nclass FileDrop extends React.PureComponent<FileDropProps> {\n  static isIE = () =>\n    window &&\n    window.navigator &&\n    ((window.navigator.userAgent || []).includes('MSIE') ||\n      (window.navigator.appVersion || []).includes('Trident/'));\n\n  static eventHasFiles = event => {\n    // In most browsers this is an array, but in IE11 it's an Object :(\n\n    let hasFiles = false;\n    if (event.dataTransfer) {\n      const types = event.dataTransfer.types;\n      for (const keyOrIndex in types) {\n        if (types[keyOrIndex] === 'Files') {\n          hasFiles = true;\n          break;\n        }\n      }\n    }\n    return hasFiles;\n  };\n\n  static defaultProps = {\n    dropEffect: 'copy',\n    frame: window ? window.document : undefined,\n    className: 'file-drop',\n    targetClassName: 'file-drop-target',\n    draggingOverFrameClassName: 'file-drop-dragging-over-frame',\n    draggingOverTargetClassName: 'file-drop-dragging-over-target'\n  };\n\n  frameDragCounter = 0;\n  state = {draggingOverFrame: false, draggingOverTarget: false};\n\n  componentDidMount() {\n    this.startFrameListeners(this.props.frame);\n    this.resetDragging();\n    window.addEventListener('dragover', this.handleWindowDragOverOrDrop);\n    window.addEventListener('drop', this.handleWindowDragOverOrDrop);\n  }\n\n  componentDidUpdate(prevProps) {\n    if (prevProps.frame !== this.props.frame) {\n      this.resetDragging();\n      this.stopFrameListeners(prevProps.frame);\n      this.startFrameListeners(this.props.frame);\n    }\n  }\n\n  componentWillUnmount() {\n    this.stopFrameListeners(this.props.frame);\n    window.removeEventListener('dragover', this.handleWindowDragOverOrDrop);\n    window.removeEventListener('drop', this.handleWindowDragOverOrDrop);\n  }\n\n  resetDragging = () => {\n    this.frameDragCounter = 0;\n    this.setState({draggingOverFrame: false, draggingOverTarget: false});\n  };\n\n  handleWindowDragOverOrDrop = event => {\n    // This prevents the browser from trying to load whatever file the user dropped on the window\n    event.preventDefault();\n  };\n\n  handleFrameDrag = event => {\n    // Only allow dragging of files\n    if (!FileDrop.eventHasFiles(event)) return;\n\n    // We are listening for events on the 'frame', so every time the user drags over any element in the frame's tree,\n    // the event bubbles up to the frame. By keeping count of how many \"dragenters\" we get, we can tell if they are still\n    // \"draggingOverFrame\" (b/c you get one \"dragenter\" initially, and one \"dragenter\"/one \"dragleave\" for every bubble)\n    // This is far better than a \"dragover\" handler, which would be calling `setState` continuously.\n    this.frameDragCounter += event.type === 'dragenter' ? 1 : -1;\n\n    if (this.frameDragCounter === 1) {\n      this.setState({draggingOverFrame: true});\n      if (this.props.onFrameDragEnter) this.props.onFrameDragEnter(event);\n      return;\n    }\n\n    if (this.frameDragCounter === 0) {\n      this.setState({draggingOverFrame: false});\n      if (this.props.onFrameDragLeave) this.props.onFrameDragLeave(event);\n      return;\n    }\n  };\n\n  handleFrameDrop = event => {\n    event.preventDefault();\n    if (!this.state.draggingOverTarget) {\n      this.resetDragging();\n      if (this.props.onFrameDrop) this.props.onFrameDrop(event);\n    }\n  };\n\n  handleDragOver = event => {\n    if (FileDrop.eventHasFiles(event)) {\n      this.setState({draggingOverTarget: true});\n      if (!FileDrop.isIE() && this.props.dropEffect)\n        event.dataTransfer.dropEffect = this.props.dropEffect;\n      if (this.props.onDragOver) this.props.onDragOver(event);\n    }\n  };\n\n  handleDragLeave = event => {\n    this.setState({draggingOverTarget: false});\n    if (this.props.onDragLeave) this.props.onDragLeave(event);\n  };\n\n  handleDrop = event => {\n    if (this.props.onDrop && FileDrop.eventHasFiles(event)) {\n      const files = event.dataTransfer ? event.dataTransfer.files : null;\n      this.props.onDrop(files, event);\n    }\n    this.resetDragging();\n  };\n\n  stopFrameListeners = frame => {\n    if (frame) {\n      frame.removeEventListener('dragenter', this.handleFrameDrag);\n      frame.removeEventListener('dragleave', this.handleFrameDrag);\n      frame.removeEventListener('drop', this.handleFrameDrop);\n    }\n  };\n\n  startFrameListeners = frame => {\n    if (frame) {\n      frame.addEventListener('dragenter', this.handleFrameDrag);\n      frame.addEventListener('dragleave', this.handleFrameDrag);\n      frame.addEventListener('drop', this.handleFrameDrop);\n    }\n  };\n\n  render() {\n    const {\n      children,\n      className,\n      targetClassName,\n      draggingOverFrameClassName,\n      draggingOverTargetClassName\n    } = this.props;\n    const {draggingOverTarget, draggingOverFrame} = this.state;\n\n    let fileDropTargetClassName = targetClassName;\n    if (draggingOverFrame) fileDropTargetClassName += ` ${draggingOverFrameClassName}`;\n    if (draggingOverTarget) fileDropTargetClassName += ` ${draggingOverTargetClassName}`;\n\n    return (\n      <div\n        className={className}\n        onDragOver={this.handleDragOver}\n        onDragLeave={this.handleDragLeave}\n        onDrop={this.handleDrop}\n      >\n        <div className={fileDropTargetClassName}>{children}</div>\n      </div>\n    );\n  }\n}\n\nexport default FileDrop;\n"]}

package/dist/common/file-uploader/file-upload-progress.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { FileLoadingProgress } from '@kepler.gl/types';
+declare const _default: React.ForwardRefExoticComponent<{
+    fileLoadingProgress: FileLoadingProgress;
+} & {
+    theme?: any;
+}>;
+export default _default;

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

@@ -0,0 +1,123 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _progressBar = _interopRequireDefault(require("../progress-bar"));
+
+var _styledComponents2 = require("../styled-components");
+
+var _utils = require("@kepler.gl/utils");
+
+var _templateObject, _templateObject2, _templateObject3;
+
+var StyledFileProgress = _styledComponents["default"].div.attrs(function (props) {
+  return {
+    className: (0, _classnames["default"])('file-upload__progress', props.className)
+  };
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  font-size: 12px;\n  margin-top: 12px;\n  border-image: initial;\n  padding: 8px 12px;\n\n  .top-row {\n    display: flex;\n    justify-content: space-between;\n  }\n\n  .file-name {\n    font-weight: 500;\n  }\n  .middle-row {\n    margin-top: 6px;\n  }\n  .bottom-row {\n    margin-top: 6px;\n    text-align: start;\n  }\n"])), function (props) {
+  return props.theme.textColorLT;
+});
+
+var StyledProgressWrapper = _styledComponents["default"].div.attrs({
+  className: 'file-upload__progress__wrapper'
+})(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  width: 400px;\n"])));
+
+var StyledContainer = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  width: 100%;\n  display: flex;\n  justify-content: center;\n"])));
+
+var formatPercent = function formatPercent(percent) {
+  return "".concat(Math.floor(percent * 100), "%");
+};
+
+/**
+ * @param {object} params
+ * @param {string} params.message
+ * @param {string} params.fileName
+ * @param {number} params.percent
+ * @param {any} params.error
+ * @param {object} params.theme
+ */
+var UploadProgress = function UploadProgress(_ref) {
+  var message = _ref.message,
+      fileName = _ref.fileName,
+      percent = _ref.percent,
+      error = _ref.error,
+      theme = _ref.theme;
+  var percentStr = formatPercent(percent);
+  var barColor = error ? theme.errorColor : theme.activeColorLT;
+  return /*#__PURE__*/_react["default"].createElement(StyledFileProgress, {
+    className: "file-upload-progress__message"
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: "top-row"
+  }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.TruncatedTitleText, {
+    className: "file-name",
+    title: fileName
+  }, fileName), /*#__PURE__*/_react["default"].createElement("div", {
+    className: "percent"
+  }, percentStr)), /*#__PURE__*/_react["default"].createElement("div", {
+    className: "middle-row"
+  }, /*#__PURE__*/_react["default"].createElement(_progressBar["default"], {
+    percent: percentStr,
+    barColor: barColor,
+    isLoading: true,
+    theme: theme
+  })), /*#__PURE__*/_react["default"].createElement("div", {
+    className: "bottom-row",
+    style: {
+      color: error ? theme.errorColor : theme.textColorLT
+    }
+  }, error ? (0, _utils.getError)(error) : message));
+};
+
+/** @type {React.FunctionComponent<FileUploadProgressProps>} */
+var FileUploadProgress = function FileUploadProgress(_ref2) {
+  var fileLoadingProgress = _ref2.fileLoadingProgress,
+      theme = _ref2.theme;
+  return /*#__PURE__*/_react["default"].createElement(StyledContainer, null, /*#__PURE__*/_react["default"].createElement(StyledProgressWrapper, null, Object.values(fileLoadingProgress).map(function (item) {
+    return /*#__PURE__*/_react["default"].createElement(UploadProgress, (0, _extends2["default"])({}, item, {
+      key: item.fileName,
+      theme: theme
+    }));
+  })));
+};
+
+var _default = (0, _styledComponents.withTheme)(FileUploadProgress);
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/common/file-uploader/file-upload-progress.tsx"],"names":["StyledFileProgress","styled","div","attrs","props","className","theme","textColorLT","StyledProgressWrapper","StyledContainer","formatPercent","percent","Math","floor","UploadProgress","message","fileName","error","percentStr","barColor","errorColor","activeColorLT","color","FileUploadProgress","fileLoadingProgress","Object","values","map","item"],"mappings":";;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAGA,IAAMA,kBAAkB,GAAGC,6BAAOC,GAAP,CAAWC,KAAX,CAAiB,UAAAC,KAAK;AAAA,SAAK;AACpDC,IAAAA,SAAS,EAAE,4BAAW,uBAAX,EAAoCD,KAAK,CAACC,SAA1C;AADyC,GAAL;AAAA,CAAtB,CAAH,8aAGb,UAAAD,KAAK;AAAA,SAAIA,KAAK,CAACE,KAAN,CAAYC,WAAhB;AAAA,CAHQ,CAAxB;;AA0BA,IAAMC,qBAAqB,GAAGP,6BAAOC,GAAP,CAAWC,KAAX,CAAiB;AAC7CE,EAAAA,SAAS,EAAE;AADkC,CAAjB,CAAH,2GAA3B;;AAMA,IAAMI,eAAe,GAAGR,6BAAOC,GAAV,wJAArB;;AAMA,IAAMQ,aAAa,GAAG,SAAhBA,aAAgB,CAAAC,OAAO;AAAA,mBAAOC,IAAI,CAACC,KAAL,CAAWF,OAAO,GAAG,GAArB,CAAP;AAAA,CAA7B;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMG,cAAc,GAAG,SAAjBA,cAAiB,OAAqE;AAAA,MAAnEC,OAAmE,QAAnEA,OAAmE;AAAA,MAA1DC,QAA0D,QAA1DA,QAA0D;AAAA,MAAhDL,OAAgD,QAAhDA,OAAgD;AAAA,MAAvCM,KAAuC,QAAvCA,KAAuC;AAAA,MAAhCX,KAAgC,QAAhCA,KAAgC;AAC1F,MAAMY,UAAU,GAAGR,aAAa,CAACC,OAAD,CAAhC;AACA,MAAMQ,QAAQ,GAAGF,KAAK,GAAGX,KAAK,CAACc,UAAT,GAAsBd,KAAK,CAACe,aAAlD;AAEA,sBACE,gCAAC,kBAAD;AAAoB,IAAA,SAAS,EAAC;AAA9B,kBACE;AAAK,IAAA,SAAS,EAAC;AAAf,kBACE,gCAAC,qCAAD;AAAoB,IAAA,SAAS,EAAC,WAA9B;AAA0C,IAAA,KAAK,EAAEL;AAAjD,KACGA,QADH,CADF,eAIE;AAAK,IAAA,SAAS,EAAC;AAAf,KAA0BE,UAA1B,CAJF,CADF,eAOE;AAAK,IAAA,SAAS,EAAC;AAAf,kBACE,gCAAC,uBAAD;AAAa,IAAA,OAAO,EAAEA,UAAtB;AAAkC,IAAA,QAAQ,EAAEC,QAA5C;AAAsD,IAAA,SAAS,MAA/D;AAAgE,IAAA,KAAK,EAAEb;AAAvE,IADF,CAPF,eAUE;AAAK,IAAA,SAAS,EAAC,YAAf;AAA4B,IAAA,KAAK,EAAE;AAACgB,MAAAA,KAAK,EAAEL,KAAK,GAAGX,KAAK,CAACc,UAAT,GAAsBd,KAAK,CAACC;AAAzC;AAAnC,KACGU,KAAK,GAAG,qBAASA,KAAT,CAAH,GAAqBF,OAD7B,CAVF,CADF;AAgBD,CApBD;;AA2BA;AACA,IAAMQ,kBAAkB,GAAG,SAArBA,kBAAqB;AAAA,MAAEC,mBAAF,SAAEA,mBAAF;AAAA,MAAuBlB,KAAvB,SAAuBA,KAAvB;AAAA,sBACzB,gCAAC,eAAD,qBACE,gCAAC,qBAAD,QACGmB,MAAM,CAACC,MAAP,CAAcF,mBAAd,EAAmCG,GAAnC,CAAuC,UAAAC,IAAI;AAAA,wBAC1C,gCAAC,cAAD,gCAAoBA,IAApB;AAA0B,MAAA,GAAG,EAAEA,IAAI,CAACZ,QAApC;AAA8C,MAAA,KAAK,EAAEV;AAArD,OAD0C;AAAA,GAA3C,CADH,CADF,CADyB;AAAA,CAA3B;;eAUe,iCAAUiB,kBAAV,C","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React from 'react';\nimport styled, {withTheme} from 'styled-components';\nimport classnames from 'classnames';\nimport ProgressBar from '../progress-bar';\nimport {TruncatedTitleText} from '../styled-components';\nimport {getError} from '@kepler.gl/utils';\nimport {FileLoadingProgress} from '@kepler.gl/types';\n\nconst StyledFileProgress = styled.div.attrs(props => ({\n  className: classnames('file-upload__progress', props.className)\n}))`\n  color: ${props => props.theme.textColorLT};\n  font-size: 12px;\n  margin-top: 12px;\n  border-image: initial;\n  padding: 8px 12px;\n\n  .top-row {\n    display: flex;\n    justify-content: space-between;\n  }\n\n  .file-name {\n    font-weight: 500;\n  }\n  .middle-row {\n    margin-top: 6px;\n  }\n  .bottom-row {\n    margin-top: 6px;\n    text-align: start;\n  }\n`;\n\nconst StyledProgressWrapper = styled.div.attrs({\n  className: 'file-upload__progress__wrapper'\n})`\n  width: 400px;\n`;\n\nconst StyledContainer = styled.div`\n  width: 100%;\n  display: flex;\n  justify-content: center;\n`;\n\nconst formatPercent = percent => `${Math.floor(percent * 100)}%`;\n\ninterface UploadProgressProps {\n  message?: string;\n  fileName?: string;\n  percent: number;\n  error?: any;\n  theme: any;\n}\n\n/**\n * @param {object} params\n * @param {string} params.message\n * @param {string} params.fileName\n * @param {number} params.percent\n * @param {any} params.error\n * @param {object} params.theme\n */\nconst UploadProgress = ({message, fileName, percent, error, theme}: UploadProgressProps) => {\n  const percentStr = formatPercent(percent);\n  const barColor = error ? theme.errorColor : theme.activeColorLT;\n\n  return (\n    <StyledFileProgress className=\"file-upload-progress__message\">\n      <div className=\"top-row\">\n        <TruncatedTitleText className=\"file-name\" title={fileName}>\n          {fileName}\n        </TruncatedTitleText>\n        <div className=\"percent\">{percentStr}</div>\n      </div>\n      <div className=\"middle-row\">\n        <ProgressBar percent={percentStr} barColor={barColor} isLoading theme={theme} />\n      </div>\n      <div className=\"bottom-row\" style={{color: error ? theme.errorColor : theme.textColorLT}}>\n        {error ? getError(error) : message}\n      </div>\n    </StyledFileProgress>\n  );\n};\n\ninterface FileUploadProgressProps {\n  fileLoadingProgress: FileLoadingProgress;\n  theme: any;\n}\n\n/** @type {React.FunctionComponent<FileUploadProgressProps>} */\nconst FileUploadProgress = ({fileLoadingProgress, theme}: FileUploadProgressProps) => (\n  <StyledContainer>\n    <StyledProgressWrapper>\n      {Object.values(fileLoadingProgress).map(item => (\n        <UploadProgress {...item} key={item.fileName} theme={theme} />\n      ))}\n    </StyledProgressWrapper>\n  </StyledContainer>\n);\n\nexport default withTheme(FileUploadProgress);\n"]}

package/dist/common/file-uploader/file-upload.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl';
+import { FileLoading, FileLoadingProgress } from '@kepler.gl/types';
+export declare const WarningMsg: import("styled-components").StyledComponent<"span", any, {}, never>;
+declare type FileUploadProps = {
+    onFileUpload: (files: File[]) => void;
+    fileLoading: FileLoading | false;
+    fileLoadingProgress: FileLoadingProgress;
+    theme: object;
+    /** A list of names of supported formats suitable to present to user */
+    fileFormatNames?: string[];
+    /** A list of typically 3 letter extensions (without '.') for file matching */
+    fileExtensions?: string[];
+    /** Set to true if app wants to do its own file filtering */
+    disableExtensionFilter?: boolean;
+} & WrappedComponentProps;
+declare function FileUploadFactory(): React.ForwardRefExoticComponent<import("react-intl").Omit<FileUploadProps, "intl"> & {
+    forwardedRef?: React.Ref<any> | undefined;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<FileUploadProps>;
+};
+export default FileUploadFactory;
+export declare const FileUpload: React.ForwardRefExoticComponent<import("react-intl").Omit<FileUploadProps, "intl"> & {
+    forwardedRef?: React.Ref<any> | undefined;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<FileUploadProps>;
+};