@scaleflex/widget-xhr-upload 0.0.1

package/lib/index.js

@@ -0,0 +1,794 @@
+var _excluded = ["isVideoProcessActive"],
+  _excluded2 = ["isImageProcessActive"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function _get() { return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) { var p = _superPropBase(e, t); if (p) { var n = Object.getOwnPropertyDescriptor(p, t); return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value; } }, _get.apply(null, arguments); }
+function _superPropBase(t, o) { for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t));); return t; }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import { Plugin } from '@scaleflex/widget-core';
+import cuid from 'cuid';
+import Translator from '@scaleflex/widget-utils/lib/Translator';
+import { Provider, RequestClient, Socket } from '@scaleflex/widget-companion-client';
+import emitSocketProgress from '@scaleflex/widget-utils/lib/emitSocketProgress';
+import getSocketHost from '@scaleflex/widget-utils/lib/getSocketHost';
+import settle from '@scaleflex/widget-utils/lib/settle';
+import EventTracker from '@scaleflex/widget-utils/lib/EventTracker';
+import ProgressTimeout from '@scaleflex/widget-utils/lib/ProgressTimeout';
+import RateLimitedQueue from '@scaleflex/widget-utils/lib/RateLimitedQueue';
+import NetworkError from '@scaleflex/widget-utils/lib/NetworkError';
+import isNetworkError from '@scaleflex/widget-utils/lib/isNetworkError';
+import isSupportedVideo from '@scaleflex/widget-utils/lib/isSupportedVideo';
+import isImage from '@scaleflex/widget-utils/lib/isImage';
+import checkConnection from '@scaleflex/widget-utils/lib/checkConnection';
+import { uploadCapabilitiesUpdated } from '@scaleflex/widget-core/lib/slices/uploads.slice';
+import { selectUserSassKey } from '@scaleflex/widget-core/lib/slices/user.slice';
+import { PROGRESS_PANEL_STATUS, PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+
+// TODO: find a way to show version of the current plugin
+// why solution below isn't good?
+// first import doesn't work with webpack 5 as it was deprecated
+// second import fixes webpack 5 issue as it was mentioned in their docs
+// but it exposes our package.json to the client and it is mentioned as security rist in mutiple places
+// https://github.com/axelpale/genversion
+// https://stackoverflow.com/questions/64993118/error-should-not-import-the-named-export-version-imported-as-version
+// https://stackoverflow.com/questions/9153571/is-there-a-way-to-get-version-from-package-json-in-nodejs-code/10855054#10855054
+// import { version } from '../package.json'
+// import packageInfo from '../package.json'
+
+var FIELD_NAME = 'files[]';
+function buildResponseError(xhr, error) {
+  // No error message
+  if (!error) error = new Error('Upload error');
+  // Got an error message string
+  if (typeof error === 'string') error = new Error(error);
+  // Got something else
+  if (!(error instanceof Error)) {
+    error = _extends(new Error('Upload error'), {
+      data: error
+    });
+  }
+  if (isNetworkError(xhr)) {
+    error = new NetworkError(error, xhr);
+    return error;
+  }
+  error.request = xhr;
+  return error;
+}
+
+/**
+ * Set `data.type` in the blob to `file.info.type`,
+ * because we might have detected a more accurate file type in Filerobot
+ * https://stackoverflow.com/a/50875615
+ *
+ * @param {object} file File object with `data`, `size` and `info` properties
+ * @returns {object} blob updated with the new `type` set from `file.info.type`
+ */
+function setTypeInBlob(file) {
+  var dataWithUpdatedType = file.data.slice(0, file.data.size, file.info.type);
+  return dataWithUpdatedType;
+}
+var XHRUpload = /*#__PURE__*/function (_Plugin) {
+  // static VERSION = packageInfo.version
+
+  function XHRUpload(filerobot) {
+    var _this;
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, XHRUpload);
+    _this = _callSuper(this, XHRUpload, [filerobot, opts]);
+    _this.type = 'uploader';
+    _this.id = _this.opts.id || PLUGINS_IDS.XHR_UPLOAD;
+    _this.title = 'XHRUpload';
+    _this.defaultLocale = {
+      strings: {
+        timedOut: 'Upload stalled for %{seconds} seconds, aborting.'
+      }
+    };
+
+    // Default options
+    var defaultOptions = {
+      dev: false,
+      uploadQueryParams: '',
+      method: 'post',
+      responseUrlFieldName: 'url',
+      uploadToFolderPath: null,
+      bundle: false,
+      headers: {},
+      timeout: 60 * 1000,
+      limit: 0,
+      withCredentials: false,
+      responseType: '',
+      info: undefined,
+      addInfoCallback: undefined,
+      meta: undefined,
+      skipUpload: false,
+      /**
+       * @typedef respObj
+       * @property {string} responseText
+       * @property {number} status
+       * @property {string} statusText
+       * @property {object.<string, string>} headers
+       *
+       * @param {string} responseText the response body string
+       * @param {XMLHttpRequest | respObj} response the response object (XHR or similar)
+       */
+      getResponseData: function getResponseData(responseText, response) {
+        var parsedResponse = {};
+        try {
+          parsedResponse = JSON.parse(responseText);
+        } catch (err) {
+          console.log(err);
+        }
+        return parsedResponse;
+      },
+      /**
+       *
+       * @param {string} responseText the response body string
+       * @param {XMLHttpRequest | respObj} response the response object (XHR or similar)
+       */
+      getResponseError: function getResponseError(responseText, response) {
+        var error = new Error('Upload error');
+        if (isNetworkError(response)) {
+          error = new NetworkError(error, response);
+        }
+        if (responseText) {
+          var jsonedResponse = JSON.parse(responseText);
+          if (jsonedResponse.hint || jsonedResponse.msg) {
+            error = new Error(jsonedResponse.hint || jsonedResponse.msg);
+          }
+        }
+        return error;
+      },
+      /**
+       * Check if the response from the upload endpoint indicates that the upload was successful.
+       *
+       * @param {number} status the response status code
+       * @param {string} responseText the response body string
+       * @param {XMLHttpRequest | respObj} response the response object (XHR or similar)
+       */
+      validateStatus: function validateStatus(status, responseText, response) {
+        return status >= 200 && status < 300;
+      }
+    };
+    _this.opts = _objectSpread(_objectSpread({}, defaultOptions), opts);
+    _this.opts.endpoint = _this.getUploadEndpoint();
+    _this.opts.headers['X-Filerobot-Key'] = selectUserSassKey(_this.getGlobalState()) || filerobot.opts.sassKey;
+    if (!_this.opts.headers['X-Filerobot-Key']) {
+      filerobot.on('sass-key-obtained', function (sassKey) {
+        _this.opts.headers['X-Filerobot-Key'] = sassKey;
+      });
+    }
+    _this.i18nInit();
+    _this.handleUpload = _this.handleUpload.bind(_this);
+
+    // Simultaneous upload limiting is shared across all uploads with this plugin.
+    // __queue is for internal Filerobot use only!
+    if (_this.opts.__queue instanceof RateLimitedQueue) {
+      _this.requests = _this.opts.__queue;
+    } else {
+      _this.requests = new RateLimitedQueue(_this.opts.limit);
+    }
+    _this.filerobotEvents = Object.create(null);
+    return _this;
+  }
+  _inherits(XHRUpload, _Plugin);
+  return _createClass(XHRUpload, [{
+    key: "setOptions",
+    value: function setOptions(newOpts) {
+      _superPropGet(XHRUpload, "setOptions", this, 3)([newOpts]);
+      this.i18nInit();
+    }
+  }, {
+    key: "getUploadEndpoint",
+    value: function getUploadEndpoint() {
+      return "".concat(this.filerobot.opts.apiEndpointWithContainer, "/v4/files");
+    }
+  }, {
+    key: "i18nInit",
+    value: function i18nInit() {
+      this.translator = new Translator([this.defaultLocale, this.filerobot.locale, this.opts.locale]);
+      this.i18n = this.translator.translate.bind(this.translator);
+    }
+  }, {
+    key: "getOptions",
+    value: function getOptions(file) {
+      var overrides = this.filerobot.getCoreCommonState().xhrUpload;
+      var opts = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.opts), overrides || {}), file.xhrUpload || {}), {}, {
+        headers: {}
+      });
+      _extends(opts.headers, this.opts.headers);
+      if (overrides) {
+        _extends(opts.headers, overrides.headers);
+      }
+      if (file.xhrUpload) {
+        _extends(opts.headers, file.xhrUpload.headers);
+      }
+      return opts;
+    }
+  }, {
+    key: "getRelativeFileName",
+    value: function getRelativeFileName(file) {
+      var _file$data;
+      return typeof ((_file$data = file.data) === null || _file$data === void 0 ? void 0 : _file$data.relativePath) === 'string' ? file.data.relativePath.substr(1).replaceAll('/', '|') : '';
+    }
+  }, {
+    key: "createFormDataUpload",
+    value: function createFormDataUpload(file, opts) {
+      var formPost = new FormData();
+      if (file.meta && Object.keys(file.meta).length > 0 || opts.meta && Object.keys(opts.meta).length > 0) {
+        formPost.append("meta[".concat(FIELD_NAME, "]"), JSON.stringify(_objectSpread(_objectSpread({}, file.meta), opts.meta)));
+      }
+      if (file.info && Object.keys(file.info).length > 0 || opts.info && Object.keys(opts.info).length > 0 || typeof this.opts.addInfoCallback === 'function') {
+        var _this$opts$addInfoCal, _this$opts;
+        var infoFromCbFn = (_this$opts$addInfoCal = (_this$opts = this.opts).addInfoCallback) === null || _this$opts$addInfoCal === void 0 ? void 0 : _this$opts$addInfoCal.call(_this$opts, file);
+        formPost.append("info[".concat(FIELD_NAME, "]"), JSON.stringify(_objectSpread(_objectSpread(_objectSpread({}, file.info), opts.info), _typeof(infoFromCbFn) === 'object' ? infoFromCbFn : {})));
+      }
+      if (file.tags && Object.keys(file.tags).length > 0 || opts.tags && Object.keys(opts.tags).length > 0) {
+        var tagLang = Object.keys(file.tags)[0];
+        formPost.append("tags[".concat(FIELD_NAME, "]"), JSON.stringify({
+          //   ...file.tags,
+          //   ...opts.tags
+          lang: tagLang,
+          new_tags: file.tags[tagLang].map(function (_ref) {
+            var sid = _ref.sid,
+              label = _ref.label;
+            return sid || label;
+          })
+        }));
+      }
+      if (file.product && Object.keys(file.product).length > 0 || opts.product && Object.keys(opts.product).length > 0) {
+        formPost.append("product[".concat(FIELD_NAME, "]"), JSON.stringify(_objectSpread(_objectSpread({}, file.product), opts.product)));
+      }
+      var dataWithUpdatedType = setTypeInBlob(file);
+      var fileName = file.name || this.getRelativeFileName(file);
+      if (fileName) {
+        formPost.append(FIELD_NAME, dataWithUpdatedType, fileName);
+      } else {
+        formPost.append(FIELD_NAME, dataWithUpdatedType);
+      }
+      return formPost;
+    }
+  }, {
+    key: "createBundledUpload",
+    value: function createBundledUpload(files, opts) {
+      var _this2 = this;
+      var formPost = new FormData();
+      files.forEach(function (file) {
+        var dataWithUpdatedType = setTypeInBlob(file);
+        var fileName = file.name || _this2.getRelativeFileName(file);
+        if (fileName) {
+          formPost.append(FIELD_NAME, dataWithUpdatedType, fileName);
+        } else {
+          formPost.append(FIELD_NAME, dataWithUpdatedType);
+        }
+      });
+      return formPost;
+    }
+  }, {
+    key: "upload",
+    value: function upload(_ref2) {
+      var _this3 = this;
+      var file = _ref2.file,
+        uploadId = _ref2.uploadId,
+        current = _ref2.current,
+        total = _ref2.total;
+      var opts = this.getOptions(file);
+      this.filerobot.log("uploading ".concat(current, " of ").concat(total));
+      return new Promise(function (resolve, reject) {
+        var _videoTranscoding$fil, _imageProcessor$files, _file$toFolder, _opts$uploadToFolderP;
+        _this3.filerobot.emit('upload-started', file, {
+          uploadId: uploadId
+        });
+        var data = file.uploadUrl ? JSON.stringify({
+          files_urls: [{
+            url: file.uploadUrl,
+            name: file.name
+          }]
+        }) : _this3.createFormDataUpload(file, opts);
+        var xhr = new XMLHttpRequest();
+        _this3.filerobotEvents[file.id] = new EventTracker(_this3.filerobot);
+        var timer = new ProgressTimeout(opts.timeout, function () {
+          xhr.abort();
+          queuedRequest.done();
+          var error = new Error(_this3.i18n('timedOut', {
+            seconds: Math.ceil(opts.timeout / 1000)
+          }));
+          _this3.filerobot.emit('upload-error', file, error, {
+            uploadId: uploadId
+          });
+          reject(error);
+        });
+        var id = cuid();
+        xhr.upload.addEventListener('loadstart', function (ev) {
+          _this3.filerobot.log("[XHRUpload] ".concat(id, " started"));
+        });
+        xhr.upload.addEventListener('progress', function (ev) {
+          _this3.filerobot.log("[XHRUpload] ".concat(id, " progress: ").concat(ev.loaded, " / ").concat(ev.total));
+          // Begin checking for timeouts when progress starts, instead of loading,
+          // to avoid timing out requests on browser concurrency queue
+          timer.progress();
+          var isOnline = checkConnection();
+          if (!isOnline) {
+            xhr.abort();
+            queuedRequest.done();
+            var error = new Error(_this3.i18n('filerobotNoInternetConnectionInfo'));
+            _this3.filerobot.emit('upload-error', file, error, {
+              uploadId: uploadId
+            });
+            reject(error);
+          }
+          if (ev.lengthComputable) {
+            _this3.filerobot.emit('upload-progress', file, {
+              filerobot: _this3,
+              bytesFinished: ev.loaded,
+              bytesTotal: ev.total,
+              uploadId: uploadId
+            });
+          }
+        });
+        xhr.addEventListener('load', function (ev) {
+          _this3.filerobot.log("[XHRUpload] ".concat(id, " finished"));
+          timer.done();
+          queuedRequest.done();
+          if (_this3.filerobotEvents[file.id]) {
+            _this3.filerobotEvents[file.id].remove();
+            _this3.filerobotEvents[file.id] = null;
+          }
+          if (opts.validateStatus(ev.target.status, xhr.responseText, xhr)) {
+            var body = opts.getResponseData(xhr.responseText, xhr);
+            var uploadURL = body[opts.responseUrlFieldName];
+            var uploadResp = {
+              status: ev.target.status,
+              body: body,
+              uploadURL: uploadURL
+            };
+            _this3.filerobot.emit('upload-success', _objectSpread(_objectSpread({}, file), uploadResp.body.file), uploadResp, {
+              uploadId: uploadId
+            });
+            if (uploadURL) {
+              _this3.filerobot.log("Download ".concat(file.name, " from ").concat(uploadURL));
+            }
+            return resolve(file);
+          } else {
+            var _body = opts.getResponseData(xhr.responseText, xhr);
+            var error = buildResponseError(xhr, opts.getResponseError(xhr.responseText, xhr));
+            var response = {
+              status: ev.target.status,
+              body: _body
+            };
+            _this3.filerobot.emit('upload-error', file, error, {
+              response: response,
+              uploadId: uploadId
+            });
+            return reject(error);
+          }
+        });
+        xhr.addEventListener('error', function (ev) {
+          _this3.filerobot.log("[XHRUpload] ".concat(id, " errored"));
+          timer.done();
+          queuedRequest.done();
+          if (_this3.filerobotEvents[file.id]) {
+            _this3.filerobotEvents[file.id].remove();
+            _this3.filerobotEvents[file.id] = null;
+          }
+          var error = buildResponseError(xhr, opts.getResponseError(xhr.responseText, xhr));
+          _this3.filerobot.emit('upload-error', file, error, {
+            uploadId: uploadId
+          });
+          return reject(error);
+        });
+        var _this3$filerobot$getC = _this3.filerobot.getCoreCommonState(),
+          _this3$filerobot$getC2 = _this3$filerobot$getC.dndTargetFolderPath,
+          dndTargetFolderPath = _this3$filerobot$getC2 === void 0 ? '/' : _this3$filerobot$getC2,
+          _this3$filerobot$getC3 = _this3$filerobot$getC.videoTranscoding,
+          _this3$filerobot$getC4 = _this3$filerobot$getC3 === void 0 ? {} : _this3$filerobot$getC3,
+          _this3$filerobot$getC5 = _this3$filerobot$getC4.isVideoProcessActive,
+          isVideoProcessActive = _this3$filerobot$getC5 === void 0 ? false : _this3$filerobot$getC5,
+          videoTranscoding = _objectWithoutProperties(_this3$filerobot$getC4, _excluded),
+          _this3$filerobot$getC6 = _this3$filerobot$getC.imageProcessor,
+          _this3$filerobot$getC7 = _this3$filerobot$getC6 === void 0 ? {} : _this3$filerobot$getC6,
+          _this3$filerobot$getC8 = _this3$filerobot$getC7.isImageProcessActive,
+          isImageProcessActive = _this3$filerobot$getC8 === void 0 ? false : _this3$filerobot$getC8,
+          imageProcessor = _objectWithoutProperties(_this3$filerobot$getC7, _excluded2),
+          _this3$filerobot$getC9 = _this3$filerobot$getC.fromDragging,
+          fromDragging = _this3$filerobot$getC9 === void 0 ? false : _this3$filerobot$getC9,
+          _this3$filerobot$getC10 = _this3$filerobot$getC.isQuickUploader,
+          isQuickUploader = _this3$filerobot$getC10 === void 0 ? false : _this3$filerobot$getC10;
+        var preprocessorParamsIfFound = '';
+        var allowVideoProcesses = isSupportedVideo(file) && isVideoProcessActive && ((_videoTranscoding$fil = videoTranscoding.filesIds) === null || _videoTranscoding$fil === void 0 ? void 0 : _videoTranscoding$fil.includes(file.id));
+        var allowImageProcesses = isImage(file) && isImageProcessActive && ((_imageProcessor$files = imageProcessor.filesIds) === null || _imageProcessor$files === void 0 ? void 0 : _imageProcessor$files.includes(file.id));
+        if (allowVideoProcesses) {
+          preprocessorParamsIfFound = "&postprocess=transcode&video-resolution=".concat(videoTranscoding.resolution, "&video_protocols=").concat(videoTranscoding.protocol);
+        } else if (allowImageProcesses) {
+          preprocessorParamsIfFound = "&resize=".concat(imageProcessor.values.width, ",").concat(imageProcessor.values.height);
+        }
+        var fileXhrQueryParams = Object.keys(file.xhrQueryParams || {});
+        var fileQueryParams = fileXhrQueryParams.map(function (key) {
+          return "".concat(key, "=").concat(file.xhrQueryParams[key]);
+        }).join('&');
+        var folder = opts.uploadQueryParams.search('(^|&)folder=') > -1 ? '' : "?folder=".concat(encodeURIComponent((_file$toFolder = file.toFolder) !== null && _file$toFolder !== void 0 ? _file$toFolder : ((_opts$uploadToFolderP = opts.uploadToFolderPath) !== null && _opts$uploadToFolderP !== void 0 ? _opts$uploadToFolderP : fromDragging) ? dndTargetFolderPath : '/'));
+        var finalEndpoint = "".concat(opts.endpoint).concat(folder).concat(opts.uploadQueryParams ? "".concat(folder ? '&' : '?').concat(opts.uploadQueryParams) : '').concat(isQuickUploader ? '&upload_mode=quick' : '').concat(preprocessorParamsIfFound).concat(fileQueryParams ? "&".concat(fileQueryParams) : '');
+        xhr.open(opts.method.toUpperCase(), finalEndpoint, true);
+        // IE10 does not allow setting `withCredentials` and `responseType`
+        // before `open()` is called.
+        xhr.withCredentials = opts.withCredentials;
+        if (opts.responseType !== '') {
+          xhr.responseType = opts.responseType;
+        }
+        var headers = _objectSpread(_objectSpread({}, opts.headers), file.xhrHeaders);
+        Object.keys(headers).forEach(function (header) {
+          xhr.setRequestHeader(header, headers[header]);
+        });
+        var queuedRequest = _this3.requests.run(function () {
+          xhr.send(data);
+          return function () {
+            timer.done();
+            xhr.abort();
+          };
+        });
+        _this3.onFileRemove(file.id, function () {
+          queuedRequest.abort();
+          reject(new Error('File removed'));
+        });
+        _this3.onCancelAll(file.id, function () {
+          queuedRequest.abort();
+          reject(new Error('Upload cancelled'));
+        });
+      });
+    }
+  }, {
+    key: "uploadRemote",
+    value: function uploadRemote(_ref3) {
+      var _this4 = this;
+      var file = _ref3.file,
+        uploadId = _ref3.uploadId;
+      var opts = this.getOptions(file);
+      return new Promise(function (resolve, reject) {
+        var _this4$opts$addInfoCa, _this4$opts;
+        var _this4$filerobot$getC = _this4.filerobot.getCoreCommonState(),
+          _this4$filerobot$getC2 = _this4$filerobot$getC.videoTranscoding,
+          _this4$filerobot$getC3 = _this4$filerobot$getC2 === void 0 ? {} : _this4$filerobot$getC2,
+          isVideoProcessActive = _this4$filerobot$getC3.isVideoProcessActive,
+          videoFilesIds = _this4$filerobot$getC3.filesIds,
+          resolution = _this4$filerobot$getC3.resolution,
+          protocol = _this4$filerobot$getC3.protocol,
+          _this4$filerobot$getC4 = _this4$filerobot$getC.imageProcessor,
+          _this4$filerobot$getC5 = _this4$filerobot$getC4 === void 0 ? {} : _this4$filerobot$getC4,
+          isImageProcessActive = _this4$filerobot$getC5.isImageProcessActive,
+          filesIds = _this4$filerobot$getC5.filesIds,
+          values = _this4$filerobot$getC5.values;
+        var allowImageProcesses = isImage(file) && isImageProcessActive && (filesIds === null || filesIds === void 0 ? void 0 : filesIds.includes(file.id));
+        var allowVideoProcesses = isSupportedVideo(file) && isVideoProcessActive && (videoFilesIds === null || videoFilesIds === void 0 ? void 0 : videoFilesIds.includes(file.id));
+        _this4.filerobot.emit('upload-started', file, {
+          uploadId: uploadId
+        });
+        var folderPath = _this4.filerobot.getRemoteUploadFolder({
+          file: file,
+          opts: opts
+        });
+        var restUploadQueryParams = opts.uploadQueryParams.split('&').filter(function (item) {
+          return !/^folder=/.test(item);
+        }).join('&');
+        var infoFromCbFn = (_this4$opts$addInfoCa = (_this4$opts = _this4.opts).addInfoCallback) === null || _this4$opts$addInfoCa === void 0 ? void 0 : _this4$opts$addInfoCa.call(_this4$opts, file);
+        var fields = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, file.info), _this4.opts.info), _typeof(infoFromCbFn) === 'object' ? infoFromCbFn : {}), {}, {
+          meta: JSON.stringify(file.meta || {}),
+          name: file.name,
+          'filerobot-folder': folderPath
+        });
+        if (allowVideoProcesses) {
+          fields['video-resolution'] = resolution;
+          fields['video-protocols'] = protocol;
+        } else if (allowImageProcesses) {
+          fields.resize = "".concat(values.width, ",").concat(values.height);
+        }
+        var Client = file.remote.providerOptions.provider ? Provider : RequestClient;
+        var client = new Client(_this4.filerobot, file.remote.providerOptions);
+        client.post(file.remote.url, _objectSpread(_objectSpread({}, file.remote.body), {}, {
+          endpoint: "".concat(opts.endpoint, "?folder=").concat(encodeURIComponent(folderPath)).concat(restUploadQueryParams ? "&".concat(restUploadQueryParams) : ''),
+          size: file.data.size,
+          fieldname: FIELD_NAME,
+          metadata: fields,
+          httpMethod: opts.method,
+          useFormData: true,
+          headers: opts.headers
+        })).then(function (res) {
+          var token = res.token;
+          var host = getSocketHost(file.remote.companionUrl);
+          var socket = new Socket({
+            target: "".concat(host, "/api/").concat(token),
+            autoOpen: false
+          });
+          _this4.filerobotEvents[file.id] = new EventTracker(_this4.filerobot);
+          _this4.onFileRemove(file.id, function () {
+            socket.send('cancel', {});
+            queuedRequest.abort();
+            resolve("upload ".concat(file.id, " was removed"));
+          });
+          _this4.onCancelAll(file.id, function () {
+            socket.send('cancel', {});
+            queuedRequest.abort();
+            resolve("upload ".concat(file.id, " was canceled"));
+          });
+          _this4.onRetry(file.id, function () {
+            socket.send('pause', {});
+            socket.send('resume', {});
+          });
+          _this4.onRetryAll(file.id, function () {
+            socket.send('pause', {});
+            socket.send('resume', {});
+          });
+          socket.on('progress', function (progressData) {
+            return emitSocketProgress(_this4, progressData, file);
+          });
+          socket.on('success', function (data) {
+            var body = opts.getResponseData(data.response.responseText, data.response);
+            var uploadURL = body[opts.responseUrlFieldName];
+            var uploadResp = {
+              status: data.response.status,
+              body: body,
+              uploadURL: uploadURL
+            };
+            _this4.filerobot.emit('upload-success', _objectSpread(_objectSpread({}, file), uploadResp.body.file), uploadResp, {
+              uploadId: uploadId
+            });
+            queuedRequest.done();
+            if (_this4.filerobotEvents[file.id]) {
+              _this4.filerobotEvents[file.id].remove();
+              _this4.filerobotEvents[file.id] = null;
+            }
+            return resolve();
+          });
+          socket.on('error', function (errData) {
+            var resp = errData.response;
+            var error = resp ? opts.getResponseError(resp.responseText, resp) : _extends(new Error(errData.error.message), {
+              cause: errData.error
+            });
+            _this4.filerobot.emit('upload-error', file, error, {
+              uploadId: uploadId
+            });
+            queuedRequest.done();
+            if (_this4.filerobotEvents[file.id]) {
+              _this4.filerobotEvents[file.id].remove();
+              _this4.filerobotEvents[file.id] = null;
+            }
+            reject(error);
+          });
+          var queuedRequest = _this4.requests.run(function () {
+            socket.open();
+            if (file.progress.status === PROGRESS_PANEL_STATUS.PAUSED) {
+              socket.send('pause', {});
+            }
+            return function () {
+              return socket.close();
+            };
+          });
+        })["catch"](function (err) {
+          _this4.filerobot.emit('upload-error', file, err, {
+            uploadId: uploadId
+          });
+          reject(err);
+        });
+      });
+    }
+  }, {
+    key: "uploadBundle",
+    value: function uploadBundle(files, uploadId) {
+      var _this5 = this;
+      return new Promise(function (resolve, reject) {
+        var endpoint = _this5.opts.endpoint;
+        var method = _this5.opts.method;
+        var optsFromState = _this5.filerobot.getCoreCommonState().xhrUpload;
+        var formData = _this5.createBundledUpload(files, _objectSpread(_objectSpread({}, _this5.opts), optsFromState || {}));
+        var xhr = new XMLHttpRequest();
+        var timer = new ProgressTimeout(_this5.opts.timeout, function () {
+          xhr.abort();
+          var error = new Error(_this5.i18n('timedOut', {
+            seconds: Math.ceil(_this5.opts.timeout / 1000)
+          }));
+          emitError(error);
+          reject(error);
+        });
+        var emitError = function emitError(error) {
+          files.forEach(function (file) {
+            _this5.filerobot.emit('upload-error', file, error, {
+              uploadId: uploadId
+            });
+          });
+        };
+        xhr.upload.addEventListener('loadstart', function (ev) {
+          _this5.filerobot.log('[XHRUpload] started uploading bundle');
+          timer.progress();
+        });
+        xhr.upload.addEventListener('progress', function (ev) {
+          timer.progress();
+          if (!ev.lengthComputable) return;
+          files.forEach(function (file) {
+            _this5.filerobot.emit('upload-progress', file, {
+              filerobot: _this5,
+              bytesFinished: ev.loaded / ev.total * file.size,
+              bytesTotal: file.size,
+              uploadId: uploadId
+            });
+          });
+        });
+        xhr.addEventListener('load', function (ev) {
+          timer.done();
+          if (_this5.opts.validateStatus(ev.target.status, xhr.responseText, xhr)) {
+            var body = _this5.opts.getResponseData(xhr.responseText, xhr);
+            var uploadResp = {
+              status: ev.target.status,
+              body: body
+            };
+            files.forEach(function (file) {
+              _this5.filerobot.emit('upload-success', _objectSpread(_objectSpread({}, file), uploadResp.body.file), uploadResp, {
+                uploadId: uploadId
+              });
+            });
+            return resolve();
+          }
+          var error = _this5.opts.getResponseError(xhr.responseText, xhr) || new Error('Upload error');
+          error.request = xhr;
+          emitError(error);
+          return reject(error);
+        });
+        xhr.addEventListener('error', function (ev) {
+          timer.done();
+          var error = _this5.opts.getResponseError(xhr.responseText, xhr) || new Error('Upload error');
+          emitError(error);
+          return reject(error);
+        });
+        _this5.filerobot.on('cancel-uploads', function () {
+          timer.done();
+          xhr.abort();
+        });
+        xhr.open(method.toUpperCase(), endpoint, true);
+        // IE10 does not allow setting `withCredentials` and `responseType`
+        // before `open()` is called.
+        xhr.withCredentials = _this5.opts.withCredentials;
+        if (_this5.opts.responseType !== '') {
+          xhr.responseType = _this5.opts.responseType;
+        }
+        Object.keys(_this5.opts.headers).forEach(function (header) {
+          xhr.setRequestHeader(header, _this5.opts.headers[header]);
+        });
+        xhr.send(formData);
+        files.forEach(function (file) {
+          _this5.filerobot.emit('upload-started', file, {
+            uploadId: uploadId
+          });
+        });
+      });
+    }
+  }, {
+    key: "uploadFiles",
+    value: function uploadFiles(files, uploadId) {
+      var _this6 = this;
+      var total = files.length;
+      var promises = files.map(function (file, i) {
+        var current = parseInt(i, 10) + 1;
+        if (file.error) {
+          return Promise.reject(new Error(file.error));
+        } else if (file.isRemote) {
+          return _this6.uploadRemote({
+            file: file,
+            uploadId: uploadId
+          });
+        } else {
+          return _this6.upload({
+            file: file,
+            uploadId: uploadId,
+            current: current,
+            total: total
+          });
+        }
+      });
+      return settle(promises);
+    }
+  }, {
+    key: "onFileRemove",
+    value: function onFileRemove(fileId, cb) {
+      this.filerobotEvents[fileId].on('file-removed', function (file) {
+        if (fileId === file.id) cb(file.id);
+      });
+    }
+  }, {
+    key: "onRetry",
+    value: function onRetry(fileId, cb) {
+      this.filerobotEvents[fileId].on('upload-retry', function (targetFileID) {
+        if (fileId === targetFileID) {
+          cb();
+        }
+      });
+    }
+  }, {
+    key: "onRetryAll",
+    value: function onRetryAll(fileId, cb) {
+      var _this7 = this;
+      this.filerobotEvents[fileId].on('retry-all', function (filesToRetry) {
+        if (!_this7.filerobot.getFileUploading(fileId)) return;
+        cb();
+      });
+    }
+  }, {
+    key: "onCancelAll",
+    value: function onCancelAll(fileId, cb) {
+      var _this8 = this;
+      this.filerobotEvents[fileId].on('cancel-uploads', function () {
+        if (!_this8.filerobot.getFileUploading(fileId)) return;
+        cb();
+      });
+    }
+  }, {
+    key: "handleUpload",
+    value: function handleUpload(fileIds, uploadId) {
+      var _this9 = this;
+      if (fileIds.length === 0) {
+        this.filerobot.log('[XHRUpload] No files to upload!');
+        return Promise.resolve();
+      }
+      if (this.opts.skipUpload) {
+        // Duplicated logic from Hub to support FRA-6565
+        return Promise.resolve();
+      }
+
+      // no limit configured by the user, and no RateLimitedQueue passed in by a "parent" plugin (basically just AwsS3) using the top secret `__queue` option
+      if (this.opts.limit === 0 && !this.opts.__queue) {
+        this.filerobot.log('[XHRUpload] When uploading multiple files at once, consider setting the `limit` option (to `10` for example), to limit the number of concurrent uploads, which helps prevent memory and network issues.', 'warning');
+      }
+      this.filerobot.log('[XHRUpload] Uploading...');
+      var files = fileIds.map(function (fileId) {
+        return _this9.filerobot.getFileUploading(fileId);
+      });
+      if (this.opts.bundle) {
+        // if bundle: true, we don’t support remote uploads
+        var isSomeFileRemote = files.some(function (file) {
+          return file.isRemote;
+        });
+        if (isSomeFileRemote) {
+          throw new Error('Can’t upload remote files when bundle: true option is set');
+        }
+        return this.uploadBundle(files, uploadId);
+      }
+      return this.uploadFiles(files, uploadId).then(function () {
+        return null;
+      });
+    }
+  }, {
+    key: "install",
+    value: function install() {
+      if (this.opts.bundle) {
+        this.dispatch(uploadCapabilitiesUpdated({
+          allowIndividualCancellation: false
+        }));
+      }
+      this.filerobot.addFilerobot(this.handleUpload);
+    }
+  }, {
+    key: "uninstall",
+    value: function uninstall() {
+      if (this.opts.bundle) {
+        this.dispatch(uploadCapabilitiesUpdated({
+          allowIndividualCancellation: true
+        }));
+      }
+      this.filerobot.removeFilerobot(this.handleUpload);
+    }
+  }]);
+}(Plugin);
+export { XHRUpload as default };