@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.7

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

@@ -0,0 +1,170 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Copied from https://github.com/sarink/react-file-drop
+ * For React 16.8 compatibility
+ */
+import React, { useCallback, useEffect, useState, useRef } from 'react';
+import Window from 'global/window';
+var isIE = function isIE() {
+  return Window && Window.navigator && ((Window.navigator.userAgent || []).includes('MSIE') || (Window.navigator.appVersion || []).includes('Trident/'));
+};
+var eventHasFiles = function eventHasFiles(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;
+};
+var FileDrop = function FileDrop(_ref) {
+  var _ref$dropEffect = _ref.dropEffect,
+    dropEffect = _ref$dropEffect === void 0 ? 'copy' : _ref$dropEffect,
+    _ref$frame = _ref.frame,
+    frame = _ref$frame === void 0 ? Window ? Window.document : undefined : _ref$frame,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? 'file-drop' : _ref$className,
+    _ref$targetClassName = _ref.targetClassName,
+    targetClassName = _ref$targetClassName === void 0 ? 'file-drop-target' : _ref$targetClassName,
+    _ref$draggingOverFram = _ref.draggingOverFrameClassName,
+    draggingOverFrameClassName = _ref$draggingOverFram === void 0 ? 'file-drop-dragging-over-frame' : _ref$draggingOverFram,
+    _ref$draggingOverTarg = _ref.draggingOverTargetClassName,
+    draggingOverTargetClassName = _ref$draggingOverTarg === void 0 ? 'file-drop-dragging-over-target' : _ref$draggingOverTarg,
+    onDragOver = _ref.onDragOver,
+    onDragLeave = _ref.onDragLeave,
+    onDrop = _ref.onDrop,
+    onFrameDragEnter = _ref.onFrameDragEnter,
+    onFrameDragLeave = _ref.onFrameDragLeave,
+    onFrameDrop = _ref.onFrameDrop,
+    children = _ref.children;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    draggingOverTarget = _useState2[0],
+    setDraggingOverTarget = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    draggingOverFrame = _useState4[0],
+    setDraggingOverFrame = _useState4[1];
+  var _useState5 = useState(0),
+    _useState6 = _slicedToArray(_useState5, 2),
+    frameDragCounter = _useState6[0],
+    setFrameDragCounter = _useState6[1];
+  var prevFrame = useRef(frame);
+  useEffect(function () {
+    // componentDidMount
+    startFrameListeners(frame);
+    resetDragging();
+    Window.addEventListener('dragover', handleWindowDragOverOrDrop);
+    Window.addEventListener('drop', handleWindowDragOverOrDrop);
+    return function () {
+      // componentWillUnmount
+      stopFrameListeners(frame);
+      Window.removeEventListener('dragover', handleWindowDragOverOrDrop);
+      Window.removeEventListener('drop', handleWindowDragOverOrDrop);
+    };
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var resetDragging = useCallback(function () {
+    setFrameDragCounter(0);
+    setDraggingOverTarget(false);
+    setDraggingOverFrame(false);
+  }, []);
+  var handleWindowDragOverOrDrop = useCallback(function (event) {
+    // This prevents the browser from trying to load whatever file the user dropped on the window
+    event.preventDefault();
+  }, []);
+  var handleFrameDrag = useCallback(function (event) {
+    // Only allow dragging of files
+    if (!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.
+    var newDragCounterValue = frameDragCounter + (event.type === 'dragenter' ? 1 : -1);
+    setFrameDragCounter(newDragCounterValue);
+    if (newDragCounterValue === 1) {
+      setDraggingOverFrame(true);
+      if (onFrameDragEnter) onFrameDragEnter(event);
+      return;
+    }
+    if (newDragCounterValue === 0) {
+      setDraggingOverFrame(false);
+      if (onFrameDragLeave) onFrameDragLeave(event);
+      return;
+    }
+  }, [frameDragCounter, setDraggingOverFrame, onFrameDragEnter, onFrameDragLeave]);
+  var handleFrameDrop = useCallback(function (event) {
+    event.preventDefault();
+    if (!draggingOverTarget) {
+      resetDragging();
+      if (onFrameDrop) onFrameDrop(event);
+    }
+  }, [onFrameDrop, draggingOverTarget, resetDragging]);
+  var handleDragOver = useCallback(function (event) {
+    if (eventHasFiles(event)) {
+      setDraggingOverTarget(true);
+      if (!isIE() && dropEffect) event.dataTransfer.dropEffect = dropEffect;
+      if (onDragOver) onDragOver(event);
+    }
+  }, [dropEffect, onDragOver]);
+  var handleDragLeave = useCallback(function (event) {
+    setDraggingOverTarget(false);
+    if (onDragLeave) onDragLeave(event);
+  }, [onDragLeave]);
+  var handleDrop = useCallback(function (event) {
+    if (onDrop && eventHasFiles(event)) {
+      var files = event.dataTransfer ? event.dataTransfer.files : null;
+      onDrop(files, event);
+    }
+    resetDragging();
+  }, [onDrop, resetDragging]);
+  var stopFrameListeners = useCallback(function (frame) {
+    if (frame) {
+      frame.removeEventListener('dragenter', handleFrameDrag);
+      frame.removeEventListener('dragleave', handleFrameDrag);
+      frame.removeEventListener('drop', handleFrameDrop);
+    }
+  }, [handleFrameDrag, handleFrameDrop]);
+  var startFrameListeners = useCallback(function (frame) {
+    if (frame) {
+      frame.addEventListener('dragenter', handleFrameDrag);
+      frame.addEventListener('dragleave', handleFrameDrag);
+      frame.addEventListener('drop', handleFrameDrop);
+    }
+  }, [handleFrameDrag, handleFrameDrop]);
+  useEffect(function () {
+    // componentDidUpdate
+    if (prevFrame.current !== frame) {
+      resetDragging();
+      stopFrameListeners(prevFrame.current);
+      startFrameListeners(frame);
+      prevFrame.current = frame;
+    }
+  }, [frame, resetDragging, stopFrameListeners, startFrameListeners]);
+
+  // Render
+  var fileDropTargetClassName = targetClassName;
+  if (draggingOverFrame) fileDropTargetClassName += " ".concat(draggingOverFrameClassName);
+  if (draggingOverTarget) fileDropTargetClassName += " ".concat(draggingOverTargetClassName);
+  return /*#__PURE__*/React.createElement("div", {
+    className: className,
+    onDragOver: handleDragOver,
+    onDragLeave: handleDragLeave,
+    onDrop: handleDrop
+  }, /*#__PURE__*/React.createElement("div", {
+    className: fileDropTargetClassName
+  }, children));
+};
+export default FileDrop;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","useRef","Window","isIE","navigator","userAgent","includes","appVersion","eventHasFiles","event","hasFiles","dataTransfer","types","keyOrIndex","FileDrop","_ref","_ref$dropEffect","dropEffect","_ref$frame","frame","document","undefined","_ref$className","className","_ref$targetClassName","targetClassName","_ref$draggingOverFram","draggingOverFrameClassName","_ref$draggingOverTarg","draggingOverTargetClassName","onDragOver","onDragLeave","onDrop","onFrameDragEnter","onFrameDragLeave","onFrameDrop","children","_useState","_useState2","_slicedToArray","draggingOverTarget","setDraggingOverTarget","_useState3","_useState4","draggingOverFrame","setDraggingOverFrame","_useState5","_useState6","frameDragCounter","setFrameDragCounter","prevFrame","startFrameListeners","resetDragging","addEventListener","handleWindowDragOverOrDrop","stopFrameListeners","removeEventListener","preventDefault","handleFrameDrag","newDragCounterValue","type","handleFrameDrop","handleDragOver","handleDragLeave","handleDrop","files","current","fileDropTargetClassName","concat","createElement"],"sources":["../../../../src/common/file-uploader/file-drop.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Copied from https://github.com/sarink/react-file-drop\n * For React 16.8 compatibility\n */\nimport React, {ReactNode, useCallback, useEffect, useState, useRef} from 'react';\nimport Window from 'global/window';\n\nconst isIE = () =>\n  Window &&\n  Window.navigator &&\n  ((Window.navigator.userAgent || []).includes('MSIE') ||\n    (Window.navigator.appVersion || []).includes('Trident/'));\n\nconst 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\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  children?: ReactNode;\n};\n\nconst FileDrop = ({\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  onDragOver,\n  onDragLeave,\n  onDrop,\n  onFrameDragEnter,\n  onFrameDragLeave,\n  onFrameDrop,\n  children\n}: FileDropProps) => {\n  const [draggingOverTarget, setDraggingOverTarget] = useState(false);\n  const [draggingOverFrame, setDraggingOverFrame] = useState(false);\n  const [frameDragCounter, setFrameDragCounter] = useState(0);\n\n  const prevFrame = useRef(frame);\n\n  useEffect(() => {\n    // componentDidMount\n    startFrameListeners(frame);\n    resetDragging();\n    Window.addEventListener('dragover', handleWindowDragOverOrDrop);\n    Window.addEventListener('drop', handleWindowDragOverOrDrop);\n\n    return () => {\n      // componentWillUnmount\n      stopFrameListeners(frame);\n      Window.removeEventListener('dragover', handleWindowDragOverOrDrop);\n      Window.removeEventListener('drop', handleWindowDragOverOrDrop);\n    };\n\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const resetDragging = useCallback(() => {\n    setFrameDragCounter(0);\n    setDraggingOverTarget(false);\n    setDraggingOverFrame(false);\n  }, []);\n\n  const handleWindowDragOverOrDrop = useCallback(event => {\n    // This prevents the browser from trying to load whatever file the user dropped on the window\n    event.preventDefault();\n  }, []);\n\n  const handleFrameDrag = useCallback(\n    event => {\n      // Only allow dragging of files\n      if (!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      const newDragCounterValue = frameDragCounter + (event.type === 'dragenter' ? 1 : -1);\n      setFrameDragCounter(newDragCounterValue);\n\n      if (newDragCounterValue === 1) {\n        setDraggingOverFrame(true);\n        if (onFrameDragEnter) onFrameDragEnter(event);\n        return;\n      }\n\n      if (newDragCounterValue === 0) {\n        setDraggingOverFrame(false);\n        if (onFrameDragLeave) onFrameDragLeave(event);\n        return;\n      }\n    },\n    [frameDragCounter, setDraggingOverFrame, onFrameDragEnter, onFrameDragLeave]\n  );\n\n  const handleFrameDrop = useCallback(\n    event => {\n      event.preventDefault();\n      if (!draggingOverTarget) {\n        resetDragging();\n        if (onFrameDrop) onFrameDrop(event);\n      }\n    },\n    [onFrameDrop, draggingOverTarget, resetDragging]\n  );\n\n  const handleDragOver = useCallback(\n    event => {\n      if (eventHasFiles(event)) {\n        setDraggingOverTarget(true);\n        if (!isIE() && dropEffect) event.dataTransfer.dropEffect = dropEffect;\n        if (onDragOver) onDragOver(event);\n      }\n    },\n    [dropEffect, onDragOver]\n  );\n\n  const handleDragLeave = useCallback(\n    event => {\n      setDraggingOverTarget(false);\n\n      if (onDragLeave) onDragLeave(event);\n    },\n    [onDragLeave]\n  );\n\n  const handleDrop = useCallback(\n    event => {\n      if (onDrop && eventHasFiles(event)) {\n        const files = event.dataTransfer ? event.dataTransfer.files : null;\n        onDrop(files, event);\n      }\n      resetDragging();\n    },\n    [onDrop, resetDragging]\n  );\n\n  const stopFrameListeners = useCallback(\n    frame => {\n      if (frame) {\n        frame.removeEventListener('dragenter', handleFrameDrag);\n        frame.removeEventListener('dragleave', handleFrameDrag);\n        frame.removeEventListener('drop', handleFrameDrop);\n      }\n    },\n    [handleFrameDrag, handleFrameDrop]\n  );\n\n  const startFrameListeners = useCallback(\n    frame => {\n      if (frame) {\n        frame.addEventListener('dragenter', handleFrameDrag);\n        frame.addEventListener('dragleave', handleFrameDrag);\n        frame.addEventListener('drop', handleFrameDrop);\n      }\n    },\n    [handleFrameDrag, handleFrameDrop]\n  );\n\n  useEffect(() => {\n    // componentDidUpdate\n    if (prevFrame.current !== frame) {\n      resetDragging();\n      stopFrameListeners(prevFrame.current);\n      startFrameListeners(frame);\n\n      prevFrame.current = frame;\n    }\n  }, [frame, resetDragging, stopFrameListeners, startFrameListeners]);\n\n  // Render\n  let fileDropTargetClassName = targetClassName;\n  if (draggingOverFrame) fileDropTargetClassName += ` ${draggingOverFrameClassName}`;\n  if (draggingOverTarget) fileDropTargetClassName += ` ${draggingOverTargetClassName}`;\n\n  return (\n    <div\n      className={className}\n      onDragOver={handleDragOver}\n      onDragLeave={handleDragLeave}\n      onDrop={handleDrop}\n    >\n      <div className={fileDropTargetClassName}>{children}</div>\n    </div>\n  );\n};\n\nexport default FileDrop;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,77 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled, { withTheme } from 'styled-components';
+import classnames from 'classnames';
+import ProgressBar from '../progress-bar';
+import { TruncatedTitleText } from '../styled-components';
+import { getError } from '@kepler.gl/utils';
+var StyledFileProgress = styled.div.attrs(function (props) {
+  return {
+    className: classnames('file-upload__progress', props.className)
+  };
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\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 = styled.div.attrs({
+  className: 'file-upload__progress__wrapper'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  width: 400px;\n"])));
+var StyledContainer = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\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.createElement(StyledFileProgress, {
+    className: "file-upload-progress__message"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "top-row"
+  }, /*#__PURE__*/React.createElement(TruncatedTitleText, {
+    className: "file-name",
+    title: fileName
+  }, fileName), /*#__PURE__*/React.createElement("div", {
+    className: "percent"
+  }, percentStr)), /*#__PURE__*/React.createElement("div", {
+    className: "middle-row"
+  }, /*#__PURE__*/React.createElement(ProgressBar, {
+    percent: percentStr,
+    barColor: barColor,
+    isLoading: true,
+    theme: theme
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "bottom-row",
+    style: {
+      color: error ? theme.errorColor : theme.textColorLT
+    }
+  }, error ? getError(error) : message));
+};
+var FileUploadProgress = function FileUploadProgress(_ref2) {
+  var fileLoadingProgress = _ref2.fileLoadingProgress,
+    theme = _ref2.theme;
+  return /*#__PURE__*/React.createElement(StyledContainer, null, /*#__PURE__*/React.createElement(StyledProgressWrapper, null, Object.values(fileLoadingProgress).map(function (item) {
+    return /*#__PURE__*/React.createElement(UploadProgress, _extends({}, item, {
+      key: item.fileName,
+      theme: theme
+    }));
+  })));
+};
+export default withTheme(FileUploadProgress);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","styled","withTheme","classnames","ProgressBar","TruncatedTitleText","getError","StyledFileProgress","div","attrs","props","className","_templateObject","_taggedTemplateLiteral","theme","textColorLT","StyledProgressWrapper","_templateObject2","StyledContainer","_templateObject3","formatPercent","percent","concat","Math","floor","UploadProgress","_ref","message","fileName","error","percentStr","barColor","errorColor","activeColorLT","createElement","title","isLoading","style","color","FileUploadProgress","_ref2","fileLoadingProgress","Object","values","map","item","_extends","key"],"sources":["../../../../src/common/file-uploader/file-upload-progress.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\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\ntype FileUploadProgressProps = {\n  fileLoadingProgress: FileLoadingProgress;\n  theme: any;\n};\n\nconst FileUploadProgress: React.FC<FileUploadProgressProps> = ({\n  fileLoadingProgress,\n  theme\n}: 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) as React.FC<FileUploadProgressProps>;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,234 @@
+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;
+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; })(); }
+// 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 { isChrome } from '@kepler.gl/utils';
+import { GUIDES_FILE_FORMAT_DOC } from '@kepler.gl/constants';
+import Markdown from 'markdown-to-jsx';
+// Breakpoints
+import { FormattedMessage } from '@kepler.gl/localization';
+import { media } from '@kepler.gl/styles';
+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  padding: 48px 8px 0;\n  height: 360px;\n\n  .file-upload-or {\n    color: ", ";\n    padding-right: 4px;\n  }\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;
+}, function (props) {
+  return props.theme.linkBtnColor;
+}, media.portable(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n    padding: 16px 4px 0;\n  "]))));
+var MsgWrapper = styled.div(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  color: ", ";\n  font-size: 20px;\n  height: 36px;\n"])), function (props) {
+  return props.theme.modalTitleColor;
+});
+var StyledDragNDropIcon = styled.div(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  color: ", ";\n  margin-bottom: 48px;\n\n  display: flex;\n  justify-content: center;\n\n  ", ";\n  ", ";\n"])), fileIconColor, media.portable(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n    margin-bottom: 16px;\n  "]))), media.palm(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n    margin-bottom: 8px;\n  "]))));
+var StyledFileTypeFow = styled.div(_templateObject0 || (_templateObject0 = _taggedTemplateLiteral(["\n  margin-bottom: 24px;\n  ", ";\n  ", ";\n"])), media.portable(_templateObject1 || (_templateObject1 = _taggedTemplateLiteral(["\n    margin-bottom: 16px;\n  "]))), media.palm(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["\n    margin-bottom: 8px;\n  "]))));
+var StyledFileUpload = styled.div(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["\n  .file-drop {\n    position: relative;\n  }\n"])));
+var StyledMessage = styled.div(_templateObject12 || (_templateObject12 = _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(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["\n  margin-bottom: 32px;\n  ", ";\n  ", ";\n"])), media.portable(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["\n    margin-bottom: 24px;\n  "]))), media.portable(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["\n    margin-bottom: 16px;\n  "]))));
+var StyledDisclaimer = styled(StyledMessage)(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["\n  margin: 0 auto;\n"])));
+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: []
+      });
+      _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
+        });
+      });
+      return _this;
+    }
+    _inherits(FileUpload, _Component);
+    return _createClass(FileUpload, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        var _this$state = this.state,
+          dragOver = _this$state.dragOver,
+          files = _this$state.files,
+          errorFiles = _this$state.errorFiles;
+        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 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(StyledFileTypeFow, {
+          className: "file-type-row"
+        }, fileExtensions.map(function (ext) {
+          return /*#__PURE__*/React.createElement(FileType, {
+            key: ext,
+            ext: ext,
+            height: "50px",
+            fontSize: "9px"
+          });
+        })), fileLoading ? /*#__PURE__*/React.createElement(FileUploadProgress, {
+          fileLoadingProgress: fileLoadingProgress,
+          theme: theme
+        }) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+          style: {
+            opacity: dragOver ? 0.5 : 1
+          },
+          className: "file-upload-display-message"
+        }, /*#__PURE__*/React.createElement(StyledDragNDropIcon, null, /*#__PURE__*/React.createElement(DragNDrop, {
+          height: "44px"
+        })), 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(MsgWrapper, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.message'
+        })), /*#__PURE__*/React.createElement("span", {
+          className: "file-upload-or"
+        }, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.or'
+        })), /*#__PURE__*/React.createElement(UploadButton, {
+          onUpload: this._handleFileInput
+        }, /*#__PURE__*/React.createElement(FormattedMessage, {
+          id: 'fileUploader.browseFiles'
+        }))) : 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
+          };
+        }
+        return {
+          fileLoading: props.fileLoading
+        };
+      }
+    }]);
+  }(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","isChrome","GUIDES_FILE_FORMAT_DOC","Markdown","FormattedMessage","media","LinkRenderer","fileIconColor","StyledUploadMessage","div","_templateObject","_taggedTemplateLiteral","props","theme","textColorLT","portable","_templateObject2","WarningMsg","span","_templateObject3","errorColor","StyledFileDrop","_templateObject4","$dragOver","subtextColorLT","linkBtnColor","_templateObject5","MsgWrapper","_templateObject6","modalTitleColor","StyledDragNDropIcon","_templateObject7","_templateObject8","palm","_templateObject9","StyledFileTypeFow","_templateObject0","_templateObject1","_templateObject10","StyledFileUpload","_templateObject11","StyledMessage","_templateObject12","StyledDragFileWrapper","_templateObject13","_templateObject14","_templateObject15","StyledDisclaimer","_templateObject16","FileUploadFactory","FileUpload","_Component","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","_defineProperty","dragOver","fileLoading","files","errorFiles","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","_inherits","_createClass","key","render","_this2","_this$state","state","_this$props","fileLoadingProgress","intl","_this$props2","_this$props2$fileExte","_this$props2$fileForm","fileFormatNames","fileUploadInfoText","formatMessage","id","map","format","join","createElement","className","ref","frame","current","document","onDragOver","_toggleDragState","onDragLeave","onDrop","_handleFileInput","options","overrides","a","component","height","fontSize","Fragment","style","opacity","values","onUpload","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 {isChrome} from '@kepler.gl/utils';\nimport {GUIDES_FILE_FORMAT_DOC} from '@kepler.gl/constants';\nimport Markdown from 'markdown-to-jsx';\n// Breakpoints\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {media} from '@kepler.gl/styles';\n\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 => (props.$dragOver ? props.theme.textColorLT : props.theme.subtextColorLT)};\n  text-align: center;\n  width: 100%;\n  padding: 48px 8px 0;\n  height: 360px;\n\n  .file-upload-or {\n    color: ${props => props.theme.linkBtnColor};\n    padding-right: 4px;\n  }\n\n  .file-type-row {\n    opacity: 0.5;\n  }\n  ${media.portable`\n    padding: 16px 4px 0;\n  `};\n`;\n\nconst MsgWrapper = styled.div`\n  color: ${props => props.theme.modalTitleColor};\n  font-size: 20px;\n  height: 36px;\n`;\n\nconst StyledDragNDropIcon = styled.div`\n  color: ${fileIconColor};\n  margin-bottom: 48px;\n\n  display: flex;\n  justify-content: center;\n\n  ${media.portable`\n    margin-bottom: 16px;\n  `};\n  ${media.palm`\n    margin-bottom: 8px;\n  `};\n`;\n\nconst StyledFileTypeFow = styled.div`\n  margin-bottom: 24px;\n  ${media.portable`\n    margin-bottom: 16px;\n  `};\n  ${media.palm`\n    margin-bottom: 8px;\n  `};\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  margin-bottom: 32px;\n  ${media.portable`\n    margin-bottom: 24px;\n  `};\n  ${media.portable`\n    margin-bottom: 16px;\n  `};\n`;\n\nconst StyledDisclaimer = styled(StyledMessage)`\n  margin: 0 auto;\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\nfunction FileUploadFactory() {\n  /** @augments {Component<FileUploadProps>} */\n  class FileUpload extends Component<FileUploadProps> {\n    state = {\n      dragOver: false,\n      fileLoading: false,\n      files: [],\n      errorFiles: []\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        };\n      }\n      return {\n        fileLoading: props.fileLoading\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    render() {\n      const {dragOver, files, errorFiles} = this.state;\n      const {fileLoading, fileLoadingProgress, theme, intl} = this.props;\n      const {fileExtensions = [], fileFormatNames = []} = this.props;\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                <StyledFileTypeFow className=\"file-type-row\">\n                  {fileExtensions.map(ext => (\n                    <FileType key={ext} ext={ext} height=\"50px\" fontSize=\"9px\" />\n                  ))}\n                </StyledFileTypeFow>\n                {fileLoading ? (\n                  <FileUploadProgress fileLoadingProgress={fileLoadingProgress} theme={theme} />\n                ) : (\n                  <>\n                    <div\n                      style={{opacity: dragOver ? 0.5 : 1}}\n                      className=\"file-upload-display-message\"\n                    >\n                      <StyledDragNDropIcon>\n                        <DragNDrop height=\"44px\" />\n                      </StyledDragNDropIcon>\n\n                      {errorFiles.length ? (\n                        <WarningMsg>\n                          <FormattedMessage\n                            id={'fileUploader.fileNotSupported'}\n                            values={{errorFiles: errorFiles.join(', ')}}\n                          />\n                        </WarningMsg>\n                      ) : null}\n                    </div>\n                    {!files.length ? (\n                      <StyledDragFileWrapper>\n                        <MsgWrapper>\n                          <FormattedMessage id={'fileUploader.message'} />\n                        </MsgWrapper>\n                        <span className=\"file-upload-or\">\n                          <FormattedMessage id={'fileUploader.or'} />\n                        </span>\n                        <UploadButton onUpload={this._handleFileInput}>\n                          <FormattedMessage id={'fileUploader.browseFiles'} />\n                        </UploadButton>\n                      </StyledDragFileWrapper>\n                    ) : null}\n\n                    <StyledDisclaimer>\n                      <FormattedMessage id={'fileUploader.disclaimer'} />\n                    </StyledDisclaimer>\n                  </>\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":[]}