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

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":[]}