@transferwise/components 46.39.0 → 46.40.0

package/build/index.js

@@ -12088,13 +12088,6 @@ var Typeahead$1 = withInputAttributes(Typeahead, {
   nonLabelable: true
 });
 
-// TODO: consider to move this enum into component file once we migrate it on TypeScript or replace with some common enum
-exports.UploadStep = void 0;
-(function (UploadStep) {
-  UploadStep["UPLOAD_IMAGE_STEP"] = "uploadImageStep";
-  UploadStep["MEDIA_UPLOAD_STEP"] = "mediaUploadStep";
-})(exports.UploadStep || (exports.UploadStep = {}));
-
 var messages = reactIntl.defineMessages({
   csButtonText: {
     id: "neptune.Upload.csButtonText"
@@ -12129,16 +12122,13 @@ var messages = reactIntl.defineMessages({
 });
 
 class UploadImageStep extends React.PureComponent {
-  constructor() {
-    super();
-    this.uploadInputRef = /*#__PURE__*/React.createRef();
-  }
+  uploadInputRef = /*#__PURE__*/React.createRef();
   onManualUpload = () => {
     const {
       fileDropped
     } = this.props;
-    if (this.uploadInputRef && this.uploadInputRef.current) {
-      const file = this.uploadInputRef.current.files[0];
+    const file = this.uploadInputRef.current?.files?.[0];
+    if (file != null) {
       fileDropped(file);
     }
   };
@@ -12187,7 +12177,7 @@ class UploadImageStep extends React.PureComponent {
             children: usLabel
           }), usPlaceholder && /*#__PURE__*/jsxRuntime.jsx("p", {
             className: "np-text-body-large m-b-3",
-            children: `${usPlaceholder}`
+            children: String(usPlaceholder)
           }), /*#__PURE__*/jsxRuntime.jsxs("label", {
             className: `btn btn-primary btn-md ${usDisabled ? 'disabled' : ''}`,
             children: [usButtonText ? /*#__PURE__*/jsxRuntime.jsx("span", {
@@ -12198,7 +12188,7 @@ class UploadImageStep extends React.PureComponent {
             }), /*#__PURE__*/jsxRuntime.jsx("input", {
               ref: this.uploadInputRef,
               type: "file",
-              accept: usAccept === '*' ? null : usAccept,
+              accept: usAccept === '*' ? undefined : usAccept,
               className: "tw-droppable-input hidden",
               disabled: usDisabled,
               name: "file-upload",
@@ -12210,213 +12200,17 @@ class UploadImageStep extends React.PureComponent {
     });
   }
 }
-UploadImageStep.propTypes = {
-  fileDropped: PropTypes__default.default.func.isRequired,
-  isComplete: PropTypes__default.default.bool.isRequired,
-  usAccept: PropTypes__default.default.string.isRequired,
-  usButtonText: PropTypes__default.default.string.isRequired,
-  usDisabled: PropTypes__default.default.bool.isRequired,
-  usHelpImage: PropTypes__default.default.node.isRequired,
-  usLabel: PropTypes__default.default.string.isRequired,
-  usPlaceholder: PropTypes__default.default.string.isRequired
-};
-
-const postData = (httpOptions, data = {}, fetcher = fetch) => fetcher(`${httpOptions.url}`, {
-  method: 'POST',
-  body: data,
-  ...httpOptions
-}).then(response => {
-  if (!response.ok) {
-    const error = new Error(response.statusText);
-    error.status = response.status;
-    error.response = response;
-    throw error;
-  }
-  return response;
-}).catch(error => {
-  throw error;
-});
-
-const asyncFileRead = file => new Promise((resolve, reject) => {
-  const reader = new FileReader();
-  reader.readAsDataURL(file);
-  reader.addEventListener('load', event => {
-    resolve(event.target.result);
-  });
-  reader.addEventListener('error', event => {
-    reject(event);
-  });
-});
-
-const isSizeValid = (file, maxSize) => Number.isInteger(maxSize) && file.size <= maxSize;
-
-const getFileType = (file, file64) => {
-  if (!file && !file64) {
-    return '';
-  }
-  if (file && file.type && file.type !== '') {
-    return file.type ?? '';
-  }
-  if (file64) {
-    const regex = /^data:([a-z]+\/[a-z]+);/;
-    const typeFromEncoded = file64.match(regex);
-    if (typeFromEncoded && typeFromEncoded[1]) {
-      return typeFromEncoded[1] ?? '';
-    }
-  }
-  return '';
-};
-
-const isTypeValid = (file, rule, file64) => {
-  if (!file || !rule) {
-    return false;
-  }
-  const allowedTypes = rule.replace(/\s/g, '').split(',');
-  const fileType = getFileType(file, file64);
-  if (rule === '*' || allowedTypes.includes(fileType)) {
-    return true;
-  }
-  return allowedTypes.some(type => {
-    const splittedRule = type.split('/');
-    const typeAllowed = splittedRule[0];
-    const extensionAllowed = splittedRule[1];
-    if (extensionAllowed !== '*') {
-      return false;
-    }
-    return fileType.includes(typeAllowed);
-  });
-};
-
-// Spot Platform's Media API only support these MIME types
-const SUPPORTED_MIME_TYPES = ['image/jpeg', 'video/*', 'application/pdf'];
-const getSupportedSpotMimeTypes = mimeTypes => {
-  if (mimeTypes === '*') {
-    return SUPPORTED_MIME_TYPES;
-  }
-  const mimeTypesArray = mimeTypes.split(',');
-  const mimeMapping = {
-    'image/*': 'image/jpeg',
-    'application/*': 'application/pdf'
-  };
-  const mapSupportedMimeTypes = mimeTypesArray.map(type => mimeMapping[type] || type);
-  return mapSupportedMimeTypes.filter(type => SUPPORTED_MIME_TYPES.includes(type));
-};
 
-const requestMedia = mediaRequest => new Promise((resolve, reject) => {
-  if (typeof window === 'undefined' || typeof window.microapps === 'undefined') {
-    reject(`microapps must be available in window to use Spot Platform's Media API`);
-  }
-  window.microapps.requestMedia(mediaRequest).then(response => {
-    const fileByteArray = base64ToByteArray(response.bytes);
-    const blob = new Blob([fileByteArray], {
-      type: response.mimeType
-    });
-    resolve(blob);
-  }).catch(error => reject(error));
-});
-const base64ToByteArray = base64String => {
-  const byteCharacters = atob(base64String);
-  const byteCharactersLength = byteCharacters.length;
-  const byteArray = new Array(byteCharactersLength);
-  for (let i = 0; i < byteCharactersLength; i += 1) {
-    byteArray[i] = byteCharacters.charCodeAt(i);
-  }
-  return new Uint8Array(byteArray);
-};
-
-const MediaUploadStep = ({
+function ProcessingStep({
   isComplete,
-  usAccept,
-  usButtonText,
-  usDisabled,
-  usHelpImage,
-  usLabel,
-  usPlaceholder,
-  fileDropped
-}) => {
-  const getMediaFile = () => {
-    const allowedMimeTypes = getSupportedSpotMimeTypes(usAccept);
-    if (allowedMimeTypes.length === 0) {
-      throw new Error('provided mimeTypes not supported');
-    }
-    const mediaRequest = {
-      allowedMimeTypes
-    };
-    requestMedia(mediaRequest).then(file => fileDropped(file));
-  };
-  const getImage = () => {
-    if (!usHelpImage) {
-      return /*#__PURE__*/jsxRuntime.jsx("div", {
-        className: "circle circle-sm circle-inverse p-t-1",
-        children: /*#__PURE__*/jsxRuntime.jsx(icons.Upload, {
-          size: 24
-        })
-      });
-    }
-    if (typeof usHelpImage === 'string') {
-      return /*#__PURE__*/jsxRuntime.jsx("img", {
-        src: usHelpImage,
-        alt: usLabel,
-        className: "thumbnail text-xs-center"
-      });
-    }
-    return usHelpImage;
-  };
-  return /*#__PURE__*/jsxRuntime.jsx("div", {
-    children: /*#__PURE__*/jsxRuntime.jsx("div", {
-      className: "droppable-default-card",
-      "aria-hidden": isComplete,
-      children: /*#__PURE__*/jsxRuntime.jsxs("div", {
-        className: "droppable-card-content",
-        children: [/*#__PURE__*/jsxRuntime.jsx("div", {
-          className: "m-b-3",
-          children: getImage()
-        }), usLabel && /*#__PURE__*/jsxRuntime.jsx(Title, {
-          type: exports.Typography.TITLE_BODY,
-          className: "m-b-1",
-          children: usLabel
-        }), usPlaceholder && /*#__PURE__*/jsxRuntime.jsx(Body, {
-          as: "p",
-          type: exports.Typography.BODY_LARGE,
-          className: "m-b-3",
-          children: `${usPlaceholder}`
-        }), /*#__PURE__*/jsxRuntime.jsx(Button, {
-          disabled: usDisabled,
-          onClick: getMediaFile,
-          children: usButtonText || /*#__PURE__*/jsxRuntime.jsx(icons.Upload, {
-            size: 24,
-            className: "m-r-0"
-          })
-        })]
-      })
-    })
-  });
-};
-MediaUploadStep.propTypes = {
-  fileDropped: PropTypes__default.default.func.isRequired,
-  isComplete: PropTypes__default.default.bool.isRequired,
-  usAccept: PropTypes__default.default.string.isRequired,
-  usButtonText: PropTypes__default.default.string.isRequired,
-  usDisabled: PropTypes__default.default.bool.isRequired,
-  usHelpImage: PropTypes__default.default.node.isRequired,
-  usLabel: PropTypes__default.default.string.isRequired,
-  usPlaceholder: PropTypes__default.default.string.isRequired
-};
-
-const ProcessingStep = props => {
-  const {
-    isComplete,
-    isError,
-    isSuccess,
-    onAnimationCompleted,
-    onClear,
-    psButtonText,
-    psProcessingText,
-    psButtonDisabled
-  } = props;
-  const {
-    isModern
-  } = componentsTheming.useTheme();
+  isError,
+  isSuccess,
+  onAnimationCompleted,
+  onClear,
+  psButtonText,
+  psProcessingText,
+  psButtonDisabled
+}) {
   let processStatus = exports.Status.PROCESSING;
   if (isError) {
     processStatus = exports.Status.FAILED;
@@ -12430,53 +12224,33 @@ const ProcessingStep = props => {
     children: /*#__PURE__*/jsxRuntime.jsxs("div", {
       className: "droppable-card-content",
       children: [/*#__PURE__*/jsxRuntime.jsx(ProcessIndicator, {
-        size: exports.Size.Small,
         status: processStatus,
         onAnimationCompleted: status => onAnimationCompleted(status)
       }), /*#__PURE__*/jsxRuntime.jsx(Title, {
-        className: classNames__default.default({
-          'm-t-3': !isModern,
-          'm-b-3': !isModern,
-          'm-t-2': isModern,
-          'm-b-2': isModern
-        }),
+        className: "m-y-2",
         type: exports.Typography.TITLE_BODY,
         "aria-live": "polite",
         children: psProcessingText
       }), psButtonText && /*#__PURE__*/jsxRuntime.jsx(Button, {
         disabled: psButtonDisabled,
-        onClick: event => onClear(event),
+        onClick: onClear,
         children: psButtonText
       })]
     })
   });
-};
-ProcessingStep.propTypes = {
-  isComplete: PropTypes__default.default.bool.isRequired,
-  isError: PropTypes__default.default.bool.isRequired,
-  isSuccess: PropTypes__default.default.bool.isRequired,
-  onAnimationCompleted: PropTypes__default.default.func.isRequired,
-  onClear: PropTypes__default.default.func.isRequired,
-  psButtonText: PropTypes__default.default.string.isRequired,
-  psProcessingText: PropTypes__default.default.string.isRequired,
-  psButtonDisabled: PropTypes__default.default.bool.isRequired
-};
+}
 
-const CompleteStep = props => {
-  const {
-    isModern
-  } = componentsTheming.useTheme();
-  const {
-    csButtonText,
-    csFailureText,
-    csSuccessText,
-    fileName,
-    isComplete,
-    isError,
-    isImage,
-    onClear,
-    uploadedImage
-  } = props;
+function CompleteStep({
+  csButtonText,
+  csFailureText,
+  csSuccessText,
+  fileName,
+  isComplete,
+  isError,
+  isImage,
+  onClear,
+  uploadedImage
+}) {
   return /*#__PURE__*/jsxRuntime.jsx("div", {
     className: "droppable-complete-card droppable-card",
     "aria-hidden": !isComplete,
@@ -12486,16 +12260,11 @@ const CompleteStep = props => {
         className: "droppable-card-content d-flex flex-column align-items-center",
         "aria-live": "polite",
         children: isError ? /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
-          children: [isModern ? /*#__PURE__*/jsxRuntime.jsx(StatusIcon, {
+          children: [/*#__PURE__*/jsxRuntime.jsx(StatusIcon, {
             size: exports.Size.LARGE,
             sentiment: exports.Sentiment.NEGATIVE
-          }) : /*#__PURE__*/jsxRuntime.jsx(icons.AlertCircle, {
-            size: 24,
-            className: "text-negative"
           }), csFailureText && /*#__PURE__*/jsxRuntime.jsx("p", {
-            className: classNames__default.default('m-t-2', {
-              'm-b-0': isModern
-            }),
+            className: "m-t-2 m-b-0",
             children: csFailureText
           })]
         }) : /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
@@ -12514,71 +12283,135 @@ const CompleteStep = props => {
           })]
         })
       }), csButtonText && /*#__PURE__*/jsxRuntime.jsx(Button, {
-        priority: isModern ? exports.Priority.PRIMARY : exports.Priority.SECONDARY,
-        className: classNames__default.default({
-          'm-t-1': isModern && !isError,
-          'm-t-2': isModern && isError,
-          'm-t-3': !isModern
-        }),
-        onClick: event => onClear(event),
+        className: isError ? 'm-t-2' : 'm-t-1',
+        onClick: onClear,
         children: csButtonText
       })]
     })
   });
-};
-CompleteStep.propTypes = {
-  csButtonText: PropTypes__default.default.string.isRequired,
-  csSuccessText: PropTypes__default.default.string.isRequired,
-  csFailureText: PropTypes__default.default.string.isRequired,
-  fileName: PropTypes__default.default.string.isRequired,
-  isComplete: PropTypes__default.default.bool.isRequired,
-  isError: PropTypes__default.default.bool.isRequired,
-  isImage: PropTypes__default.default.bool.isRequired,
-  onClear: PropTypes__default.default.func.isRequired,
-  uploadedImage: PropTypes__default.default.string
-};
-CompleteStep.defaultProps = {
-  uploadedImage: null
-};
+}
 
