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

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

@@ -0,0 +1,227 @@
+"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(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, FileDrop);
+    _this = _super.call(this, props);
+    (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);
+      }
+    });
+    _this.frameDragCounter = 0;
+    _this.state = {
+      draggingOverFrame: false,
+      draggingOverTarget: false
+    };
+    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/components/common/file-uploader/file-drop.js"],"names":["FileDrop","props","frameDragCounter","setState","draggingOverFrame","draggingOverTarget","event","preventDefault","eventHasFiles","type","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\n/** @typedef {import('./file-drop').FileDropProps} FileDropProps */\n\n/** @augments React.PureComponent<FileDropProps> */\nclass FileDrop extends React.PureComponent {\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  constructor(props) {\n    super(props);\n    this.frameDragCounter = 0;\n    this.state = {draggingOverFrame: false, draggingOverTarget: false};\n  }\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/components/common/file-uploader/file-upload-progress.js

@@ -0,0 +1,102 @@
+"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 _progressBar = _interopRequireDefault(require("../progress-bar"));
+
+var _styledComponents2 = require("../styled-components");
+
+var _utils = require("../../../utils/utils");
+
+var _templateObject, _templateObject2, _templateObject3;
+
+/** @typedef {import('./file-upload-progress').FileUploadProgressProps} FileUploadProgressProps*/
+var StyledFileProgress = _styledComponents["default"].div.attrs({
+  className: 'file-upload__progress'
+})(_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/components/common/file-uploader/file-upload-progress.js"],"names":["StyledFileProgress","styled","div","attrs","className","props","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;;;;AAEA;AAEA,IAAMA,kBAAkB,GAAGC,6BAAOC,GAAP,CAAWC,KAAX,CAAiB;AAC1CC,EAAAA,SAAS,EAAE;AAD+B,CAAjB,CAAH,8aAGb,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYC,WAAhB;AAAA,CAHQ,CAAxB;;AA0BA,IAAMC,qBAAqB,GAAGP,6BAAOC,GAAP,CAAWC,KAAX,CAAiB;AAC7CC,EAAAA,SAAS,EAAE;AADkC,CAAjB,CAAH,2GAA3B;;AAMA,IAAMK,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;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,IAAMG,cAAc,GAAG,SAAjBA,cAAiB,OAAgD;AAAA,MAA9CC,OAA8C,QAA9CA,OAA8C;AAAA,MAArCC,QAAqC,QAArCA,QAAqC;AAAA,MAA3BL,OAA2B,QAA3BA,OAA2B;AAAA,MAAlBM,KAAkB,QAAlBA,KAAkB;AAAA,MAAXX,KAAW,QAAXA,KAAW;AACrE,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;AAsBA;;;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 ProgressBar from '../progress-bar';\nimport {TruncatedTitleText} from 'components/common/styled-components';\nimport {getError} from 'utils/utils';\n\n/** @typedef {import('./file-upload-progress').FileUploadProgressProps} FileUploadProgressProps*/\n\nconst StyledFileProgress = styled.div.attrs({\n  className: 'file-upload__progress'\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\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}) => {\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\n/** @type {React.FunctionComponent<FileUploadProgressProps>} */\nconst FileUploadProgress = ({fileLoadingProgress, theme}) => (\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"]}