@scaleflex/widget-core 0.0.1

package/lib/index.js

@@ -0,0 +1,1918 @@
+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 _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function 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 _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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+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 _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 _wrapNativeSuper(t) { var r = "function" == typeof Map ? new Map() : void 0; return _wrapNativeSuper = function _wrapNativeSuper(t) { if (null === t || !_isNativeFunction(t)) return t; if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== r) { if (r.has(t)) return r.get(t); r.set(t, Wrapper); } function Wrapper() { return _construct(t, arguments, _getPrototypeOf(this).constructor); } return Wrapper.prototype = Object.create(t.prototype, { constructor: { value: Wrapper, enumerable: !1, writable: !0, configurable: !0 } }), _setPrototypeOf(Wrapper, t); }, _wrapNativeSuper(t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).indexOf("[native code]"); } catch (n) { return "function" == typeof t; } }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+import React from 'react';
+import ReactDOM from 'react-dom';
+import ee from 'namespace-emitter';
+import cuid from 'cuid';
+import prettierBytes from '@transloadit/prettier-bytes';
+import match from 'mime-match';
+import getFileType from '@scaleflex/widget-utils/lib/getFileType';
+import Translator from '@scaleflex/widget-utils/lib/Translator';
+import getFileNameAndExtension from '@scaleflex/widget-utils/lib/getFileNameAndExtension';
+import generateFileId from '@scaleflex/widget-utils/lib/generateFileId';
+import checkConnection from '@scaleflex/widget-utils/lib/checkConnection';
+import handlePromise from '@scaleflex/widget-utils/lib/handlePromise';
+import { PERMISSIONS, RESTRICTED_FILES_EXTENISONS, PLUGINS_IDS, FILE_UPLOAD_STATUS, PROGRESS_PANEL_ACTIVITY, ABORTED_ERROR } from '@scaleflex/widget-utils/lib/constants';
+import { getBackendTranslations } from '@scaleflex/widget-utils/lib/i18n.client';
+import extractFileDataNoBlob from '@scaleflex/widget-utils/lib/extractFileDataNoBlob';
+import getFileExtension from '@scaleflex/widget-utils/lib/getFileExtension';
+import convertBytesToMb from '@scaleflex/widget-utils/lib/convertBytesToMb';
+import { justErrorsLogger, debugLogger } from './loggers';
+import Plugin from './Plugin'; // Exported from here.
+import defaultLocale from './defaultLocale';
+import createStore from './createStore';
+import { uploadUpdated, selectUploadById, selectUploads, selectUploadsArray, selectUploadCapabilities, uploadCapabilitiesUpdated, updateUploadInfoMetaTags, uploadsAdded, uploadsRemoved, allUploadsCancelled, allUploadsRemoved } from './slices/uploads.slice';
+import { fetchUserAuthState, generateUserKey as _generateUserKey, saveUserSassKey, selectUserPermissions, selectUserSassKey, selectUserSecurityData, userInfoUpdated } from './slices/user.slice';
+import { infoHid, infoSet } from './slices/info.slice';
+import { coreCommonStateUpdated, selectCommonState, selectCoreLoading, selectCurrentFolderPath } from './slices/common.slice';
+import Client from './Client';
+import SassKeyRenewer from './SassKeyRenewer';
+
+// 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'
+
+// HACK until this issue fixed -- https://scaleflexhq.atlassian.net/browse/FRA-1673
+window.React = React;
+window.ReactDOM = ReactDOM;
+var RestrictionError = /*#__PURE__*/function (_Error) {
+  function RestrictionError() {
+    var _this;
+    _classCallCheck(this, RestrictionError);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, RestrictionError, [].concat(args));
+    _this.isRestriction = true;
+    return _this;
+  }
+  _inherits(RestrictionError, _Error);
+  return _createClass(RestrictionError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * filerobot Core module.
+ * Manages plugins, state updates, acts as an event bus,
+ * adds/removes files and metadata.
+ */
+var Filerobot = /*#__PURE__*/function () {
+  /**
+   * Instantiate filerobot
+   *
+   * @param {object} opts — filerobot options
+   */
+  function Filerobot(opts) {
+    var _this2 = this;
+    _classCallCheck(this, Filerobot);
+    _defineProperty(this, "loadBackendTranslations", function () {
+      if (!_this2.backendTranslations) {
+        handlePromise(getBackendTranslations({
+          i18nFetchApiEndpoint: _this2.opts.i18nFetchApiEndpoint
+        }), function (translations) {
+          var _this2$currLngBackend;
+          if (!((_this2$currLngBackend = _this2.currLngBackendTranslations) !== null && _this2$currLngBackend !== void 0 && _this2$currLngBackend.strings)) {
+            _this2.currLngBackendTranslations = {
+              strings: {}
+            };
+          }
+          _this2.backendTranslations = translations;
+          _this2.updateCurrLngBackendTranslations();
+        }, function () {
+          var _this2$currLngBackend2;
+          if (!((_this2$currLngBackend2 = _this2.currLngBackendTranslations) !== null && _this2$currLngBackend2 !== void 0 && _this2$currLngBackend2.strings)) {
+            _this2.currLngBackendTranslations = {
+              strings: {}
+            };
+          }
+          _this2.updateCurrLngBackendTranslations();
+          _this2.info.apply(_this2, arguments);
+        });
+      }
+    });
+    _defineProperty(this, "updateCurrLngBackendTranslations", function () {
+      var _ref = _this2.opts || {},
+        language = _ref.language;
+      if (!language) return;
+      var currentLanguage = language.toLowerCase();
+      Translator.LANGUAGE = currentLanguage;
+      var backendTranslations = _this2.backendTranslations || [];
+      backendTranslations.forEach(function (translation) {
+        _this2.currLngBackendTranslations.strings[translation.translation_key] = translation.translations[currentLanguage];
+      });
+      _this2.i18nInit();
+      _this2.updateAllPluginsI18n();
+      _this2.refreshPluginsOptions();
+    });
+    _defineProperty(this, "updateAllPluginsI18n", function () {
+      _this2.iteratePlugins(function (plugin) {
+        if (typeof plugin.i18nInit === 'function') {
+          plugin.i18nInit();
+        }
+      });
+    });
+    _defineProperty(this, "_getInstalledPkgs", function () {
+      // We are always returning a new reference from plugins object, incase of using memoized value for the reference of the object
+      // So that we guarantee a rerender in all cases whether memoized or not.
+      return {
+        filerobot: _this2,
+        plugins: _objectSpread({}, _this2.plugins)
+      };
+    });
+    _defineProperty(this, "refreshPluginsOptions", function () {
+      _this2.emit('opts-updated', _this2._getInstalledPkgs());
+    });
+    // TODO: [Relevance] remove show/hide relevance when BE is done
+    _defineProperty(this, "showRelevance", function () {
+      _this2.setCoreCommonState({
+        isRelevanceAvailable: true
+      });
+      localStorage.setItem('show-relevance', 'true');
+      return 'Relevance activated, search by something to view relevance badge';
+    });
+    _defineProperty(this, "hideRelevance", function () {
+      _this2.setCoreCommonState({
+        isRelevanceAvailable: false
+      });
+      localStorage.removeItem('show-relevance');
+      return 'Relevance deactivated, search by something to hide relevance badge';
+    });
+    _defineProperty(this, "enableSearchDebugging", function () {
+      localStorage.setItem('debug_search', true);
+      return 'Search debugging enabled, hover on any asset to show debug info';
+    });
+    _defineProperty(this, "disableSearchDebugging", function () {
+      localStorage.setItem('debug_search', false);
+      return 'Search debugging disabled';
+    });
+    this.defaultLocale = {
+      strings: defaultLocale
+    };
+    this.timeoutNoPermissionsInfoId = null;
+    var defaultOptions = {
+      id: 'scaleflexWidget',
+      autoProceed: false,
+      allowMultipleUploads: true,
+      debug: false,
+      restrictions: {
+        maxFileSize: null,
+        maxTotalFilesSize: null,
+        totalUploadedFilesSize: null,
+        maxNumberOfFiles: null,
+        minNumberOfFiles: null,
+        allowedFileTypes: null,
+        maxItemsSizeForCompression: null,
+        hideRestrictionsInformer: false
+      },
+      onBeforeFileAdded: function onBeforeFileAdded(currentFile, files) {
+        return currentFile;
+      },
+      onBeforeUpload: function onBeforeUpload(files) {
+        return files;
+      },
+      logger: justErrorsLogger,
+      dev: false,
+      container: undefined,
+      securityTemplateId: undefined,
+      akamaiMode: false,
+      userPermissions: [],
+      userFoldersScope: [],
+      apiEndpoint: '',
+      skipApiEndpointToken: false,
+      apiEndpointVersion: 'v5',
+      adminApiEndpoint: '',
+      i18nFetchApiEndpoint: 'https://i18n-fastly.ultrafast.io/api',
+      shareApiEndpoint: '',
+      videoApiEndpoint: '',
+      language: 'en',
+      theme: {
+        breakpoints: {
+          values: {
+            xs: 0,
+            sm: 576,
+            md: 768,
+            lg: 1084,
+            xl: 1342,
+            xxl: 1600,
+            xxxl: 1920
+          }
+        }
+      },
+      userInfo: {
+        email: '',
+        name: '',
+        photo_uri: '',
+        uuid: ''
+      },
+      sassKeyRenewerEnabled: true
+    };
+
+    // Merge default options with the ones set by user,
+    // making sure to merge restrictions too
+    this.opts = _objectSpread(_objectSpread(_objectSpread({}, defaultOptions), opts), {}, {
+      securityTemplateId: opts.securityTemplateId || opts.securityTemplateID || defaultOptions.securityTemplateId,
+      // Old config name alias securityTemplateID->securityTemplateId. DEPRECATE SOON!
+      restrictions: _objectSpread(_objectSpread({}, defaultOptions.restrictions), opts && opts.restrictions),
+      userInfo: _objectSpread(_objectSpread({}, defaultOptions.userInfo), (opts === null || opts === void 0 ? void 0 : opts.userInfo) || {})
+    });
+    this.opts.apiEndpoint = (this.opts.apiEndpoint || '').trim().replace(/\/$/, '');
+    this.opts.adminApiEndpoint = (this.opts.adminApiEndpoint || '').trim().replace(/\/$/, '');
+    this.opts.shareApiEndpoint = (this.opts.shareApiEndpoint || '').trim().replace(/\/$/, '');
+    this.opts.videoApiEndpoint = (this.opts.videoApiEndpoint || '').trim().replace(/\/$/, '');
+    this.opts.i18nFetchApiEndpoint = (this.opts.i18nFetchApiEndpoint || '').trim().replace(/\/$/, '');
+    if (!this.opts.apiEndpoint) {
+      this.opts.apiEndpoint = this.opts.dev ? 'https://api-dev.filerobot.com' : 'https://api.filerobot.com';
+    }
+    if (!this.opts.adminApiEndpoint) {
+      this.opts.adminApiEndpoint = this.opts.dev ? 'https://hub-dev.filerobot.com/api' : 'https://hub.filerobot.com/api';
+    }
+    if (!this.opts.shareApiEndpoint) {
+      this.opts.shareApiEndpoint = this.opts.dev ? 'https://share-dev.filerobot.com' : 'https://share.filerobot.com';
+    }
+    if (!this.opts.videoApiEndpoint) {
+      this.opts.videoApiEndpoint = 'https://api.filerobot.com/videos/v2';
+    }
+
+    // Separate option for easier usage as it respects skipApiEndpointToken (no need to check in each use case)
+    this.opts.apiEndpointWithContainer = "".concat(this.opts.apiEndpoint).concat(!this.opts.skipApiEndpointToken && this.opts.container ? "/".concat(this.opts.container) : '');
+
+    // opts instead of this.opts to avoid comparing objects — we set logger: justErrorsLogger in defaultOptions
+    if (opts && opts.logger && opts.debug) {
+      this.log('You are using a custom `logger`, but also set `debug: true`, which uses built-in logger to output logs to console. Ignoring `debug: true` and using your custom `logger`.', 'warning');
+    } else if (opts && opts.debug) {
+      this.opts.logger = debugLogger;
+    }
+    if (!opts.container) {
+      throw new Error('`container` is required for having the widget works properly.');
+    }
+    if (this.log) {
+      this.log("Using Core v".concat(this.constructor.VERSION));
+    }
+    if (this.opts.restrictions.allowedFileTypes && this.opts.restrictions.allowedFileTypes !== null && !Array.isArray(this.opts.restrictions.allowedFileTypes)) {
+      throw new TypeError('`restrictions.allowedFileTypes` must be an array');
+    }
+
+    /**
+     * saveMissing translations is temporary disabled. Until we find a good solution how to improve automation.
+     * Previous approach doesn't work thus we switched to manual translations adding to Wordplex directly by developers.
+     */
+    // Translator.IS_DEV = this.opts.dev
+
+    this.i18nInit();
+
+    // Container for different types of plugins
+    this.plugins = {};
+    /*
+    * Container for the current uploads operations
+    * (not files but the upload process/operation itself that can contain multiple files)
+    * made as a property in the class as it doesn't need to cause a render or accessed externally.
+    */
+    this.uploadOperations = {};
+    this.getGlobalState = this.getGlobalState.bind(this);
+    this.getPlugin = this.getPlugin.bind(this);
+    this.removePlugin = this.removePlugin.bind(this);
+    this.getPreProcessors = this.getPreProcessors.bind(this);
+    this.getPostProcessors = this.getPostProcessors.bind(this);
+    this.setFilesInfoMetaTags = this.setFilesInfoMetaTags.bind(this);
+    this.showRelevance = this.showRelevance.bind(this);
+    this.hideRelevance = this.hideRelevance.bind(this);
+    this.setFileStateBeforeUpload = this.setFileStateBeforeUpload.bind(this);
+    this.getFileUploading = this.getFileUploading.bind(this);
+    this.setFileUploadingState = this.setFileUploadingState.bind(this);
+    this.setUploadPanelFileState = this.setUploadPanelFileState.bind(this);
+    this.setFileState = this.setFileState.bind(this);
+    this.setProgressPanelFileState = this.setProgressPanelFileState.bind(this);
+    this.log = this.log.bind(this);
+    this.use = this.use.bind(this);
+    this.info = this.info.bind(this);
+    this.hideInfo = this.hideInfo.bind(this);
+    this.addFile = this.addFile.bind(this);
+    this.removeFile = this.removeFile.bind(this);
+    this.removeUploads = this.removeUploads.bind(this);
+    this.pauseResume = this.pauseResume.bind(this);
+    this.checkUserPermissions = this.checkUserPermissions.bind(this);
+    this.generateUserKey = this.generateUserKey.bind(this);
+    this.checkPluginTypeExistence = this.checkPluginTypeExistence.bind(this);
+    this.initUserAuthState = this.initUserAuthState.bind(this);
+    this.enableSearchDebugging = this.enableSearchDebugging.bind(this);
+    this.disableSearchDebugging = this.disableSearchDebugging.bind(this);
+    this.isFileRestrictedToGetAdded = this.isFileRestrictedToGetAdded.bind(this);
+    window.enableSearchDebugging = this.enableSearchDebugging;
+    window.disableSearchDebugging = this.disableSearchDebugging;
+    this.updateOnlineStatus = this.updateOnlineStatus.bind(this);
+    this.cancelUploads = this.cancelUploads.bind(this);
+    this.retryUpload = this.retryUpload.bind(this);
+    this.upload = this.upload.bind(this);
+    this.pauseAll = this.pauseAll.bind(this);
+    this.resumeAll = this.resumeAll.bind(this);
+    this.retryAll = this.retryAll.bind(this);
+    this.cancelAll = this.cancelAll.bind(this);
+    this.emitter = ee();
+    this.on = this.on.bind(this);
+    this.off = this.off.bind(this);
+    this.once = this.emitter.once.bind(this.emitter);
+    this.emit = this.emitter.emit.bind(this.emitter);
+
+    // { process: processingFn, render: renderingFn }
+    this.preProcessors = [];
+    this.filerobots = [];
+    // { process: processingFn, render: renderingFn }
+    this.postProcessors = [];
+    this._storeInit();
+    this._storeUnsubscribe = this.store.subscribe(function () {});
+    if (this.opts.sassKeyRenewerEnabled) {
+      this._sassKeyRenewerUnsubscribe = this.sassKeyRenewer.subscribe();
+    }
+
+    // Exposing filerobot object on window for debugging and testing
+    if (this.opts.debug && typeof window !== 'undefined') {
+      window[this.opts.id] = this;
+    }
+    this.loadBackendTranslations();
+    this._addListeners();
+    if (!this.opts.sassKey) {
+      if (this.opts.securityTemplateId) {
+        this.generateUserKey();
+      } else {
+        if (this.opts.dev) {
+          console.warn('Core: `securityTemplateId` property is required if you don\'t want to use login (email&pass) mode. (this warning is shown in development mode only)');
+        }
+        this.initUserAuthState();
+      }
+    } else {
+      this.initUserAuthState(this.opts.sassKey);
+    }
+  }
+  return _createClass(Filerobot, [{
+    key: "on",
+    value: function on(event, callback) {
+      this.emitter.on(event, callback);
+      return this;
+    }
+  }, {
+    key: "off",
+    value: function off(event, callback) {
+      this.emitter.off(event, callback);
+      return this;
+    }
+  }, {
+    key: "initUserAuthState",
+    value: function initUserAuthState(sassKey) {
+      if (!sassKey) return this.setCoreCommonState({
+        loading: false
+      });
+      this.dispatch(userInfoUpdated(_objectSpread(_objectSpread({}, this.opts.userInfo), {}, {
+        sessionUuid: this.opts.sessionToken
+      })));
+      return this.dispatch(fetchUserAuthState({
+        userSassKey: sassKey
+      }));
+    }
+
+    /**
+     * Iterate on all plugins and run `update` on them.
+     * Called each time state changes.
+     *
+     */
+  }, {
+    key: "updateAll",
+    value: function updateAll(state) {
+      this.iteratePlugins(function (plugin) {
+        plugin.update(state);
+      });
+    }
+
+    /**
+     * creates & assigns the redux store
+     *
+    */
+  }, {
+    key: "_storeInit",
+    value: function _storeInit() {
+      var client = new Client(this, this.opts);
+      this.store = createStore(client, [], this);
+      this.setCoreCommonState({
+        isDevEnv: this.opts.dev
+      });
+      if (this.opts.sassKeyRenewerEnabled) {
+        this.sassKeyRenewer = new SassKeyRenewer(this, client);
+      }
+    }
+
+    /**
+     * injects a sub-reducer into the root reducer (mostly used for injecting a plugin's reducer)
+     *
+    */
+  }, {
+    key: "_injectReducer",
+    value: function _injectReducer(key, reducerFn) {
+      this.store.injectReducer(key, reducerFn);
+    }
+
+    /**
+     * injects a sub-reducer into the root reducer (mostly used for injecting a plugin's reducer)
+     *
+    */
+  }, {
+    key: "_removeReducer",
+    value: function _removeReducer(key) {
+      this.store.removeReducer(key);
+    }
+
+    /**
+     * Triggers the action to call store's reducers
+     * @param {Function} actionCreator
+     */
+  }, {
+    key: "dispatch",
+    value: function dispatch(actionCreator) {
+      return this.store.dispatch(actionCreator);
+    }
+
+    /**
+     * Updates common state with a patch
+     * any state that not organized in a sub-reducer/slice
+     *
+     * @param {object} patch {foo: 'bar'}
+    //  * TODO: To check it
+     */
+  }, {
+    key: "setCoreCommonState",
+    value: function setCoreCommonState(patch) {
+      this.dispatch(coreCommonStateUpdated(patch));
+    }
+
+    /**
+     * Returns current state of whole redux's store (global state).
+     *
+     * @returns {object}
+    */
+  }, {
+    key: "getGlobalState",
+    value: function getGlobalState() {
+      return this.store.getState();
+    }
+
+    /**
+     * Returns current core's slice state.
+     *
+     * @returns {object}
+     */
+  }, {
+    key: "getCoreState",
+    value: function getCoreState() {
+      return this.getGlobalState()[PLUGINS_IDS.CORE];
+    }
+
+    /**
+     * Returns current core's slice state.
+     *
+     * @returns {object}
+     */
+  }, {
+    key: "getCoreCommonState",
+    value: function getCoreCommonState() {
+      return selectCommonState(this.getGlobalState());
+    }
+
+    /**
+     * Returns current uploads
+     *
+     * @returns {object}
+     */
+  }, {
+    key: "getUploadOperations",
+    value: function getUploadOperations() {
+      return this.uploadOperations;
+    }
+
+    /**
+     * Returns current uploads' meta
+     *
+     * @returns {object}
+     */
+  }, {
+    key: "getUploadCapabilities",
+    value: function getUploadCapabilities() {
+      return selectUploadCapabilities(this.getGlobalState());
+    }
+
+    /**
+     * Returns the current files that will get uploaded
+     *
+     * @returns {object}
+     */
+  }, {
+    key: "getUploads",
+    value: function getUploads() {
+      var files = _objectSpread({}, selectUploads(this.getGlobalState()));
+      Object.keys(files).forEach(function (fileId) {
+        files[fileId] = _objectSpread(_objectSpread({}, files[fileId]), {}, {
+          data: Filerobot.uploadFilesData[fileId]
+        });
+      });
+      return files;
+    }
+
+    /**
+     * Returns the current files that will get uploaded in a type of array
+     *
+     * @returns {Array}
+     */
+  }, {
+    key: "getUploadsArray",
+    value: function getUploadsArray() {
+      return selectUploadsArray(this.getGlobalState());
+    }
+  }, {
+    key: "setUploadPanelFileState",
+    value: function setUploadPanelFileState() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated, please use setFileStateBeforeUpload instead');
+    }
+  }, {
+    key: "setFileState",
+    value: function setFileState() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated, please use setFileStateBeforeUpload instead');
+      this.setFileStateBeforeUpload.apply(this, arguments);
+    }
+
+    /**
+     * Shorthand to set state for a specific file.
+     */
+  }, {
+    key: "setFileStateBeforeUpload",
+    value: function setFileStateBeforeUpload(fileId, state) {
+      if (!this.getFileBeforeUpload(fileId)) {
+        if (this.opts.autoProceed) {
+          return;
+        }
+        throw new Error("Can\u2019t set state for ".concat(fileId, " (the file could have been removed)"));
+      }
+      var fileState = _objectSpread(_objectSpread({}, state), {}, {
+        id: fileId
+      });
+      if (state.data) {
+        Filerobot.uploadFilesData[fileId] = state.data;
+        fileState.data = extractFileDataNoBlob(state.data);
+      }
+      this.dispatch(uploadUpdated(_objectSpread(_objectSpread({}, fileState), {}, {
+        id: fileId
+      })));
+    }
+  }, {
+    key: "i18nInit",
+    value: function i18nInit() {
+      if (!Translator.BACKEND_TRANSLATIONS) {
+        var _this$currLngBackendT;
+        Translator.BACKEND_TRANSLATIONS = (_this$currLngBackendT = this.currLngBackendTranslations) === null || _this$currLngBackendT === void 0 ? void 0 : _this$currLngBackendT.strings;
+      }
+      this.translator = new Translator([this.defaultLocale, this.currLngBackendTranslations, this.opts.locale]);
+      this.locale = this.translator.locale;
+      this.i18n = this.translator.translate.bind(this.translator);
+      this.i18nArray = this.translator.translateArray.bind(this.translator);
+    }
+  }, {
+    key: "setOptions",
+    value: function setOptions() {
+      var newOpts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (typeof newOpts.sassKey !== 'undefined' && newOpts.sassKey !== this.opts.sassKey) {
+        var _explorerPlugin$opts;
+        var explorerPlugin = this.getPlugin(PLUGINS_IDS.EXPLORER);
+        if (!explorerPlugin || !((_explorerPlugin$opts = explorerPlugin.opts) !== null && _explorerPlugin$opts !== void 0 && _explorerPlugin$opts.ExploreViewComponent)) {
+          this.dispatch(saveUserSassKey(newOpts.sassKey));
+        } else {
+          this.initUserAuthState(newOpts.sassKey);
+        }
+      }
+      this.opts = _objectSpread(_objectSpread(_objectSpread({}, this.opts), newOpts), {}, {
+        restrictions: _objectSpread(_objectSpread({}, this.opts.restrictions), newOpts && newOpts.restrictions)
+      });
+      if (newOpts.locale) {
+        this.i18nInit();
+      }
+      if (newOpts.language) {
+        this.updateCurrLngBackendTranslations();
+      }
+      if (typeof newOpts.dev !== 'undefined') {
+        this.setCoreCommonState({
+          isDevEnv: this.opts.dev
+        });
+      }
+
+      // Already the opts object of the plugin is updated, so we need only to emit a new object's reference
+      // and handle rerendering in the plugins' providers so that it causes rerender.
+      this.emit('opts-updated', this._getInstalledPkgs());
+    }
+  }, {
+    key: "addPreProcessor",
+    value: function addPreProcessor(processor) {
+      this.preProcessors.push(processor);
+    }
+  }, {
+    key: "removePreProcessor",
+    value: function removePreProcessor(processor) {
+      var i = this.preProcessors.indexOf(processor);
+      if (i !== -1) {
+        this.preProcessors.splice(i, 1);
+      }
+    }
+  }, {
+    key: "addPostProcessor",
+    value: function addPostProcessor(processor) {
+      this.postProcessors.push(processor);
+    }
+  }, {
+    key: "removePostProcessor",
+    value: function removePostProcessor(processor) {
+      var i = this.postProcessors.indexOf(processor);
+      if (i !== -1) {
+        this.postProcessors.splice(i, 1);
+      }
+    }
+  }, {
+    key: "addFilerobot",
+    value: function addFilerobot(fn) {
+      this.filerobots.push(fn);
+    }
+  }, {
+    key: "removeFilerobot",
+    value: function removeFilerobot(fn) {
+      var i = this.filerobots.indexOf(fn);
+      if (i !== -1) {
+        this.filerobots.splice(i, 1);
+      }
+    }
+  }, {
+    key: "setFilesInfoMetaTags",
+    value: function setFilesInfoMetaTags(_ref2) {
+      var filesIds = _ref2.filesIds,
+        meta = _ref2.meta,
+        tags = _ref2.tags,
+        info = _ref2.info,
+        tagsForceUpdate = _ref2.tagsForceUpdate;
+      return this.dispatch(updateUploadInfoMetaTags({
+        filesIds: filesIds,
+        meta: meta,
+        tags: tags,
+        info: info,
+        tagsForceUpdate: tagsForceUpdate
+      }));
+    }
+
+    /**
+     * Get file uploading object.
+     *
+     * @param {string} fileId The ID of the file object to return.
+     */
+  }, {
+    key: "getFileUploading",
+    value: function getFileUploading(fileId) {
+      var uploadOperations = this.getUploadOperations();
+      var uploadOperationId = Object.keys(uploadOperations).find(function (uploadId) {
+        return uploadOperations[uploadId].files[fileId];
+      });
+      if (!uploadOperationId) {
+        return;
+      }
+      return _objectSpread(_objectSpread({}, uploadOperations[uploadOperationId].files[fileId]), {}, {
+        uploadId: uploadOperationId,
+        data: Filerobot.uploadFilesData[fileId]
+      });
+    }
+
+    /**
+     * Get a file object before upload.
+     *
+     * @param {string} fileId The ID of the file object to return.
+     */
+  }, {
+    key: "getFileBeforeUpload",
+    value: function getFileBeforeUpload(fileId) {
+      return selectUploadById(this.getGlobalState(), fileId);
+    }
+
+    /**
+     * Check if minNumberOfFiles restriction is reached before uploading.
+     *
+     * @private
+     */
+  }, {
+    key: "_checkMinNumberOfFiles",
+    value: function _checkMinNumberOfFiles(files) {
+      var minNumberOfFiles = this.opts.restrictions.minNumberOfFiles;
+      if (Object.keys(files).length < minNumberOfFiles) {
+        throw new RestrictionError("".concat(this.i18n('filerobotYouHaveToAtLeastSelectXError', {
+          smart_count: minNumberOfFiles
+        })));
+      }
+    }
+
+    /**
+     * Check if file passes a set of restrictions set in options: maxFileSize,
+     * maxNumberOfFiles and allowedFileTypes.
+     *
+     * @param {object} files Object of files already added
+     * @param {object} file object to check
+     * @private
+     */
+  }, {
+    key: "_checkRestrictions",
+    value: function _checkRestrictions(files, file) {
+      var _this3 = this,
+        _file$data;
+      var dontCheckFileType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var _this$opts$restrictio = this.opts.restrictions,
+        maxFileSize = _this$opts$restrictio.maxFileSize,
+        maxNumberOfFiles = _this$opts$restrictio.maxNumberOfFiles,
+        allowedFileTypes = _this$opts$restrictio.allowedFileTypes,
+        maxTotalFilesSize = _this$opts$restrictio.maxTotalFilesSize,
+        totalUploadedFilesSize = _this$opts$restrictio.totalUploadedFilesSize;
+      var _selectUserSecurityDa = selectUserSecurityData(this.getGlobalState()),
+        _selectUserSecurityDa2 = _selectUserSecurityDa.upload_scope,
+        allowedFoldersToUploadTo = _selectUserSecurityDa2 === void 0 ? this.opts.userFoldersScope : _selectUserSecurityDa2;
+      if (allowedFoldersToUploadTo && allowedFoldersToUploadTo.length > 0) {
+        this.plugins.uploader.forEach(function (plugin) {
+          var folderPath = (file.toFolder || plugin.opts.uploadToFolderPath || selectCurrentFolderPath(_this3.getGlobalState()) || '').toLowerCase().replace(/\/$/, '') || '/';
+          var foundAllowedFolderScope = allowedFoldersToUploadTo.some(function (f) {
+            var folderNameWithNoSlashStar = f.toLowerCase().replace(/\/\*?$/, '');
+            if (folderPath === folderNameWithNoSlashStar || f.endsWith('/*') && folderPath.includes("".concat(folderNameWithNoSlashStar, "/"))) {
+              return true;
+            }
+            return false;
+          });
+          if (!foundAllowedFolderScope) {
+            throw new RestrictionError("".concat(_this3.i18n('filerobotFolderUploadingNotAllowedError', {
+              folder: folderPath
+            })));
+          }
+        });
+      }
+      if (!this.checkUserPermissions([PERMISSIONS.UPLOAD])) {
+        throw new Error("".concat(this.i18n('filerobotInvalidPermissionError')));
+      }
+      if (typeof maxNumberOfFiles === 'number') {
+        if (Object.keys(files).length + 1 > maxNumberOfFiles) {
+          throw new RestrictionError("".concat(this.i18n('filerobotYouCanOnlyUploadXError', {
+            smart_count: maxNumberOfFiles
+          })));
+        }
+      }
+      if (!dontCheckFileType && allowedFileTypes) {
+        var fileType = file.type || file.mimeType;
+        var isCorrectFileType = allowedFileTypes.some(function (type) {
+          var _file$extension;
+          // is this is a mime-type
+          if (type.indexOf('/') > -1) {
+            if (!fileType) return false;
+            return match(fileType.replace(/;.*?$/, ''), type);
+          }
+
+          // otherwise this is likely an extension
+          var fileExtension = type[0] === '.' && ((_file$extension = file.extension) !== null && _file$extension !== void 0 ? _file$extension : getFileExtension(file));
+          if (fileExtension) {
+            return fileExtension.toLowerCase() === type.substr(1).toLowerCase();
+          }
+          return false;
+        });
+        if (!isCorrectFileType) {
+          var allowedFileTypesString = allowedFileTypes.join(', ');
+          throw new RestrictionError(this.i18n('filerobotYouCanOnlyUploadFileTypesError', {
+            types: allowedFileTypesString
+          }));
+        }
+      }
+
+      // We can't check maxFileSize if the size is unknown.
+      var fileSize = ((_file$data = file.data) === null || _file$data === void 0 ? void 0 : _file$data.size) || file.size;
+      if (maxTotalFilesSize) {
+        var totalFilesSize = [].concat(_toConsumableArray(Object.values(files)), [file]).reduce(function (totalSize, file) {
+          var _file$data2;
+          totalSize += ((_file$data2 = file.data) === null || _file$data2 === void 0 ? void 0 : _file$data2.size) || file.size || 0;
+          return totalSize;
+        }, 0);
+        if (convertBytesToMb(totalFilesSize) + totalUploadedFilesSize > maxTotalFilesSize) {
+          throw new RestrictionError(this.i18n('filerobotFilesExceedsSizeError', {
+            size: maxTotalFilesSize
+          }));
+        }
+      }
+      if (maxFileSize && fileSize != null) {
+        if (fileSize > maxFileSize) {
+          throw new RestrictionError(this.i18n('filerobotExceedsSizeError', {
+            size: prettierBytes(maxFileSize)
+          }));
+        }
+      }
+    }
+
+    /**
+     * Logs an error, sets Informer message, then throws the error.
+     * Emits a 'restriction-failed' event if it’s a restriction error
+     *
+     * @param {object | string} err — Error object or plain string message
+     * @param {object} [options]
+     * @param {boolean} [options.showInformer=true] — Sometimes developer might want to show Informer manually
+     * @param {object} [options.file=null] — File object used to emit the restriction error
+     * @param {boolean} [options.throwErr=true] — Errors shouldn’t be thrown, for example, in `upload-error` event
+     * @private
+     */
+  }, {
+    key: "_showOrLogErrorAndThrow",
+    value: function _showOrLogErrorAndThrow(err) {
+      var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref3$showInformer = _ref3.showInformer,
+        showInformer = _ref3$showInformer === void 0 ? true : _ref3$showInformer,
+        _ref3$file = _ref3.file,
+        file = _ref3$file === void 0 ? null : _ref3$file,
+        _ref3$throwErr = _ref3.throwErr,
+        throwErr = _ref3$throwErr === void 0 ? true : _ref3$throwErr;
+      var message = _typeof(err) === 'object' ? err.message : err;
+      var details = _typeof(err) === 'object' && err.details ? err.details : '';
+      var hideRestrictionsInformer = this.opts.restrictions.hideRestrictionsInformer;
+
+      // Restriction errors should be logged, but not as errors,
+      // as they are expected and shown in the UI.
+      var logMessageWithDetails = message;
+      if (details) {
+        logMessageWithDetails += ' ' + details;
+      }
+      if (err.isRestriction) {
+        this.log(logMessageWithDetails);
+        this.emit('restriction-failed', file, err);
+      } else {
+        this.log(logMessageWithDetails, 'error');
+      }
+
+      // Sometimes informer has to be shown manually by the developer,
+      // for example, in `onBeforeFileAdded`.
+      if (showInformer && !hideRestrictionsInformer) {
+        this.info({
+          message: message,
+          details: details
+        }, 'error', 5000);
+      }
+      if (throwErr) {
+        throw _typeof(err) === 'object' ? err : new Error(err);
+      }
+    }
+  }, {
+    key: "_assertNewUploadAllowed",
+    value: function _assertNewUploadAllowed(file) {
+      var _this$getUploadCapabi = this.getUploadCapabilities(),
+        allowNewUpload = _this$getUploadCapabi.allowNewUpload;
+      if (allowNewUpload === false) {
+        this._showOrLogErrorAndThrow(new RestrictionError(this.i18n('filerobotNoNewAlreadyUploadingError')), {
+          file: file
+        });
+      }
+    }
+
+    /**
+     * Create a file state object based on user-provided `addFile()` options.
+     *
+     * Note this is extremely side-effectful and should only be done when a file state object will be added to state immediately afterward!
+     *
+     * The `files` value is passed in because it may be updated by the caller without updating the store.
+     */
+  }, {
+    key: "_checkAndCreateFileStateObject",
+    value: function _checkAndCreateFileStateObject(files, checkedFile) {
+      var _file$data3, _file$data4;
+      var fileType = getFileType(checkedFile);
+      var file = _objectSpread(_objectSpread({}, checkedFile), {}, {
+        type: fileType
+      });
+      var onBeforeFileAddedResult = this.opts.onBeforeFileAdded(file, files);
+      if (onBeforeFileAddedResult === false) {
+        // Don’t show UI info for this error, as it should be done by the developer
+        this._showOrLogErrorAndThrow(new RestrictionError('Cannot add the file because onBeforeFileAdded returned false.'), {
+          showInformer: false,
+          file: file
+        });
+      }
+      if (_typeof(onBeforeFileAddedResult) === 'object' && onBeforeFileAddedResult) {
+        file = onBeforeFileAddedResult;
+      }
+      var fileName;
+      if (file.name) {
+        fileName = file.name;
+      } else if (fileType.split('/')[0] === 'image') {
+        fileName = fileType.split('/')[0] + '.' + fileType.split('/')[1];
+      } else {
+        fileName = 'noname';
+      }
+      var fileExtension = getFileNameAndExtension(fileName, fileType).extension;
+      var isRemote = file.isRemote || false;
+      var fileId = generateFileId(file);
+      if (files[fileId]) {
+        this._showOrLogErrorAndThrow(new RestrictionError(this.i18n('filerobotNoDuplicatesError', {
+          fileName: fileName
+        })), {
+          file: file
+        });
+      }
+      var fileInfo = file.info || {};
+      fileInfo.name = fileName;
+      fileInfo.type = fileType;
+      // `null` means the size is unknown.
+      var size = isFinite((_file$data3 = file.data) === null || _file$data3 === void 0 ? void 0 : _file$data3.size) ? (_file$data4 = file.data) === null || _file$data4 === void 0 ? void 0 : _file$data4.size : null;
+      var newFile = {
+        source: file.source || '',
+        id: fileId,
+        name: fileName,
+        extension: fileExtension || '',
+        info: fileInfo,
+        meta: file.meta || {},
+        product: file.product || {},
+        type: fileType,
+        blob: file.data instanceof File || file.data instanceof Blob ? URL.createObjectURL(file.data) : null,
+        data: extractFileDataNoBlob(file.data),
+        progress: {
+          type: PROGRESS_PANEL_ACTIVITY.UPLOAD,
+          percentage: 0,
+          bytesFinished: 0,
+          bytesTotal: size,
+          startedAt: null,
+          status: FILE_UPLOAD_STATUS.PREPARING
+        },
+        size: size,
+        isRemote: isRemote,
+        remote: file.remote || '',
+        preview: file.preview,
+        toFolder: file.toFolder || selectCurrentFolderPath(this.getGlobalState()),
+        xhrQueryParams: file.xhrQueryParams,
+        xhrHeaders: file.xhrHeaders,
+        uploadStep: true,
+        visibility: file.visibility,
+        uploadUrl: file.uploadUrl,
+        currentUploadId: file.currentUploadId
+      };
+      try {
+        this._checkRestrictions(files, newFile);
+      } catch (err) {
+        this._showOrLogErrorAndThrow(err, {
+          file: newFile
+        });
+      }
+      if (file.data) {
+        Filerobot.uploadFilesData[newFile.id] = file.data;
+      }
+      return newFile;
+    }
+
+    /**
+     * check if file is available and if not it will throw an error
+     *
+     * @param {string} error — Error message
+     * @param {object} file — File object
+     * @private
+     */
+  }, {
+    key: "_checkIfFileIsAvailable",
+    value: function _checkIfFileIsAvailable(file, error) {
+      if (!file) {
+        throw new Error(error);
+      }
+    }
+  }, {
+    key: "isFileRestrictedToGetAdded",
+    value: function isFileRestrictedToGetAdded(files, file) {
+      var dontCheckFileType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      try {
+        this._checkRestrictions(files, file, dontCheckFileType);
+        return false;
+      } catch (err) {
+        this._showOrLogErrorAndThrow(err, {
+          file: file,
+          throwErr: false
+        });
+        return true;
+      }
+    }
+
+    // Schedule an upload if `autoProceed` is enabled.
+  }, {
+    key: "_startIfAutoProceed",
+    value: function _startIfAutoProceed() {
+      var _this4 = this;
+      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref4$forceAutoProcee = _ref4.forceAutoProceed,
+        forceAutoProceed = _ref4$forceAutoProcee === void 0 ? false : _ref4$forceAutoProcee,
+        onUpload = _ref4.onUpload,
+        newFile = _ref4.newFile;
+      if ((this.opts.autoProceed || forceAutoProceed) && !this.scheduledAutoProceed) {
+        this.scheduledAutoProceed = setTimeout(function () {
+          _this4.scheduledAutoProceed = null;
+          _this4.upload()["catch"](function (err) {
+            if (!err.isRestriction) {
+              _this4.log(err.stack || err.message || err);
+            }
+          });
+          if (typeof onUpload === 'function') {
+            onUpload(newFile);
+          }
+        }, 4);
+      }
+    }
+
+    /**
+     * Add a new file to `state.files`. This will run `onBeforeFileAdded`,
+     * try to guess file type in a clever way, check file against restrictions,
+     * and start an upload if `autoProceed === true`.
+     *
+     * @param {object} file object to add
+     * @returns {string} id for the added file
+     */
+  }, {
+    key: "addFile",
+    value: function addFile(file) {
+      var forceAutoProceed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var onUpload = arguments.length > 2 ? arguments[2] : undefined;
+      var fileExtension = getFileNameAndExtension(file.name, file.type).extension;
+      var isRestrictedFileExtension = RESTRICTED_FILES_EXTENISONS.includes(fileExtension);
+      if (isRestrictedFileExtension) {
+        return this.info({
+          message: this.i18n('filerobotRestrictedFileError', {
+            file_extension: fileExtension
+          })
+        }, 'error', 5000);
+      }
+      this._assertNewUploadAllowed(file);
+      var files = this.getUploads();
+      var newFile = this._checkAndCreateFileStateObject(files, file);
+      this.dispatch(uploadsAdded({
+        files: [newFile],
+        skipOpenUploadsPanel: forceAutoProceed
+      }));
+      this.emit('file-added', _objectSpread(_objectSpread({}, newFile), {}, {
+        data: Filerobot.uploadFilesData[newFile.id]
+      }));
+      this.log("Added file: ".concat(newFile.name, ", ").concat(newFile.id, ", mime type: ").concat(newFile.type));
+      this._startIfAutoProceed({
+        forceAutoProceed: forceAutoProceed,
+        onUpload: onUpload,
+        newFile: newFile
+      });
+      return newFile.id;
+    }
+
+    /**
+     * Add multiple files to `state.files`. See the `addFile()` documentation.
+     *
+     * This cuts some corners for performance, so should typically only be used in cases where there may be a lot of files.
+     *
+     * If an error occurs while adding a file, it is logged and the user is notified. This is good for UI plugins, but not for programmatic use. Programmatic users should usually still use `addFile()` on individual files.
+     */
+  }, {
+    key: "addFiles",
+    value: function addFiles(fileDescriptors, forceAutoProceed, _onUpload) {
+      var _this5 = this;
+      var _fileDescriptors = fileDescriptors.filter(function (_ref5) {
+        var name = _ref5.name;
+        return !RESTRICTED_FILES_EXTENISONS.includes(getFileNameAndExtension(name).extension);
+      });
+      this._assertNewUploadAllowed();
+
+      // create a copy of the files object only once
+      var currentAndNewPassedFiles = this.getUploads();
+      var newFiles = [];
+      var errors = [];
+      for (var i = 0; i < _fileDescriptors.length; i++) {
+        try {
+          var newFile = this._checkAndCreateFileStateObject(currentAndNewPassedFiles, _fileDescriptors[i]);
+          newFiles.push(newFile);
+          // We are adding the passed files into the object in every loop step, for considering them in the restrictions counts.
+          currentAndNewPassedFiles[newFile.id] = newFile;
+        } catch (err) {
+          if (!err.isRestriction) {
+            errors.push(err);
+          }
+        }
+      }
+      this.dispatch(uploadsAdded({
+        files: newFiles,
+        skipOpenUploadsPanel: forceAutoProceed
+      }));
+      newFiles.forEach(function (newFile) {
+        _this5.emit('file-added', _objectSpread(_objectSpread({}, newFile), {}, {
+          data: Filerobot.uploadFilesData[newFile.id]
+        }));
+      });
+      if (newFiles.length > 5) {
+        this.log("Added batch of ".concat(newFiles.length, " files"));
+      } else {
+        newFiles.forEach(function (file) {
+          _this5.log("Added file: ".concat(file.name, "\n id: ").concat(file.id, "\n type: ").concat(file.type));
+        });
+      }
+      if (newFiles.length > 0) {
+        this._startIfAutoProceed({
+          forceAutoProceed: forceAutoProceed,
+          onUpload: function onUpload() {
+            return _onUpload && _onUpload(newFiles);
+          }
+        });
+      }
+      if (errors.length > 0) {
+        var message = 'Multiple errors occurred while adding files:\n';
+        errors.forEach(function (subError) {
+          message += "\n * ".concat(subError.message);
+        });
+        this.info({
+          message: this.i18n('addBulkFilesFailedMessage', {
+            smart_count: errors.length
+          }),
+          details: message
+        }, 'error', 5000);
+        var err = new Error(message);
+        err.errors = errors;
+        throw err;
+      }
+    }
+  }, {
+    key: "removeUploads",
+    value: function removeUploads(filesIds) {
+      this.dispatch(uploadsRemoved(filesIds));
+    }
+  }, {
+    key: "removeFile",
+    value: function removeFile(fileId) {
+      var reason = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var fileBeforeRemove = this.getFileUploading(fileId);
+      if (!fileBeforeRemove) {
+        throw new Error("Can\u2019t remove ".concat(fileId, " (the file could have been removed)"));
+      }
+      var uploadOperationId = fileBeforeRemove.uploadId;
+      var currentUploadOperation = this.uploadOperations[uploadOperationId];
+      var notRemovedFileIds = function notRemovedFileIds(uploadFileId) {
+        return uploadFileId !== fileId;
+      };
+      if (currentUploadOperation && uploadOperationId) {
+        var newFileIds = currentUploadOperation.filesIds.filter(notRemovedFileIds);
+        delete currentUploadOperation.files[fileId];
+        delete Filerobot.uploadFilesData[fileId];
+        this.emit('file-removed', fileBeforeRemove, reason);
+        this.log("Removed file: ".concat(fileId));
+        if (newFileIds.length === 0) {
+          delete this.uploadOperations[uploadOperationId];
+          return;
+        }
+        this.uploadOperations[uploadOperationId] = _objectSpread(_objectSpread({}, currentUploadOperation), {}, {
+          filesIds: newFileIds
+        });
+      }
+    }
+  }, {
+    key: "pauseResume",
+    value: function pauseResume(fileId) {
+      if (!this.getUploadCapabilities().allowResumableUploads) {
+        return;
+      }
+      var file = this.getFileUploading(fileId);
+      this._checkIfFileIsAvailable(file, "can't pause or resume for a file that has been removed: ".concat(fileId));
+      var wasPaused = file.progress.status === FILE_UPLOAD_STATUS.PAUSED || false;
+      var isPaused = !wasPaused;
+      var status = isPaused ? FILE_UPLOAD_STATUS.PAUSED : FILE_UPLOAD_STATUS.PROGRESSING;
+      this.emit('activity-update', {
+        id: file.id,
+        progress: {
+          status: status
+        }
+      });
+      this.setFileUploadingState(fileId, file.uploadId, {
+        progress: _objectSpread(_objectSpread({}, file.progress), {}, {
+          status: status
+        })
+      });
+      this.emit('upload-pause', fileId, isPaused);
+    }
+  }, {
+    key: "pauseAll",
+    value: function pauseAll() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated');
+    }
+  }, {
+    key: "resumeAll",
+    value: function resumeAll() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated');
+    }
+  }, {
+    key: "retryAll",
+    value: function retryAll() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated');
+    }
+  }, {
+    key: "cancelAll",
+    value: function cancelAll() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated');
+    }
+  }, {
+    key: "cancelUploads",
+    value: function cancelUploads() {
+      this.emit('cancel-uploads');
+      this.uploadOperations = {};
+      this.dispatch(allUploadsCancelled({
+        capabilities: {
+          allowResumableUploads: Boolean(this.getPlugin(PLUGINS_IDS.TUS))
+        }
+      }));
+    }
+  }, {
+    key: "retryUpload",
+    value: function retryUpload(fileId, fallbackFile) {
+      var file = this.getFileUploading(fileId);
+      if (!file && fallbackFile) {
+        return this.retryRemovedUpload(fallbackFile);
+      }
+      this._checkIfFileIsAvailable(file, "can't retry a file that has been removed: ".concat(fileId));
+      this.setFileUploadingState(fileId, file.uploadId, {
+        error: null
+      });
+      this.emit('upload-retry', fileId);
+      return this._runUploadOperation(file.uploadId);
+    }
+  }, {
+    key: "retryRemovedUpload",
+    value: function retryRemovedUpload(file) {
+      if (!file || _typeof(file) !== 'object') {
+        return;
+      }
+      this.emit('upload-retry', file.id);
+      return this.upload(_defineProperty({}, file.id, file));
+    }
+
+    /**
+     * Registers listeners for all global actions, like:
+     * `error`, `file-removed`, `upload-progress`
+     */
+  }, {
+    key: "_addListeners",
+    value: function _addListeners() {
+      var _this6 = this;
+      this.on('error', function (filesIds, error, _ref6) {
+        var uploadId = _ref6.uploadId;
+        var errorMsg = 'Unknown error';
+        if (error.message) {
+          errorMsg = error.message;
+        }
+        if (error.details) {
+          errorMsg += ' ' + error.details;
+        }
+        filesIds.forEach(function (fileId) {
+          var file = _this6.getFileUploading(fileId);
+          _this6.setFileUploadingState(fileId, uploadId, {
+            progress: _objectSpread(_objectSpread({}, file.progress), {}, {
+              status: FILE_UPLOAD_STATUS.ERROR
+            }),
+            error: errorMsg
+          });
+          _this6.emit('activity-error', {
+            id: file.id,
+            error: errorMsg
+          });
+        });
+      });
+
+      // show informer if offline
+      if (typeof window !== 'undefined' && window.addEventListener) {
+        window.addEventListener('online', function () {
+          return _this6.updateOnlineStatus();
+        });
+        window.addEventListener('offline', function () {
+          return _this6.updateOnlineStatus();
+        });
+        setTimeout(function () {
+          return _this6.updateOnlineStatus();
+        }, 3000);
+      }
+    }
+  }, {
+    key: "updateOnlineStatus",
+    value: function updateOnlineStatus() {
+      var isOnline = checkConnection();
+      if (!isOnline) {
+        this.emit('is-offline');
+        this.info(this.i18n('filerobotNoInternetConnectionInfo'), 'error', 5000);
+        this.wasOffline = true;
+      } else {
+        this.emit('is-online');
+        if (this.wasOffline) {
+          this.emit('back-online');
+          this.info(this.i18n('filerobotConnectedToInternetInfo'), 'success', 3000);
+          this.wasOffline = false;
+        }
+      }
+    }
+  }, {
+    key: "generateUserKey",
+    value: function generateUserKey() {
+      return this.dispatch(_generateUserKey());
+    }
+  }, {
+    key: "checkUserPermissions",
+    value: function checkUserPermissions() {
+      var _this7 = this;
+      var permissionsToCheck = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var showMsg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var state = this.getGlobalState();
+      var permissions = selectUserPermissions(state);
+      var loading = selectCoreLoading(state);
+      var isSasskeyGenerated = !!selectUserSassKey(state);
+      if (Object.keys(permissions).length === 0 && isSasskeyGenerated) {
+        if (!loading) {
+          // Show warning only when permissions are missing after core loading
+          setTimeout(function () {
+            _this7.info(_this7.i18n('filerobotNoPermissionsInfo'), 'error', 5000);
+          }, 0);
+        }
+        return false;
+      }
+      var areAllPermissionsValid = !permissionsToCheck.some(function (permission) {
+        return permission && !permissions[permission];
+      });
+      if (showMsg && !areAllPermissionsValid) {
+        this.info(this.i18n('filerobotInvalidPermissionError'), 'error', 4000);
+        return false;
+      }
+      return areAllPermissionsValid;
+    }
+  }, {
+    key: "getId",
+    value: function getId() {
+      return this.opts.id;
+    }
+
+    /**
+     * Registers a plugin with Core.
+     *
+     * @param {object} Plugin object
+     * @param {object} [opts] object with options to be passed to Plugin
+     * @returns {object} self for chaining
+     */
+  }, {
+    key: "use",
+    value: function use(Plugin, opts) {
+      if (typeof Plugin !== 'function') {
+        var msg = "Expected a plugin class, but got ".concat(Plugin === null ? 'null' : _typeof(Plugin), ".") + ' Please verify that the plugin was imported and spelled correctly.';
+        throw new TypeError(msg);
+      }
+
+      // Instantiate
+      var plugin = new Plugin(this, opts);
+      var pluginId = plugin.id;
+      this.plugins[plugin.type] = this.plugins[plugin.type] || [];
+      if (!pluginId) {
+        throw new Error('Your plugin must have an id');
+      }
+      if (!plugin.type) {
+        throw new Error('Your plugin must have a type');
+      }
+      var existsPluginAlready = this.getPlugin(pluginId);
+      if (existsPluginAlready) {
+        var _msg = "Already found a plugin named '".concat(existsPluginAlready.id, "'. ") + "Tried to use: '".concat(pluginId, "'.\n") + 'filerobot plugins must have unique `id` options.';
+        throw new Error(_msg);
+      }
+      if (Plugin.VERSION) {
+        this.log("Using ".concat(pluginId, " v").concat(Plugin.VERSION));
+      }
+      var pluginReducer = plugin.getPluginReducer();
+      if (typeof pluginReducer === 'function') {
+        this._injectReducer(pluginId, pluginReducer);
+      }
+      this.plugins[plugin.type].push(plugin);
+      plugin.install();
+      this.emit('plugins-updated', this._getInstalledPkgs());
+      return this;
+    }
+
+    /**
+     * Find one Plugin by name.
+     *
+     * @param {string} id plugin id
+     * @returns {object|boolean}
+     */
+  }, {
+    key: "getPlugin",
+    value: function getPlugin(id) {
+      var foundPlugin = null;
+      this.iteratePlugins(function (plugin) {
+        if (plugin.id === id) {
+          foundPlugin = plugin;
+          return false;
+        }
+      });
+      return foundPlugin;
+    }
+
+    /**
+     * Get all the pre-processor plugins
+     *
+     * @returns array
+     */
+  }, {
+    key: "getPreProcessors",
+    value: function getPreProcessors() {
+      return this.preProcessors;
+    }
+
+    /**
+     * Get all the post-processor plugins
+     *
+     * @returns array
+     */
+  }, {
+    key: "getPostProcessors",
+    value: function getPostProcessors() {
+      return this.postProcessors;
+    }
+
+    /**
+     * Iterate through all `use`d plugins.
+     *
+     * @param {Function} method that will be run on each plugin
+     */
+  }, {
+    key: "iteratePlugins",
+    value: function iteratePlugins(method) {
+      var _this8 = this;
+      Object.keys(this.plugins).forEach(function (pluginType) {
+        _this8.plugins[pluginType].forEach(method);
+      });
+    }
+  }, {
+    key: "checkPluginTypeExistence",
+    value: function checkPluginTypeExistence() {
+      var pluginTypeToCheck = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      var pluginTypeLoweredCase = pluginTypeToCheck.toLowerCase();
+      if (!pluginTypeLoweredCase) {
+        return;
+      }
+      return Object.keys(this.plugins).includes(pluginTypeLoweredCase) && this.plugins[pluginTypeLoweredCase].length > 0;
+    }
+  }, {
+    key: "checkPluginExistence",
+    value: function checkPluginExistence() {
+      var pluginIdToCheck = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      if (!pluginIdToCheck) {
+        return;
+      }
+      return Boolean(this.getPlugin(pluginIdToCheck));
+    }
+
+    /**
+     * Uninstall and remove a plugin.
+     *
+     * @param {object} instance The plugin instance to remove.
+     */
+  }, {
+    key: "removePlugin",
+    value: function removePlugin(instance) {
+      this.log("Removing plugin ".concat(instance.id));
+      if (instance.uninstall) {
+        instance.uninstall();
+      }
+      var list = this.plugins[instance.type].slice();
+      var index = list.indexOf(instance);
+      if (index !== -1) {
+        list.splice(index, 1);
+        this._removeReducer(instance.id);
+        this.plugins[instance.type] = list;
+      }
+      this.emit('plugin-remove', instance);
+      this.emit('plugins-updated', this._getInstalledPkgs());
+    }
+
+    /**
+     * Uninstall all plugins and close down this filerobot instance.
+     */
+  }, {
+    key: "close",
+    value: function close() {
+      var _this9 = this;
+      this.log("Closing filerobot instance ".concat(this.opts.id, ": removing all files and uninstalling plugins"));
+      this._storeUnsubscribe();
+      if (this.opts.sassKeyRenewerEnabled) {
+        this._sassKeyRenewerUnsubscribe();
+      }
+      this.iteratePlugins(function (plugin) {
+        _this9.removePlugin(plugin);
+      });
+    }
+
+    /**
+     * Set info message in `state.info`, so that UI plugins like `Informer`
+     * can display the message.
+     *
+     * @param {string | object} message Message to be displayed by the informer
+     * @param {string} [type]
+     * @param {number} [duration]
+     */
+  }, {
+    key: "info",
+    value: function info(message) {
+      var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'info';
+      var duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 3000;
+      // Avoid showing aborted/cancelled request feedback to the user.
+      if (message === ABORTED_ERROR || message === (ABORTED_ERROR === null || ABORTED_ERROR === void 0 ? void 0 : ABORTED_ERROR.message)) {
+        return;
+      }
+      var isComplexMessage = _typeof(message) === 'object';
+      var toStringIfObj = function toStringIfObj(data) {
+        return _typeof(data) === 'object' ? data.toString() : data;
+      };
+      this.dispatch(infoSet({
+        isHidden: false,
+        type: type,
+        message: isComplexMessage ? toStringIfObj(message.message) : message,
+        details: isComplexMessage ? toStringIfObj(message.details) : null,
+        errors: message.errors
+      }));
+      this.emit('info-visible');
+      clearTimeout(this.infoTimeoutId);
+      if (duration === 0) {
+        this.infoTimeoutId = undefined;
+        return;
+      }
+
+      // hide the informer after `duration` milliseconds
+      this.infoTimeoutId = setTimeout(this.hideInfo, duration);
+    }
+  }, {
+    key: "hideInfo",
+    value: function hideInfo() {
+      this.dispatch(infoHid());
+      this.emit('info-hidden');
+    }
+
+    /**
+     * Passes messages to a function, provided in `opts.logger`.
+     * If `opts.logger: filerobot.debugLogger` or `opts.debug: true`, logs to the browser console.
+     *
+     * @param {string|object} message to log
+     * @param {string} [type] optional `error` or `warning`
+     */
+  }, {
+    key: "log",
+    value: function log(message, type) {
+      var logger = this.opts.logger;
+      if (!logger) {
+        return;
+      }
+      switch (type) {
+        case 'error':
+          logger.error(message);
+          break;
+        case 'warning':
+          logger.warn(message);
+          break;
+        default:
+          logger.debug(message);
+          break;
+      }
+    }
+
+    /**
+     * Obsolete, event listeners are now added in the constructor.
+     */
+  }, {
+    key: "run",
+    value: function run() {
+      this.log('Calling run() is no longer necessary.', 'warning');
+      return this;
+    }
+
+    /**
+     * Restore an upload by its ID.
+     */
+  }, {
+    key: "restore",
+    value: function restore(uploadId) {
+      this.log("Core: attempting to restore upload \"".concat(uploadId, "\""));
+      if (!this.getUploadOperation(uploadId)) {
+        this._removeUploadOperation(uploadId);
+        return Promise.reject(new Error('Nonexistent upload'));
+      }
+      return this._runUploadOperation(uploadId);
+    }
+
+    /**
+     * Create an upload for a bunch of files.
+     *
+     * @param {Object} files Files to include in this upload.
+     * @returns {string} ID of this upload.
+     */
+  }, {
+    key: "_createUploadOperation",
+    value: function _createUploadOperation(files) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var _opts$forceAllowNewUp = opts.forceAllowNewUpload,
+        forceAllowNewUpload = _opts$forceAllowNewUp === void 0 ? false : _opts$forceAllowNewUp;
+      var _this$getUploadCapabi2 = this.getUploadCapabilities(),
+        allowNewUpload = _this$getUploadCapabi2.allowNewUpload;
+      if (!allowNewUpload && !forceAllowNewUpload) {
+        throw new Error('Cannot create a new upload: already uploading.');
+      }
+      var uploadId = cuid();
+      var filesIds = Object.keys(files);
+      this.emit('upload', {
+        id: uploadId,
+        filesIds: filesIds,
+        files: files
+      });
+      this.dispatch(uploadCapabilitiesUpdated({
+        allowMultipleUploads: this.opts.allowMultipleUploads,
+        allowNewUpload: this.opts.allowMultipleUploads !== false
+      }));
+      this.uploadOperations[uploadId] = {
+        id: uploadId,
+        filesIds: filesIds,
+        files: files,
+        step: 0,
+        result: {}
+      };
+      return uploadId;
+    }
+  }, {
+    key: "getUploadOperation",
+    value: function getUploadOperation(uploadId) {
+      return this.getUploadOperations()[uploadId];
+    }
+
+    /**
+     * Add data to an upload's result object.
+     *
+     * @param {string} uploadId The ID of the upload.
+     * @param {object} data Data properties to add to the result object.
+     */
+  }, {
+    key: "addResultData",
+    value: function addResultData(uploadId, data) {
+      if (!this.getUploadOperation(uploadId)) {
+        this.log("Not setting result for an upload that has been removed: ".concat(uploadId));
+        return;
+      }
+      var currentUploadOperation = this.getUploadOperation(uploadId);
+      this._updateUploadOperation({
+        id: uploadId,
+        result: _objectSpread(_objectSpread({}, currentUploadOperation.result), data)
+      });
+    }
+
+    /**
+     * Remove an upload, eg. if it has been canceled or completed.
+     *
+     * @param {string} uploadId The ID of the upload.
+    */
+  }, {
+    key: "_removeUploadOperation",
+    value: function _removeUploadOperation(uploadId) {
+      delete this.uploadOperations[uploadId];
+    }
+
+    /**
+     * Edit an upload, eg. if its step/phase is being updated.
+     *
+     * @param {string} updatedUpload - the updated/changed upload operation must contain `id` for the upload's id to be changed.
+     */
+  }, {
+    key: "_updateUploadOperation",
+    value: function _updateUploadOperation(updatedUpload) {
+      this.uploadOperations[updatedUpload.id] = _objectSpread(_objectSpread({}, this.uploadOperations[updatedUpload.id]), updatedUpload);
+    }
+  }, {
+    key: "setProgressPanelFileState",
+    value: function setProgressPanelFileState() {
+      // This method is deprecated
+      // TODO: remove completely after a while
+      this.log('This method is deprecated, please use setFileUploadingState instead');
+    }
+  }, {
+    key: "setFileUploadingState",
+    value: function setFileUploadingState(fileId, uploadId, state) {
+      var _this$uploadOperation;
+      if (!this.getFileUploading(fileId)) {
+        throw new Error("Can\u2019t set state for ".concat(fileId, " (the file could have been removed)"));
+      }
+      var fileState = _objectSpread(_objectSpread({}, state), {}, {
+        id: fileId
+      });
+      var currentFiles = (_this$uploadOperation = this.uploadOperations[uploadId]) === null || _this$uploadOperation === void 0 ? void 0 : _this$uploadOperation.files;
+      var currentFile = currentFiles === null || currentFiles === void 0 ? void 0 : currentFiles[fileId];
+      this._updateUploadOperation({
+        id: uploadId,
+        files: _objectSpread(_objectSpread({}, currentFiles), {}, _defineProperty({}, fileId, _objectSpread(_objectSpread({}, currentFile), fileState)))
+      });
+    }
+
+    /**
+     * Run an upload. This picks up where it left off in case the upload is being restored.
+     *
+     * @private
+     */
+  }, {
+    key: "_runUploadOperation",
+    value: function _runUploadOperation(uploadId) {
+      var _this10 = this;
+      var uploadData = this.getUploadOperation(uploadId);
+      var restoreStep = uploadData.step;
+      var steps = [].concat(_toConsumableArray(this.preProcessors), _toConsumableArray(this.filerobots), _toConsumableArray(this.postProcessors));
+      var lastStep = Promise.resolve();
+      steps.forEach(function (fn, step) {
+        // Skip this step if we are restoring and have already completed this step before.
+        if (step < restoreStep) {
+          return;
+        }
+        lastStep = lastStep.then(function () {
+          var currentUploadOperation = _this10.getUploadOperation(uploadId);
+          if (!currentUploadOperation) {
+            return;
+          }
+          var updatedUploadSlice = {
+            id: uploadId,
+            step: step
+          };
+          _this10._updateUploadOperation(updatedUploadSlice);
+          // The processor is an object { process: fn, render: fn } which contains process function
+          // otherwise would be the uploading process function.
+          return fn ? (fn.process || fn)(currentUploadOperation.filesIds, uploadId) : Promise.resolve();
+        }).then(function (result) {
+          return null;
+        });
+      });
+
+      // Not returning the `catch`ed promise, because we still want to return a rejected
+      // promise from this method if the upload failed.
+      lastStep["catch"](function (error) {
+        var currentUploadOperation = _this10.getUploadOperation(uploadId);
+        var filesIds = currentUploadOperation.filesIds;
+        _this10.emit('error', filesIds, error, {
+          uploadId: uploadId
+        });
+        _this10._removeUploadOperation(uploadId);
+      });
+      return lastStep.then(function () {
+        // Set result data.
+        var currentUploadOperation = _this10.getUploadOperation(uploadId);
+        if (!currentUploadOperation) {
+          return;
+        }
+        var files = currentUploadOperation.filesIds.map(function (fileId) {
+          return _this10.getFileUploading(fileId);
+        });
+        var successful = files.filter(function (file) {
+          return (file === null || file === void 0 ? void 0 : file.progress.status) !== FILE_UPLOAD_STATUS.ERROR;
+        });
+        var failed = files.filter(function (file) {
+          return (file === null || file === void 0 ? void 0 : file.progress.status) === FILE_UPLOAD_STATUS.ERROR;
+        });
+        _this10.addResultData(uploadId, {
+          successful: successful,
+          failed: failed,
+          uploadId: uploadId
+        });
+      }).then(function () {
+        // Emit completion events.
+        // This is in a separate function so that the `currentUploadOperations` variable
+        // always refers to the latest state. In the handler right above it refers
+        // to an outdated object without the `.result` property.
+        var currentUploadOperation = _this10.getUploadOperation(uploadId);
+        if (!currentUploadOperation) {
+          return;
+        }
+        var result = currentUploadOperation.result;
+        _this10.emit('complete', result);
+        _this10._removeUploadOperation(uploadId);
+        return result;
+      }).then(function (result) {
+        if (result == null) {
+          _this10.log("Not setting result for an upload that has been removed: ".concat(uploadId));
+        }
+        return result;
+      });
+    }
+
+    /**
+     * Start an upload for all the files that are not currently being uploaded.
+     *
+     * @returns {Promise}
+     */
+  }, {
+    key: "upload",
+    value: function upload(files, callback) {
+      var _this11 = this;
+      if (!this.plugins.uploader) {
+        this.log('No filerobot type plugins are used', 'warning');
+      }
+      var filesToUpload = files || selectUploads(this.getGlobalState());
+      var onBeforeUploadResult = this.opts.onBeforeUpload(filesToUpload);
+      if (onBeforeUploadResult === false) {
+        return Promise.reject(new Error('Not starting the upload because onBeforeUpload returned false'));
+      }
+      if (onBeforeUploadResult && _typeof(onBeforeUploadResult) === 'object') {
+        filesToUpload = onBeforeUploadResult;
+      }
+      return Promise.resolve().then(function () {
+        return _this11._checkMinNumberOfFiles(filesToUpload);
+      })["catch"](function (err) {
+        _this11._showOrLogErrorAndThrow(err);
+      }).then(function () {
+        if (typeof callback === 'function') {
+          callback(filesToUpload);
+        }
+        _this11.dispatch(allUploadsRemoved());
+        var currentUploadOperations = _this11.getUploadOperations();
+        // get a list of files that are currently assigned to uploads
+        var currentlyUploadingFiles = Object.keys(currentUploadOperations).reduce(function (prev, curr) {
+          return prev.concat(currentUploadOperations[curr].filesIds);
+        }, []);
+        var waitingFiles = {};
+        Object.keys(filesToUpload).forEach(function (fileId) {
+          // if the file hasn't started uploading
+          if (currentlyUploadingFiles.indexOf(fileId) === -1) {
+            waitingFiles[fileId] = _objectSpread({}, filesToUpload[fileId]);
+          }
+        });
+        var uploadId = _this11._createUploadOperation(waitingFiles);
+        return _this11._runUploadOperation(uploadId);
+      })["catch"](function (err) {
+        _this11._showOrLogErrorAndThrow(err, {
+          showInformer: false
+        });
+      });
+    }
+  }, {
+    key: "getRemoteUploadFolder",
+    value: function getRemoteUploadFolder() {
+      var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref7$file = _ref7.file,
+        file = _ref7$file === void 0 ? {} : _ref7$file,
+        opts = _ref7.opts;
+      var _this$getCoreCommonSt = this.getCoreCommonState(),
+        dndTargetFolderPath = _this$getCoreCommonSt.dndTargetFolderPath,
+        _this$getCoreCommonSt2 = _this$getCoreCommonSt.isDragging,
+        isDragging = _this$getCoreCommonSt2 === void 0 ? false : _this$getCoreCommonSt2,
+        _this$getCoreCommonSt3 = _this$getCoreCommonSt.xhrUpload,
+        xhrUpload = _this$getCoreCommonSt3 === void 0 ? {} : _this$getCoreCommonSt3;
+      var _ref8 = opts || _objectSpread(_objectSpread(_objectSpread({}, this.opts), xhrUpload), file === null || file === void 0 ? void 0 : file.xhrUpload),
+        uploadToFolderPath = _ref8.uploadToFolderPath,
+        _ref8$uploadQueryPara = _ref8.uploadQueryParams,
+        uploadQueryParams = _ref8$uploadQueryPara === void 0 ? '' : _ref8$uploadQueryPara;
+      var isFolderInUploadParams = (uploadQueryParams === null || uploadQueryParams === void 0 ? void 0 : uploadQueryParams.search('(^|&)folder=')) > -1;
+      var path = '/';
+      if (isFolderInUploadParams) path = uploadQueryParams.match(/folder=([^&]*)/)[1];else if (uploadToFolderPath) path = uploadToFolderPath;else if (isDragging) path = dndTargetFolderPath;else if (file !== null && file !== void 0 && file.toFolder) path = file.toFolder;
+      return decodeURIComponent(path);
+    }
+  }]);
+}();
+// static VERSION = version
+// This property contains the data File class instance of the uploads' files, mapped through the file id,
+// as `File` class is not serializable data type so we are not saving it into redux, and keeping it in sync with related upload/file object.
+_defineProperty(Filerobot, "uploadFilesData", {
+  // [fileId]: { [File/Blob instance] }
+});
+export default function (opts) {
+  return new Filerobot(opts);
+}
+
+// Expose class constructor.
+export { Filerobot, Plugin, debugLogger };