-const PROCESS_STATE = ['error', 'success'];
+class ResponseError extends Error {
+  response;
+  status;
+  constructor(response, message) {
+    super(message);
+    this.name = 'ResponseError';
+    this.response = response;
+    this.status = response.status;
+  }
+}
+async function postData({
+  url,
+  method = 'POST',
+  ...httpOptions
+}, data, fetcher = fetch) {
+  const response = await fetcher(url, {
+    method,
+    body: data,
+    ...httpOptions
+  });
+  if (!response.ok) {
+    throw new ResponseError(response, response.statusText);
+  }
+  return response;
+}
+
+async function asyncFileRead(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.addEventListener('load', () => {
+      resolve(reader.result);
+    });
+    reader.addEventListener('error', () => {
+      reject(reader.error ?? new Error('Cannot read file'));
+    });
+    reader.readAsDataURL(file);
+  });
+}
+
+function isSizeValid(file, maxSize) {
+  return Number.isInteger(maxSize) && file.size <= maxSize;
+}
+
+function getFileType(file, file64) {
+  if (file.type) {
+    return file.type;
+  }
+  if (file64) {
+    const regex = /^data:([a-z]+\/[a-z]+);/;
+    const typeFromEncoded = regex.exec(file64);
+    if (typeFromEncoded?.[1]) {
+      return typeFromEncoded[1];
+    }
+  }
+  return '';
+}
+
+function isTypeValid(file, rule, file64) {
+  if (!rule) {
+    return false;
+  }
+  const allowedTypes = rule.replace(/\s/g, '').split(',');
+  const fileType = getFileType(file, file64);
+  if (rule === '*' || allowedTypes.includes(fileType)) {
+    return true;
+  }
+  return allowedTypes.some(type => {
+    const [typeAllowed, extensionAllowed] = type.split('/');
+    return extensionAllowed === '*' && fileType.includes(typeAllowed);
+  });
+}
 
