@scaleflex/widget-tus 0.0.1

package/lib/index.js

@@ -0,0 +1,983 @@
+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 _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); }
+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 _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 _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 _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 _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 _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); }
+import { Plugin } from '@scaleflex/widget-core';
+import { Upload } from 'tus-js-client';
+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 NetworkError from '@scaleflex/widget-utils/lib/NetworkError';
+import isNetworkError from '@scaleflex/widget-utils/lib/isNetworkError';
+import RateLimitedQueue from '@scaleflex/widget-utils/lib/RateLimitedQueue';
+import hasProperty from '@scaleflex/widget-utils/lib/hasProperty';
+import { COMPANION_URLS, PROGRESS_PANEL_STATUS, UPLOAD_CONNECTOR_SERVER } from '@scaleflex/widget-utils/lib/constants';
+import { uploadsReplaced, uploadCapabilitiesUpdated } from '@scaleflex/widget-core/lib/slices/uploads.slice';
+import { selectUserSassKey } from '@scaleflex/widget-core/lib/slices/user.slice';
+import Translator from '@scaleflex/widget-utils/lib/Translator';
+import getFingerprint from './getFingerprint';
+
+// 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'
+
+/** @typedef {import('../types').TusOptions} TusOptions */
+/** @typedef {import('tus-js-client').UploadOptions} RawTusOptions */
+/** @typedef {import('@scaleflex/widget-core').Filerobot} Filerobot */
+/** @typedef {import('@scaleflex/widget-core').FilerobotFile} FilerobotFile */
+/** @typedef {import('@scaleflex/widget-core').FailedFilerobotFile<{}>} FailedFilerobotFile */
+
+/**
+ * Extracted from https://github.com/tus/tus-js-client/blob/master/lib/upload.js#L13
+ * excepted we removed 'fingerprint' key to avoid adding more dependencies
+ *
+ * @type {RawTusOptions}
+ */
+var tusDefaultOptions = {
+  endpoint: '',
+  uploadUrl: null,
+  metadata: {},
+  uploadSize: null,
+  onProgress: null,
+  onChunkComplete: null,
+  onSuccess: null,
+  onError: null,
+  overridePatchMethod: false,
+  headers: {},
+  addRequestId: false,
+  chunkSize: Infinity,
+  retryDelays: [0, 1000, 3000, 5000],
+  parallelUploads: 1,
+  storeFingerprintForResuming: true,
+  removeFingerprintOnSuccess: true,
+  uploadLengthDeferred: false,
+  uploadDataDuringCreation: false
+};
+
+/**
+ * Tus resumable file filerobot
+ */
+var Tus = /*#__PURE__*/function (_Plugin) {
+  // static VERSION = packageInfo.version
+
+  /**
+   * @param {Filerobot} filerobot
+   * @param {TusOptions} opts
+   */
+  function Tus(filerobot) {
+    var _this$opts$retryDelay;
+    var _this;
+    var _opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, Tus);
+    _this = _callSuper(this, Tus, [filerobot, _opts]);
+    _defineProperty(_this, "successHandler", function (_ref) {
+      var _file$progress;
+      var _ref$fileResponse = _ref.fileResponse,
+        fileResponse = _ref$fileResponse === void 0 ? {} : _ref$fileResponse,
+        file = _ref.file,
+        uploadId = _ref.uploadId,
+        data = _ref.data,
+        queuedRequest = _ref.queuedRequest,
+        resolve = _ref.resolve;
+      if (file !== null && file !== void 0 && (_file$progress = file.progress) !== null && _file$progress !== void 0 && _file$progress.uploadComplete) return;
+      var fileJson = _objectSpread(_objectSpread({}, file.fileJson || {}), file);
+      fileJson === null || fileJson === void 0 ? true : delete fileJson.preview;
+      var uploadRes = {
+        uploadURL: data.url,
+        body: {
+          file: fileResponse
+        }
+      };
+      _this.resetFilerobotReferences(file.id);
+      queuedRequest.done();
+      _this.filerobot.emit('upload-success', fileJson, uploadRes, {
+        uploadId: uploadId
+      });
+      if (data.url) {
+        _this.filerobot.log("Download ".concat(data.file.name, " from ").concat(data.url));
+      }
+      resolve(data);
+    });
+    _defineProperty(_this, "getFileJson", async function (_ref2) {
+      var _uploadUrl$match;
+      var uploadUrl = _ref2.uploadUrl,
+        file = _ref2.file,
+        uploadId = _ref2.uploadId,
+        queuedRequest = _ref2.queuedRequest,
+        resolve = _ref2.resolve,
+        reject = _ref2.reject;
+      var retryLimit = 0;
+      var regex = /files\/(.*)/;
+      var id = (uploadUrl === null || uploadUrl === void 0 ? void 0 : (_uploadUrl$match = uploadUrl.match(regex)) === null || _uploadUrl$match === void 0 ? void 0 : _uploadUrl$match[1]) || '';
+      var fileSizeLimit = 1 * Math.pow(10, 8);
+      var isFileHasDelay = file.size > fileSizeLimit;
+      var delay = isFileHasDelay ? 13000 : 6000;
+      if (!id) return;
+      var req = new XMLHttpRequest();
+      var openRequest = function openRequest() {
+        req.open('GET', "".concat(_this.opts.jsonEndpoint, "/").concat(id));
+        req.onload = onSuccess;
+        req.onerror = onError;
+        req.send();
+      };
+      var onSuccess = function onSuccess(res) {
+        if (req.status !== 200 && retryLimit <= 3) {
+          retryLimit++;
+          if (isFileHasDelay && retryLimit === 1 && req.status === 404) {
+            _this.filerobot.info(_this.i18n('resumableUploadDelayInfo'), 'success');
+            _this.filerobot.setFileUploadingState(file.id, uploadId, {
+              progress: _objectSpread(_objectSpread({}, file.progress), {}, {
+                status: PROGRESS_PANEL_STATUS.DELAYED
+              })
+            });
+            _this.emit('activity-update', {
+              id: file.id,
+              progress: {
+                status: PROGRESS_PANEL_STATUS.DELAYED
+              }
+            });
+          }
+          setTimeout(function () {
+            openRequest();
+          }, delay);
+          return;
+        }
+        if (retryLimit === 4) {
+          _this.filerobot.setFileUploadingState(file.id, uploadId, {
+            progress: _objectSpread(_objectSpread({}, file.progress), {}, {
+              status: PROGRESS_PANEL_STATUS.COMPLETED
+            })
+          });
+        }
+        try {
+          var _JSON$parse;
+          var fileResponse = (_JSON$parse = JSON.parse(req === null || req === void 0 ? void 0 : req.response)) === null || _JSON$parse === void 0 ? void 0 : _JSON$parse.file;
+          if (!fileResponse) {
+            onError(res);
+            return;
+          }
+          _this.filerobot.setFileUploadingState(file.id, uploadId, {
+            fileJson: fileResponse
+          });
+          _this.successHandler({
+            fileResponse: fileResponse,
+            file: file,
+            uploadId: uploadId,
+            data: res,
+            queuedRequest: queuedRequest,
+            resolve: resolve
+          });
+        } catch (err) {
+          onError(err);
+        }
+      };
+      var onError = function onError(error) {
+        _this.filerobot.emit('upload-error', file, error, {
+          uploadId: uploadId
+        });
+        return reject(error);
+      };
+      openRequest();
+    });
+    _defineProperty(_this, "requestSocketToken", async function (file) {
+      var Client = file.remote.providerOptions.provider ? Provider : RequestClient;
+      var client = new Client(_this.filerobot, file.remote.providerOptions);
+      var opts = _objectSpread({}, _this.opts);
+      if (file.tus) {
+        // Install file-specific upload overrides.
+        _extends(opts, file.tus);
+      }
+      var res = await client.post(file.remote.url, _objectSpread(_objectSpread({}, file.remote.body), {}, {
+        endpoint: opts.endpoint,
+        uploadUrl: opts.uploadUrl,
+        protocol: 'tus',
+        size: file.data.size,
+        headers: opts.headers,
+        metadata: _objectSpread(_objectSpread({}, file.info), {}, {
+          'filerobot-folder': _this.filerobot.getRemoteUploadFolder({
+            file: file,
+            opts: _this.opts
+          })
+        })
+      }));
+      return res.token;
+    });
+    _this.type = 'uploader';
+    _this.id = _this.opts.id || 'Tus';
+    _this.title = 'Tus';
+    _this.defaultLocale = {
+      strings: {
+        resumableUploadDelayInfo: 'Assets uploaded. It takes few seconds to complete processing, after you can use your assets.'
+      }
+    };
+
+    // set default options
+    var defaultOptions = {
+      autoRetry: true,
+      resume: true,
+      useFastRemoteRetry: true,
+      limit: 20,
+      retryDelays: [0, 1000, 3000, 5000],
+      headers: {}
+    };
+
+    // merge default options with the ones set by user
+    /** @type {import("../types").TusOptions} */
+    _this.opts = _extends({}, defaultOptions, _opts);
+    _this.opts.headers['X-Filerobot-Token'] = filerobot.opts.container;
+    _this.opts.headers['X-Filerobot-Key'] = selectUserSassKey(_this.getGlobalState());
+    if (!_this.opts.headers['X-Filerobot-Key']) {
+      filerobot.on('sass-key-obtained', function (sassKey) {
+        _this.opts.headers['X-Filerobot-Key'] = sassKey;
+      });
+    }
+    if (!_this.opts.headers['X-Filerobot-Token']) {
+      _this.opts.headers['X-Filerobot-Token'] = filerobot.opts.container;
+    }
+    _this.i18nInit();
+    if (!_this.opts.endpoint || _this.opts.endpoint.length === 0) {
+      var companionProdUrl = sessionStorage.getItem(UPLOAD_CONNECTOR_SERVER) || COMPANION_URLS.PROD;
+      _this.opts.endpoint = "".concat(filerobot.opts.dev ? COMPANION_URLS.DEV : companionProdUrl, "/files");
+      _this.opts.jsonEndpoint = "".concat(filerobot.opts.dev ? COMPANION_URLS.DEV : companionProdUrl, "/json");
+    }
+
+    /**
+     * Simultaneous upload limiting is shared across all uploads with this plugin.
+     *
+     * @type {RateLimitedQueue}
+     */
+    _this.requests = new RateLimitedQueue(_this.opts.limit);
+    _this.retryDelayIterator = (_this$opts$retryDelay = _this.opts.retryDelays) === null || _this$opts$retryDelay === void 0 ? void 0 : _this$opts$retryDelay.values();
+    _this.filerobots = Object.create(null);
+    _this.filerobotEvents = Object.create(null);
+    _this.filerobotSockets = Object.create(null);
+    _this.handleResetProgress = _this.handleResetProgress.bind(_this);
+    _this.handleUpload = _this.handleUpload.bind(_this);
+    _this.queueRequestSocketToken = _this.requests.wrapPromiseFunction(_this.requestSocketToken, {
+      priority: -1
+    });
+    return _this;
+  }
+  _inherits(Tus, _Plugin);
+  return _createClass(Tus, [{
+    key: "handleResetProgress",
+    value: function handleResetProgress() {
+      var files = _extends({}, this.filerobot.getUploads());
+      Object.keys(files).forEach(function (fileId) {
+        // Only clone the file object if it has a Tus `uploadUrl` attached.
+        if (files[fileId].tus && files[fileId].tus.uploadUrl) {
+          var tusState = _extends({}, files[fileId].tus);
+          delete tusState.uploadUrl;
+          files[fileId] = _extends({}, files[fileId], {
+            tus: tusState
+          });
+        }
+      });
+      this.filerobot.dispatch(uploadsReplaced(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);
+    }
+
+    /**
+     * Clean up all references for a file's upload: the tus.Upload instance,
+     * any events related to the file, and the Companion WebSocket connection.
+     *
+     * @param {string} fileId
+     */
+  }, {
+    key: "resetFilerobotReferences",
+    value: function resetFilerobotReferences(fileId) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (this.filerobots[fileId]) {
+        var filerobot = this.filerobots[fileId];
+        filerobot.abort();
+        if (opts.abort) {
+          filerobot.abort(true);
+        }
+        this.filerobots[fileId] = null;
+      }
+      if (this.filerobotEvents[fileId]) {
+        this.filerobotEvents[fileId].remove();
+        this.filerobotEvents[fileId] = null;
+      }
+      if (this.filerobotSockets[fileId]) {
+        this.filerobotSockets[fileId].close();
+        this.filerobotSockets[fileId] = null;
+      }
+    }
+  }, {
+    key: "upload",
+    value:
+    /**
+     * Create a new Tus upload.
+     *
+     * A lot can happen during an upload, so this is quite hard to follow!
+     * - First, the upload is started. If the file was already paused by the time the upload starts, nothing should happen.
+     *   If the `limit` option is used, the upload must be queued onto the `this.requests` queue.
+     *   When an upload starts, we store the tus.Upload instance, and an EventTracker instance that manages the event listeners
+     *   for pausing, cancellation, removal, etc.
+     * - While the upload is in progress, it may be paused or cancelled.
+     *   Pausing aborts the underlying tus.Upload, and removes the upload from the `this.requests` queue. All other state is
+     *   maintained.
+     *   Cancelling removes the upload from the `this.requests` queue, and completely aborts the upload-- the `tus.Upload`
+     *   instance is aborted and discarded, the EventTracker instance is destroyed (removing all listeners).
+     *   Resuming the upload uses the `this.requests` queue as well, to prevent selectively pausing and resuming uploads from
+     *   bypassing the limit.
+     * - After completing an upload, the tus.Upload and EventTracker instances are cleaned up, and the upload is marked as done
+     *   in the `this.requests` queue.
+     * - When an upload completed with an error, the same happens as on successful completion, but the `upload()` promise is
+     *   rejected.
+     *
+     * When working on this function, keep in mind:
+     *  - When an upload is completed or cancelled for any reason, the tus.Upload and EventTracker instances need to be cleaned
+     *    up using this.resetFilerobotReferences().
+     *  - When an upload is cancelled or paused, for any reason, it needs to be removed from the `this.requests` queue using
+     *    `queuedRequest.abort()`.
+     *  - When an upload is completed for any reason, including errors, it needs to be marked as such using
+     *    `queuedRequest.done()`.
+     *  - When an upload is started or resumed, it needs to go through the `this.requests` queue. The `queuedRequest` variable
+     *    must be updated so the other uses of it are valid.
+     *  - Before replacing the `queuedRequest` variable, the previous `queuedRequest` must be aborted, else it will keep taking
+     *    up a spot in the queue.
+     *
+     * @param {FilerobotFile} file for use with upload
+     * @returns {Promise<void>}
+     */
+    function upload(file, uploadId) {
+      var _this2 = this;
+      this.resetFilerobotReferences(file.id);
+
+      // Create a new tus upload
+      return new Promise(function (resolve, reject) {
+        var queuedRequest;
+        var startUploadRequest;
+        var upload = {};
+        _this2.filerobot.emit('upload-started', file, {
+          uploadId: uploadId
+        });
+        var opts = _objectSpread(_objectSpread({}, _this2.opts), file.tus || {});
+        if (typeof opts.headers === 'function') {
+          opts.headers = opts.headers(file);
+        }
+
+        /** @type {RawTusOptions} */
+        var uploadOptions = _objectSpread(_objectSpread({}, tusDefaultOptions), opts);
+
+        // We override tus fingerprint to filerobot’s `file.id`, since the `file.id`
+        // now also includes `relativePath` for files added from folders.
+        // This means you can add 2 identical files, if one is in folder a,
+        // the other in folder b.
+        uploadOptions.fingerprint = getFingerprint(file);
+        uploadOptions.onBeforeRequest = function (req) {
+          var xhr = req.getUnderlyingObject();
+          xhr.withCredentials = !!opts.withCredentials;
+          var userProvidedPromise;
+          if (typeof opts.onBeforeRequest === 'function') {
+            userProvidedPromise = opts.onBeforeRequest(req, file);
+          }
+          if (hasProperty(queuedRequest, 'shouldBeRequeued')) {
+            if (!queuedRequest.shouldBeRequeued) return Promise.reject(new Error('Nonexistent upload'));
+            var done;
+            var newPromise = new Promise(function (resolve) {
+              done = resolve;
+            });
+            queuedRequest = _this2.requests.run(function () {
+              if (file.progress.status === PROGRESS_PANEL_STATUS.PAUSED) {
+                queuedRequest.abort();
+              }
+              done();
+              return function () {};
+            });
+            // If the request has been requeued because it was rate limited by the
+            // remote server, we want to wait for `RateLimitedQueue` to dispatch
+            // the re-try request.
+            // Therefore we create a promise that the queue will resolve when
+            // enough time has elapsed to expect not to be rate-limited again.
+            // This means we can hold the Tus retry here with a `Promise.all`,
+            // together with the returned value of the user provided
+            // `onBeforeRequest` option callback (in case it returns a promise).
+            return Promise.all([newPromise, userProvidedPromise]);
+          }
+          return userProvidedPromise;
+        };
+        uploadOptions.onError = function (error) {
+          var _queuedRequest;
+          _this2.filerobot.log(error);
+          var xhr = error.originalRequest ? error.originalRequest.getUnderlyingObject() : null;
+          if (isNetworkError(xhr)) {
+            var networkError = new NetworkError(error, xhr);
+            return networkError;
+          }
+          _this2.resetFilerobotReferences(file.id);
+          (_queuedRequest = queuedRequest) === null || _queuedRequest === void 0 ? void 0 : _queuedRequest.abort();
+          _this2.filerobot.emit('upload-error', file, error, {
+            uploadId: uploadId
+          });
+          reject(error);
+        };
+        uploadOptions.onProgress = function (bytesFinished, bytesTotal) {
+          _this2.onReceiveUploadUrl(file, uploadId, upload.url);
+          _this2.filerobot.emit('upload-progress', file, {
+            filerobot: _this2,
+            bytesFinished: bytesFinished,
+            bytesTotal: bytesTotal,
+            uploadId: uploadId
+          });
+        };
+        uploadOptions.onSuccess = function () {
+          if (!file.fileJson) {
+            _this2.getFileJson({
+              uploadUrl: upload.url,
+              file: file,
+              uploadId: uploadId,
+              queuedRequest: queuedRequest,
+              resolve: resolve,
+              reject: reject
+            });
+          }
+        };
+        var defaultOnShouldRetry = function defaultOnShouldRetry(err) {
+          var _err$originalResponse;
+          var status = err === null || err === void 0 ? void 0 : (_err$originalResponse = err.originalResponse) === null || _err$originalResponse === void 0 ? void 0 : _err$originalResponse.getStatus();
+          if (status === 429) {
+            // HTTP 429 Too Many Requests => to avoid the whole download to fail, pause all requests.
+            if (!_this2.requests.isPaused) {
+              var _this2$retryDelayIter;
+              var next = (_this2$retryDelayIter = _this2.retryDelayIterator) === null || _this2$retryDelayIter === void 0 ? void 0 : _this2$retryDelayIter.next();
+              if (next == null || next.done) {
+                return false;
+              }
+              _this2.requests.rateLimit(next.value);
+            }
+          } else if (status > 400 && status < 500 && status !== 409) {
+            // HTTP 4xx, the server won't send anything, it's doesn't make sense to retry
+            return false;
+          } else if (typeof navigator !== 'undefined' && navigator.onLine === false) {
+            // The navigator is offline, let's wait for it to come back online.
+            if (!_this2.requests.isPaused) {
+              _this2.requests.pause();
+              window.addEventListener('online', function () {
+                _this2.requests.resume();
+              }, {
+                once: true
+              });
+            }
+          }
+          queuedRequest.abort();
+          queuedRequest = {
+            shouldBeRequeued: true,
+            abort: function abort() {
+              this.shouldBeRequeued = false;
+            },
+            done: function done() {
+              throw new Error('Cannot mark a queued request as done: this indicates a bug');
+            },
+            fn: function fn() {
+              throw new Error('Cannot run a queued request: this indicates a bug');
+            }
+          };
+          return true;
+        };
+        if (opts.onShouldRetry != null) {
+          uploadOptions.onShouldRetry = function () {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            return opts.onShouldRetry.apply(opts, args.concat([defaultOnShouldRetry]));
+          };
+        } else {
+          uploadOptions.onShouldRetry = defaultOnShouldRetry;
+        }
+        var copyProp = function copyProp(obj, srcProp, destProp) {
+          if (hasProperty(obj, srcProp) && !hasProperty(obj, destProp)) {
+            obj[destProp] = obj[srcProp];
+          }
+        };
+
+        /** @type {Record<string, string>} */
+        var meta = {};
+        var allowedMetaFields = Array.isArray(opts.allowedMetaFields) ? opts.allowedMetaFields
+        // Send along all fields by default.
+        : Object.keys(file.meta);
+        allowedMetaFields.forEach(function (item) {
+          meta[item] = file.meta[item];
+        });
+        // tusd uses metadata fields 'filetype' and 'filename'
+        copyProp(meta, 'type', 'filetype');
+        copyProp(meta, 'name', 'filename');
+        uploadOptions.metadata = _objectSpread(_objectSpread({}, file.info), {}, {
+          'filerobot-folder': _this2.filerobot.getRemoteUploadFolder({
+            file: file,
+            opts: _this2.opts
+          })
+        });
+        upload = new Upload(file.data, uploadOptions);
+        _this2.filerobots[file.id] = upload;
+        _this2.filerobotEvents[file.id] = new EventTracker(_this2.filerobot);
+        // eslint-disable-next-line prefer-const
+        startUploadRequest = function startUploadRequest() {
+          if (file.progress.status !== PROGRESS_PANEL_STATUS.PAUSED) {
+            upload.start();
+          }
+          // Don't do anything here, the caller will take care of cancelling the upload itself
+          // using resetFilerobotReferences(). This is because resetFilerobotReferences() has to be
+          // called when this request is still in the queue, and has not been started yet, too. At
+          // that point this cancellation function is not going to be called.
+          // Also, we need to remove the request from the queue _without_ destroying everything
+          // related to this upload to handle pauses.
+          return function () {};
+        };
+        upload.findPreviousUploads().then(function (previousUploads) {
+          var previousUpload = previousUploads[0];
+          if (previousUpload) {
+            _this2.filerobot.log("[Tus] Resuming upload of ".concat(file.id, " started at ").concat(previousUpload.creationTime));
+            upload.resumeFromPreviousUpload(previousUpload);
+          }
+        });
+        queuedRequest = _this2.requests.run(startUploadRequest);
+        _this2.onFileRemove(file.id, function (targetFileID) {
+          queuedRequest.abort();
+          _this2.resetFilerobotReferences(file.id, {
+            abort: !!upload.url
+          });
+          resolve("upload ".concat(targetFileID, " was removed"));
+        });
+        _this2.onPause(file.id, function (isPaused) {
+          queuedRequest.abort();
+          if (isPaused) {
+            // Remove this file from the queue so another file can start in its place.
+            upload.abort();
+          } else {
+            // Resuming an upload should be queued, else you could pause and then
+            // resume a queued upload to make it skip the queue.
+            queuedRequest = _this2.requests.run(startUploadRequest);
+          }
+        });
+        _this2.onPauseAll(file.id, function () {
+          queuedRequest.abort();
+          upload.abort();
+        });
+        _this2.onCancelAll(file.id, function () {
+          var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+            reason = _ref3.reason;
+          if (reason === 'user') {
+            queuedRequest.abort();
+            _this2.resetFilerobotReferences(file.id, {
+              abort: !!upload.url
+            });
+          }
+          resolve("upload ".concat(file.id, " was canceled"));
+        });
+        _this2.onResumeAll(file.id, function () {
+          queuedRequest.abort();
+          if (file.error) {
+            upload.abort();
+          }
+          queuedRequest = _this2.requests.run(startUploadRequest);
+        });
+      })["catch"](function (error) {
+        _this2.filerobot.emit('upload-error', file, error, {
+          uploadId: uploadId
+        });
+        throw error;
+      });
+    }
+  }, {
+    key: "uploadRemote",
+    value:
+    // NOTE! Keep this duplicated code in sync with other plugins
+    // TODO we should probably abstract this into a common function
+    /**
+     * @param {FilerobotFile} file for use with upload
+     * @returns {Promise<void>}
+     */
+    async function uploadRemote(file, uploadId) {
+      this.resetFilerobotReferences(file.id);
+
+      // Don't double-emit upload-started for Golden Retriever-restored files that were already started
+      if (!file.progress.uploadStarted || !file.isRestored) {
+        this.filerobot.emit('upload-started', file, {
+          uploadId: uploadId
+        });
+      }
+      try {
+        if (file.serverToken) {
+          return await this.connectToServerSocket(file, uploadId);
+        }
+        var serverToken = await this.queueRequestSocketToken(file);
+        this.filerobot.setFileUploadingState(file.id, uploadId, {
+          serverToken: serverToken
+        });
+        return await this.connectToServerSocket(this.filerobot.getFileUploading(file.id), uploadId);
+      } catch (error) {
+        this.filerobot.setFileUploadingState(file.id, uploadId, {
+          serverToken: undefined
+        });
+        this.filerobot.emit('upload-error', file, error, {
+          uploadId: uploadId
+        });
+        throw error;
+      }
+    }
+
+    /**
+     * See the comment on the upload() method.
+     *
+     * Additionally, when an upload is removed, completed, or cancelled, we need to close the WebSocket connection. This is
+     * handled by the resetFilerobotReferences() function, so the same guidelines apply as in upload().
+     *
+     * @param {FilerobotFile} file
+     */
+  }, {
+    key: "connectToServerSocket",
+    value: async function connectToServerSocket(file, uploadId) {
+      var _this3 = this;
+      return new Promise(function (resolve, reject) {
+        var token = file.serverToken;
+        var host = getSocketHost(file.remote.companionUrl);
+        var socket = new Socket({
+          target: "".concat(host, "/api/").concat(token),
+          autoOpen: false
+        });
+        _this3.filerobotSockets[file.id] = socket;
+        _this3.filerobotEvents[file.id] = new EventTracker(_this3.filerobot);
+        var queuedRequest;
+        _this3.onFileRemove(file.id, function () {
+          queuedRequest.abort();
+          socket.send('cancel', {});
+          _this3.resetFilerobotReferences(file.id);
+          resolve("upload ".concat(file.id, " was removed"));
+        });
+        _this3.onPause(file.id, function (isPaused) {
+          if (isPaused) {
+            // Remove this file from the queue so another file can start in its place.
+            socket.send('pause', {});
+            queuedRequest.abort();
+          } else {
+            // Resuming an upload should be queued, else you could pause and then
+            // resume a queued upload to make it skip the queue.
+            queuedRequest.abort();
+            queuedRequest = _this3.requests.run(function () {
+              socket.open();
+              socket.send('resume', {});
+              return function () {};
+            });
+          }
+        });
+        _this3.onPauseAll(file.id, function () {
+          socket.send('pause', {});
+          queuedRequest.abort();
+        });
+        _this3.onCancelAll(file.id, function () {
+          var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+            reason = _ref4.reason;
+          if (reason === 'user') {
+            queuedRequest.abort();
+            socket.send('cancel', {});
+            _this3.resetFilerobotReferences(file.id);
+          }
+          resolve("upload ".concat(file.id, " was canceled"));
+        });
+        _this3.onResumeAll(file.id, function () {
+          queuedRequest.abort();
+          if (file.error) {
+            socket.send('pause', {});
+          }
+          queuedRequest = _this3.requests.run(function () {
+            socket.open();
+            socket.send('resume', {});
+            return function () {};
+          });
+        });
+        _this3.onRetry(file.id, function () {
+          // Only do the retry if the upload is actually in progress;
+          // else we could try to send these messages when the upload is still queued.
+          // We may need a better check for this since the socket may also be closed
+          // for other reasons, like network failures.
+          if (socket.isOpen) {
+            socket.send('pause', {});
+            socket.send('resume', {});
+          }
+        });
+        _this3.onRetryAll(file.id, function () {
+          // See the comment in the onRetry() call
+          if (socket.isOpen) {
+            socket.send('pause', {});
+            socket.send('resume', {});
+          }
+        });
+        socket.on('progress', function (progressData) {
+          return emitSocketProgress(_this3, progressData, file);
+        });
+        socket.on('error', function (errData) {
+          var message = errData.error.message;
+          var error = _extends(new Error(message), {
+            cause: errData.error
+          });
+
+          // If the remote retry optimisation should not be used,
+          // close the socket—this will tell companion to clear state and delete the file.
+          if (!_this3.opts.useFastRemoteRetry) {
+            _this3.resetFilerobotReferences(file.id);
+            // Remove the serverToken so that a new one will be created for the retry.
+            _this3.filerobot.setFileUploadingState(file.id, uploadId, {
+              serverToken: null
+            });
+          } else {
+            socket.close();
+          }
+          _this3.filerobot.emit('upload-error', file, error, {
+            uploadId: uploadId
+          });
+          queuedRequest.done();
+          reject(error);
+        });
+        socket.on('success', function (data) {
+          if (!file.fileJson) {
+            _this3.getFileJson({
+              uploadUrl: data.url,
+              file: file,
+              uploadId: uploadId,
+              queuedRequest: queuedRequest,
+              resolve: resolve
+            });
+          }
+        });
+        queuedRequest = _this3.requests.run(function () {
+          if (file.progress.status === PROGRESS_PANEL_STATUS.PAUSED) {
+            socket.send('pause', {});
+          } else {
+            socket.open();
+          }
+
+          // Just close the socket here, the caller will take care of cancelling the upload itself
+          // using resetFilerobotReferences(). This is because resetFilerobotReferences() has to be
+          // called when this request is still in the queue, and has not been started yet, too. At
+          // that point this cancellation function is not going to be called.
+          // Also, we need to remove the request from the queue _without_ destroying everything
+          // related to this upload to handle pauses.
+          return function () {};
+        });
+      });
+    }
+
+    /**
+     * Store the uploadUrl on the file options, so that when Golden Retriever
+     * restores state, we will continue uploading to the correct URL.
+     *
+     * @param {FilerobotFile} file
+     * @param {string} uploadURL
+     */
+  }, {
+    key: "onReceiveUploadUrl",
+    value: function onReceiveUploadUrl(file, uploadId, uploadURL) {
+      var currentFile = this.filerobot.getFileUploading(file.id);
+      if (!currentFile) return;
+      // Only do the update if we didn't have an upload URL yet.
+      if (!currentFile.tus || currentFile.tus.uploadUrl !== uploadURL) {
+        this.filerobot.log('[Tus] Storing upload url');
+        this.filerobot.setFileUploadingState(currentFile.id, uploadId, {
+          tus: _objectSpread(_objectSpread({}, currentFile.tus), {}, {
+            uploadUrl: uploadURL
+          })
+        });
+      }
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(string): void} cb
+     */
+  }, {
+    key: "onFileRemove",
+    value: function onFileRemove(fileId, cb) {
+      this.filerobotEvents[fileId].on('file-removed', function (file) {
+        if (fileId === file.id) cb(file.id);
+      });
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(boolean): void} cb
+     */
+  }, {
+    key: "onPause",
+    value: function onPause(fileId, cb) {
+      this.filerobotEvents[fileId].on('upload-pause', function (targetFileID, isPaused) {
+        if (fileId === targetFileID) {
+          cb(isPaused);
+        }
+      });
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(): void} cb
+     */
+  }, {
+    key: "onRetry",
+    value: function onRetry(fileId, cb) {
+      this.filerobotEvents[fileId].on('upload-retry', function (targetFileID) {
+        if (fileId === targetFileID) {
+          cb();
+        }
+      });
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(): void} cb
+     */
+  }, {
+    key: "onRetryAll",
+    value: function onRetryAll(fileId, cb) {
+      var _this4 = this;
+      this.filerobotEvents[fileId].on('retry-all', function () {
+        if (!_this4.filerobot.getFileUploading(fileId)) return;
+        cb();
+      });
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(): void} cb
+     */
+  }, {
+    key: "onPauseAll",
+    value: function onPauseAll(fileId, cb) {
+      var _this5 = this;
+      this.filerobotEvents[fileId].on('pause-all', function () {
+        if (!_this5.filerobot.getFileUploading(fileId)) return;
+        cb();
+      });
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(): void} cb
+     */
+  }, {
+    key: "onCancelAll",
+    value: function onCancelAll(fileId, eventHandler) {
+      var _this6 = this;
+      this.filerobotEvents[fileId].on('cancel-uploads', function () {
+        if (!_this6.filerobot.getFileUploading(fileId)) return;
+        eventHandler.apply(void 0, arguments);
+      });
+    }
+
+    /**
+     * @param {string} fileId
+     * @param {function(): void} cb
+     */
+  }, {
+    key: "onResumeAll",
+    value: function onResumeAll(fileId, cb) {
+      var _this7 = this;
+      this.filerobotEvents[fileId].on('resume-all', function () {
+        if (!_this7.filerobot.getFileUploading(fileId)) return;
+        cb();
+      });
+    }
+
+    /**
+     * @param {(FilerobotFile | FailedFilerobotFile)[]} files
+     */
+  }, {
+    key: "uploadFiles",
+    value: function uploadFiles(files, uploadId) {
+      var _this8 = this;
+      var promises = files.map(function (file, i) {
+        if ('error' in file && file.error) {
+          return Promise.reject(new Error(file.error));
+        }
+        if (file.isRemote) {
+          // We emit upload-started here, so that it's also emitted for files
+          // that have to wait due to the `limit` option.
+          // Don't double-emit upload-started for Golden Retriever-restored files that were already started
+          if (!file.progress.uploadStarted || !file.isRestored) {
+            _this8.filerobot.emit('upload-started', file, {
+              uploadId: uploadId
+            });
+          }
+          return _this8.uploadRemote(file, uploadId);
+        }
+        // Don't double-emit upload-started for Golden Retriever-restored files that were already started
+        if (!file.progress.uploadStarted || !file.isRestored) {
+          _this8.filerobot.emit('upload-started', file, {
+            uploadId: uploadId
+          });
+        }
+        return _this8.upload(file, uploadId);
+      });
+      return settle(promises);
+    }
+
+    /**
+     * @param {string[]} fileIds
+     */
+  }, {
+    key: "handleUpload",
+    value: function handleUpload(fileIds, uploadId) {
+      var _this9 = this;
+      if (fileIds.length === 0) {
+        this.filerobot.log('[Tus] No files to upload');
+        return Promise.resolve();
+      }
+      if (this.opts.limit === 0) {
+        this.filerobot.log('[Tus] 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: https://filerobot.io/docs/tus/#limit-0', 'warning');
+      }
+      this.filerobot.log('[Tus] Uploading...');
+      var filesToUpload = fileIds.map(function (fileId) {
+        return _this9.filerobot.getFileUploading(fileId);
+      });
+      return this.uploadFiles(filesToUpload, uploadId).then(function () {
+        return null;
+      });
+    }
+  }, {
+    key: "install",
+    value: function install() {
+      this.filerobot.dispatch(uploadCapabilitiesUpdated({
+        allowResumableUploads: true
+      }));
+      this.filerobot.addFilerobot(this.handleUpload);
+      this.filerobot.on('reset-progress', this.handleResetProgress);
+    }
+  }, {
+    key: "uninstall",
+    value: function uninstall() {
+      this.filerobot.dispatch(uploadCapabilitiesUpdated({
+        allowResumableUploads: false
+      }));
+      this.filerobot.removeFilerobot(this.handleUpload);
+    }
+  }]);
+}(Plugin);
+export { Tus as default };