-/*
- * This delay is required for the isError/isSuccess to be fired after isProcessing so the processIndicator, will be
- * rendered first and then updated with the right status.
- */
 const ANIMATION_FIX = 10;
 const MAX_SIZE_DEFAULT = 5000000;
-const UPLOAD_STEP_COMPONENTS = {
-  [exports.UploadStep.UPLOAD_IMAGE_STEP]: UploadImageStep,
-  [exports.UploadStep.MEDIA_UPLOAD_STEP]: MediaUploadStep
-};
+exports.UploadStep = void 0;
+(function (UploadStep) {
+  UploadStep["UPLOAD_IMAGE_STEP"] = "uploadImageStep";
+})(exports.UploadStep || (exports.UploadStep = {}));
 class Upload extends React.Component {
+  static defaultProps = {
+    animationDelay: 700,
+    maxSize: MAX_SIZE_DEFAULT,
+    psButtonDisabled: false,
+    size: 'md',
+    usAccept: 'image/*',
+    usDisabled: false,
+    usLabel: ''
+  };
+  dragCounter = 0;
+  timeouts = 0;
   constructor(props) {
     super(props);
-    this.dragCounter = 0;
-    this.timeouts = null;
     this.state = {
       fileName: '',
+      isDroppable: false,
       isComplete: false,
       isError: false,
       isImage: false,
       isProcessing: false,
       isSuccess: false,
-      response: null,
-      uploadedImage: null
+      response: undefined,
+      uploadedImage: undefined
     };
   }
   getErrorMessage(status) {
+    const {
+      csFailureText,
+      csTooLargeMessage,
+      csWrongTypeMessage,
+      maxSize,
+      intl
+    } = this.props;
     switch (status) {
       case 413:
-        return this.props.csTooLargeMessage || this.props.intl.formatMessage(messages.csTooLargeMessage, {
-          maxSize: this.props.maxSize / 1000000
+        return csTooLargeMessage || intl.formatMessage(messages.csTooLargeMessage, {
+          maxSize: maxSize / 1000000
         });
       case 415:
-        return this.props.csWrongTypeMessage || this.props.intl.formatMessage(messages.csWrongTypeMessage);
+        return csWrongTypeMessage || intl.formatMessage(messages.csWrongTypeMessage);
       default:
-        return this.props.csFailureText || this.props.intl.formatMessage(messages.csFailureText);
+        return csFailureText || intl.formatMessage(messages.csFailureText);
     }
   }
   onDragLeave(event) {
@@ -12605,7 +12438,7 @@ class Upload extends React.Component {
       });
     }
   }
-  onDrop(event) {
+  async onDrop(event) {
     const {
       isProcessing
     } = this.state;
@@ -12613,8 +12446,8 @@ class Upload extends React.Component {
     if (!isProcessing) {
       this.reset();
     }
-    if (event.dataTransfer && event.dataTransfer.files && event.dataTransfer.files[0]) {
-      this.fileDropped(event.dataTransfer.files[0]);
+    if (event.dataTransfer?.files?.[0]) {
+      await this.fileDropped(event.dataTransfer.files[0]);
     }
   }
   onAnimationCompleted = async status => {
@@ -12623,77 +12456,70 @@ class Upload extends React.Component {
       isProcessing,
       fileName
     } = this.state;
-    // Success.
     const {
       animationDelay
     } = this.props;
-    if (isProcessing && status === exports.Status.SUCCEEDED) {
+    if (isProcessing && status === 'succeeded') {
       const {
         onSuccess
       } = this.props;
-      this.timeouts = setTimeout(() => {
+      this.timeouts = window.setTimeout(() => {
         this.setState({
           isProcessing: false,
           isComplete: true
-        }, () => onSuccess ? onSuccess(response, fileName) : {});
+        }, onSuccess ? () => onSuccess(response, fileName) : undefined);
       }, animationDelay);
     }
-    // Failure.
-    if (isProcessing && status === exports.Status.FAILED) {
+    if (isProcessing && status === 'failed') {
       const {
         onFailure
       } = this.props;
-      this.timeouts = setTimeout(() => {
+      this.timeouts = window.setTimeout(() => {
         this.setState({
           isProcessing: false,
           isComplete: true
-        }, () => onFailure ? onFailure(response) : {});
+        }, onFailure ? () => onFailure(response) : undefined);
       }, animationDelay);
     }
   };
-  asyncPost = file => {
+  asyncPost = async file => {
     const {
       httpOptions,
       fetcher
     } = this.props;
+    if (httpOptions == null) {
+      throw new Error('Cannot find HTTP options');
+    }
     const {
       fileInputName = file.name,
       data = {}
-    } = httpOptions || {};
+    } = httpOptions;
     const formData = new FormData();
     formData.append(fileInputName, file);
     Object.keys(data).forEach(key => formData.append(key, data[key]));
-    return postData(this.prepareHttpOptions(httpOptions), formData, fetcher);
+    return postData(httpOptions, formData, fetcher);
   };
   asyncResponse = (response, type) => {
     // Gives time to the animation callback to fire.
-    this.timeouts = setTimeout(() => {
+    this.timeouts = window.setTimeout(() => {
       this.setState({
         response,
-        isError: type === PROCESS_STATE[0],
-        isSuccess: type === PROCESS_STATE[1]
+        isError: type === 'error',
+        isSuccess: type === 'success'
       });
     }, ANIMATION_FIX);
   };
-  prepareHttpOptions = httpOptions => {
-    if (!httpOptions.url) {
-      throw new Error('You must supply a URL to post image data asynchronously');
-    }
-    return httpOptions;
-  };
   handleOnClear = event => {
     event.preventDefault();
     const {
       onCancel
     } = this.props;
-    if (onCancel) {
-      onCancel();
-    }
+    onCancel?.();
     this.reset();
   };
   reset = () => {
     this.dragCounter = 0;
-    clearTimeout(this.timeouts);
+    window.clearTimeout(this.timeouts);
     this.setState({
       isComplete: false,
       isError: false,
@@ -12733,14 +12559,12 @@ class Upload extends React.Component {
       isDroppable: false,
       isProcessing: true
     });
-    if (onStart) {
-      onStart(file);
-    }
+    onStart?.(file);
     let file64 = null;
     try {
       file64 = await asyncFileRead(file);
     } catch (error) {
-      this.asyncResponse(error, PROCESS_STATE[0]);
+      this.asyncResponse(error, 'error');
     }
     if (!file64) {
       return false;
@@ -12749,30 +12573,31 @@ class Upload extends React.Component {
       isImage: getFileType(file, file64).includes('image')
     });
     if (!isTypeValid(file, usAccept, file64)) {
-      const response = {
+      this.asyncResponse(new ResponseError(new Response(null, {
         status: 415,
         statusText: 'Unsupported Media Type'
-      };
-      this.asyncResponse(response, PROCESS_STATE[0]);
+      })), 'error');
       return false;
     }
     if (!isSizeValid(file, maxSize)) {
-      const response = {
+      this.asyncResponse(new ResponseError(new Response(null, {
         status: 413,
         statusText: 'Request Entity Too Large'
-      };
-      this.asyncResponse(response, PROCESS_STATE[0]);
+      })), 'error');
       return false;
     }
     if (httpOptions) {
       // Post the file to provided endpoint
-      return await this.asyncPost(file).then(response => this.asyncResponse(response, 'success')).then(() => {
-        this.showDataImage(file64);
-        return true;
-      }).catch(error => {
-        this.asyncResponse(error, PROCESS_STATE[0]);
+      let response;
+      try {
+        response = await this.asyncPost(file);
+      } catch (error) {
+        this.asyncResponse(error, 'error');
         return false;
-      });
+      }
+      this.asyncResponse(response, 'success');
+      this.showDataImage(file64);
+      return true;
     }
     // Post on form submit. And return the encoded image.
     this.showDataImage(file64);
@@ -12781,6 +12606,7 @@ class Upload extends React.Component {
   };
   render() {
     const {
+      maxSize,
       usDropMessage,
       usAccept,
       usButtonText,
@@ -12794,7 +12620,6 @@ class Upload extends React.Component {
       csButtonText,
       csSuccessText,
       size,
-      uploadStep,
       intl
     } = this.props;
     const {
@@ -12808,7 +12633,6 @@ class Upload extends React.Component {
       isSuccess,
       uploadedImage
     } = this.state;
-    const UploadStepComponent = UPLOAD_STEP_COMPONENTS[uploadStep] || UploadImageStep;
     return /*#__PURE__*/jsxRuntime.jsxs("div", {
       className: classNames__default.default('droppable-area', {
         droppable: true,
@@ -12822,10 +12646,10 @@ class Upload extends React.Component {
       }),
       onDragEnter: event => this.onDragEnter(event),
       onDragLeave: event => this.onDragLeave(event),
-      onDrop: event => this.onDrop(event),
+      onDrop: async event => this.onDrop(event),
       onDragOver: event => event.preventDefault(),
-      children: [!isProcessing && !isComplete && /*#__PURE__*/jsxRuntime.jsx(UploadStepComponent, {
-        fileDropped: file => this.fileDropped(file),
+      children: [!isProcessing && !isComplete && /*#__PURE__*/jsxRuntime.jsx(UploadImageStep, {
+        fileDropped: async file => this.fileDropped(file),
         isComplete: isComplete,
         usAccept: usAccept,
         usButtonText: usButtonText || intl.formatMessage(messages.usButtonText),
@@ -12833,7 +12657,7 @@ class Upload extends React.Component {
         usHelpImage: usHelpImage,
         usLabel: usLabel,
         usPlaceholder: usPlaceholder || intl.formatMessage(messages.usPlaceholder, {
-          maxSize: this.props.maxSize / 1000000
+          maxSize: maxSize / 1000000
         })
       }), isProcessing && /*#__PURE__*/jsxRuntime.jsx(ProcessingStep, {
         isComplete: isComplete,
@@ -12842,7 +12666,7 @@ class Upload extends React.Component {
         psButtonText: psButtonText || intl.formatMessage(messages.psButtonText),
         psProcessingText: psProcessingText || intl.formatMessage(messages.psProcessingText),
         psButtonDisabled: psButtonDisabled,
-        onAnimationCompleted: status => this.onAnimationCompleted(status),
+        onAnimationCompleted: async status => this.onAnimationCompleted(status),
         onClear: event => this.handleOnClear(event)
       }), (isSuccess || isError || isComplete) && /*#__PURE__*/jsxRuntime.jsx(CompleteStep, {
         fileName: fileName,
@@ -12850,7 +12674,7 @@ class Upload extends React.Component {
         isError: isError,
         isImage: isImage,
         csButtonText: csButtonText || intl.formatMessage(messages.csButtonText),
-        csFailureText: this.getErrorMessage(response?.status),
+        csFailureText: this.getErrorMessage(response != null && typeof response === 'object' && 'status' in response && typeof response.status === 'number' ? response.status : undefined),
         csSuccessText: csSuccessText || intl.formatMessage(messages.csSuccessText),
         uploadedImage: uploadedImage,
         onClear: event => this.handleOnClear(event)
@@ -12874,73 +12698,6 @@ class Upload extends React.Component {
     });
   }
 }
-Upload.propTypes = {
-  animationDelay: PropTypes__default.default.number,
-  csButtonText: PropTypes__default.default.string,
-  csFailureText: PropTypes__default.default.string,
-  csSuccessText: PropTypes__default.default.string,
-  csTooLargeMessage: PropTypes__default.default.string,
-  csWrongTypeMessage: PropTypes__default.default.string,
-  httpOptions: PropTypes__default.default.shape({
-    url: PropTypes__default.default.string.isRequired,
-    method: PropTypes__default.default.oneOf(['POST', 'PUT', 'PATCH']),
-    fileInputName: PropTypes__default.default.string,
-    data: PropTypes__default.default.object,
-    headers: PropTypes__default.default.object
-  }),
-  /**
-   * You can provide a fetcher function with the same interface as the global fetch function, which is used by default.
-   * function fetcher(input: RequestInfo, init?: RequestInit): Promise<Response>
-   */
-  fetcher: PropTypes__default.default.func,
-  maxSize: PropTypes__default.default.number,
-  onCancel: PropTypes__default.default.func,
-  onFailure: PropTypes__default.default.func,
-  onStart: PropTypes__default.default.func,
-  onSuccess: PropTypes__default.default.func,
-  psButtonText: PropTypes__default.default.string,
-  psButtonDisabled: PropTypes__default.default.bool,
-  psProcessingText: PropTypes__default.default.string,
-  size: PropTypes__default.default.oneOf(['sm', 'md', 'lg']),
-  /**
-   * You can provide multiple rules separated by comma, e.g.: "application/pdf,image/*".
-   * Using "*" will allow every file type to be uploaded.
-   */
-  usAccept: PropTypes__default.default.string,
-  usButtonText: PropTypes__default.default.string,
-  usDisabled: PropTypes__default.default.bool,
-  usDropMessage: PropTypes__default.default.string,
-  usHelpImage: PropTypes__default.default.node,
-  usLabel: PropTypes__default.default.string,
-  usPlaceholder: PropTypes__default.default.string,
-  uploadStep: PropTypes__default.default.oneOf(['uploadImageStep', 'mediaUploadStep'])
-};
-Upload.defaultProps = {
-  animationDelay: 700,
-  csButtonText: undefined,
-  csFailureText: undefined,
-  csSuccessText: undefined,
-  csTooLargeMessage: undefined,
-  csWrongTypeMessage: undefined,
-  httpOptions: null,
-  maxSize: MAX_SIZE_DEFAULT,
-  onCancel: null,
-  onFailure: null,
-  onStart: null,
-  onSuccess: null,
-  psButtonText: undefined,
-  psButtonDisabled: false,
-  psProcessingText: undefined,
-  size: 'md',
-  usAccept: 'image/*',
-  usButtonText: undefined,
-  usDisabled: false,
-  usDropMessage: undefined,
-  usHelpImage: '',
-  usLabel: '',
-  usPlaceholder: undefined,
-  uploadStep: exports.UploadStep.UPLOAD_IMAGE_STEP
-};
 var Upload$1 = reactIntl.injectIntl(Upload);
 
 var MESSAGES$2 = reactIntl.defineMessages({
@@ -13471,7 +13228,7 @@ const UploadInput = ({
           name
         } = file;
         const id = generateFileId(file);
-        const allowedFileTypes = Array.isArray(fileTypes) ? fileTypes.join(',') : fileTypes;
+        const allowedFileTypes = typeof fileTypes === 'string' ? fileTypes : fileTypes.join(',');
         // Check if file type is valid
         if (!isTypeValid(file, allowedFileTypes)) {
           handleFileUploadFailure(file, formatMessage(MESSAGES$2.fileTypeNotSupported));