@scaleflex/widget-core 0.0.1

package/lib/loggers.js

@@ -0,0 +1,45 @@
+function _readOnlyError(r) { throw new TypeError('"' + r + '" is read-only'); }
+import getTimeStamp from '@scaleflex/widget-utils/lib/getTimeStamp';
+
+// Swallow all logs, except errors.
+// default if logger is not set or debug: false
+var justErrorsLogger = {
+  debug: function debug() {},
+  warn: function warn() {},
+  error: function error() {
+    var _console;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return (_console = console).error.apply(_console, ["[Filerobot] [".concat(getTimeStamp(), "]")].concat(args));
+  }
+};
+
+// Print logs to console with namespace + timestamp,
+// set by logger: Filerobot.debugLogger or debug: true
+var debugLogger = {
+  debug: function debug() {
+    var _debug;
+    // IE 10 doesn’t support console.debug
+    var debug = console.debug || console.log;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    (_debug = debug).call.apply(_debug, [console, "[Filerobot] [".concat(getTimeStamp(), "]")].concat(args));
+  },
+  warn: function warn() {
+    var _console2;
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return (_console2 = console).warn.apply(_console2, ["[Filerobot] [".concat(getTimeStamp(), "]")].concat(args));
+  },
+  error: function error() {
+    var _console3;
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return (_console3 = console).error.apply(_console3, ["[Filerobot] [".concat(getTimeStamp(), "]")].concat(args));
+  }
+};
+export { justErrorsLogger, debugLogger };

package/lib/slices/common.slice.js

@@ -0,0 +1,90 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _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 { createSlice } from '@reduxjs/toolkit';
+import { PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import { fetchUserAuthState, generateUserKey } from './user.slice';
+
+/**
+ * The order of the code in slice file is:
+ *  1. initialState (*No* export needed)
+ *  2. automated thunks functions -- uses createThunk API-- (export needed)
+ *  3. createSlice (*No* export needed)
+ *  4. actions exports
+ *  5. selectors (export needed)
+ *  6. default reducer export
+ *
+ */
+export var slicePropName = 'common';
+var sliceName = "".concat(PLUGINS_IDS.CORE, "/").concat(slicePropName);
+var initialState = {
+  loading: true,
+  companion: {},
+  xhrUpload: {},
+  imageProcessor: {},
+  videoTranscoding: {},
+  fromDragging: false,
+  dndTargetFolderPath: '',
+  isDragging: false,
+  isRelevanceAvailable: false,
+  isDevEnv: false // retrieved from opts.dev
+  // isRelevanceAvailable: localStorage.getItem('show-relevance') === 'true' (needed in explorer only)
+};
+var commonSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    loadingSet: function loadingSet(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: action.payload
+      });
+    },
+    coreCommonStateUpdated: function coreCommonStateUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder
+    // We don't need to add extraReducer for .pending case, as by default the app starts in loading: true state,
+    // User might hit the refreshment of sass key generation before getting expired, so we don't need to set loading to true
+    // to avoid bothering the user, it's better to done in the background.
+    .addMatcher(function (_ref) {
+      var type = _ref.type;
+      return [generateUserKey.fulfilled.type, fetchUserAuthState.fulfilled.type].includes(type);
+    }, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: false
+      });
+    }).addMatcher(function (_ref2) {
+      var type = _ref2.type;
+      return [generateUserKey.rejected.type, fetchUserAuthState.rejected.type].includes(type);
+    }, function (state, action) {
+      return getActionErrorState(state, action);
+    });
+  }
+});
+var _commonSlice$actions = commonSlice.actions,
+  loadingSet = _commonSlice$actions.loadingSet,
+  coreCommonStateUpdated = _commonSlice$actions.coreCommonStateUpdated;
+export { loadingSet, coreCommonStateUpdated };
+export var selectCommonState = function selectCommonState(state) {
+  return state[PLUGINS_IDS.CORE][slicePropName];
+};
+
+// !TODO: This is not appropriate as it will be undefined in-case explorer isn't there, so maybe better to remove it.
+// Local selector "selectCurrentFolderPath" was created because of the error "failed to initialize ..." if we try to import via @filerobot..../slice.. inside core/src/index.js
+export var selectCurrentFolderPath = function selectCurrentFolderPath(state) {
+  var _state$PLUGINS_IDS$EX, _state$PLUGINS_IDS$EX2, _state$PLUGINS_IDS$EX3, _state$PLUGINS_IDS$EX4, _state$PLUGINS_IDS$EX5;
+  return ((_state$PLUGINS_IDS$EX = state[PLUGINS_IDS.EXPLORER]) === null || _state$PLUGINS_IDS$EX === void 0 ? void 0 : (_state$PLUGINS_IDS$EX2 = _state$PLUGINS_IDS$EX.folders) === null || _state$PLUGINS_IDS$EX2 === void 0 ? void 0 : (_state$PLUGINS_IDS$EX3 = _state$PLUGINS_IDS$EX2.currentFolder) === null || _state$PLUGINS_IDS$EX3 === void 0 ? void 0 : _state$PLUGINS_IDS$EX3.path) || ((_state$PLUGINS_IDS$EX4 = state[PLUGINS_IDS.EXPLORER]) === null || _state$PLUGINS_IDS$EX4 === void 0 ? void 0 : (_state$PLUGINS_IDS$EX5 = _state$PLUGINS_IDS$EX4.folders) === null || _state$PLUGINS_IDS$EX5 === void 0 ? void 0 : _state$PLUGINS_IDS$EX5.baseFolderPath);
+};
+export var selectCoreLoading = function selectCoreLoading(state) {
+  return selectCommonState(state).loading;
+};
+export var selectIsRelevanceAvailable = function selectIsRelevanceAvailable(state) {
+  return selectCommonState(state).isRelevanceAvailable;
+};
+export default commonSlice.reducer;

package/lib/slices/index.js

@@ -0,0 +1,12 @@
+import { combineReducers } from '@reduxjs/toolkit';
+import common from './common.slice';
+import uploads from './uploads.slice';
+import info from './info.slice';
+import user from './user.slice';
+var coreReducer = combineReducers({
+  common: common,
+  uploads: uploads,
+  info: info,
+  user: user
+});
+export default coreReducer;

package/lib/slices/info.slice.js

@@ -0,0 +1,52 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _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 { createSlice } from '@reduxjs/toolkit';
+import { PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+
+/**
+ * The order of the code in slice file is:
+ *  1. initialState (*No* export needed)
+ *  2. automated thunks functions -- uses createThunk API-- (export needed)
+ *  3. createSlice (*No* export needed)
+ *  4. actions exports
+ *  5. selectors (export needed)
+
+ *  7. default reducer export
+ *
+ */
+var slicePropName = 'info';
+var sliceName = "".concat(PLUGINS_IDS.CORE, "/").concat(slicePropName);
+var initialState = {
+  isHidden: true,
+  type: 'info',
+  message: '',
+  details: ''
+};
+var infoSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    infoSet: function infoSet(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isHidden: false
+      }, action.payload);
+    },
+    infoHid: function infoHid(state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isHidden: true
+      });
+    }
+  }
+});
+var _infoSlice$actions = infoSlice.actions,
+  infoSet = _infoSlice$actions.infoSet,
+  infoHid = _infoSlice$actions.infoHid;
+export { infoSet, infoHid };
+export var selectInfo = function selectInfo(state) {
+  return state[PLUGINS_IDS.CORE][slicePropName];
+};
+export default infoSlice.reducer;

package/lib/slices/uploads.slice.js

@@ -0,0 +1,294 @@
+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 _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 { createSelector, createSlice } from '@reduxjs/toolkit';
+import { UPLOAD_CONNECTOR_SERVER, PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import deepMerge from '@scaleflex/widget-utils/lib/deepMerge';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import supportsUploadProgress from '../supportsUploadProgress';
+import { Filerobot } from '../';
+
+/**
+ * The order of the code in slice file is:
+ *  1. initialState (*No* export needed)
+ *  2. automated thunks functions -- uses createThunk API-- (export needed)
+ *  3. createSlice (*No* export needed)
+ *  4. actions exports
+ *  5. selectors (export needed)
+ *  6. default reducer export
+ *
+ */
+var slicePropName = 'uploads';
+var sliceName = "".concat(PLUGINS_IDS.CORE, "/").concat(slicePropName);
+var initialState = {
+  ids: [],
+  files: {},
+  capabilities: {
+    allowUploadProgress: supportsUploadProgress(),
+    allowIndividualCancellation: true,
+    allowResumableUploads: false,
+    allowNewUpload: true,
+    allowMultipleUploads: true
+  },
+  error: null
+};
+export var updateUploadInfoMetaTags = createThunk(function (_ref, thunkApi) {
+  var filesIds = _ref.filesIds,
+    meta = _ref.meta,
+    tags = _ref.tags,
+    info = _ref.info,
+    tagsForceUpdate = _ref.tagsForceUpdate,
+    deepMergeMeta = _ref.deepMergeMeta,
+    removeMeta = _ref.removeMeta;
+  var updatedFiles = _objectSpread({}, selectUploads(thunkApi.getState()));
+  filesIds.forEach(function (fileId) {
+    var newFile = _objectSpread({}, updatedFiles[fileId]);
+    if (info) {
+      newFile.info = _objectSpread(_objectSpread({}, newFile.info), info);
+      if (info !== null && info !== void 0 && info.name) {
+        newFile.name = info.name;
+      }
+    }
+    if (meta) {
+      if (deepMergeMeta) {
+        newFile.meta = deepMerge(newFile.meta, meta, {
+          considerArray: true,
+          removeFromArray: removeMeta,
+          dismissArrayIfSourceNotArray: removeMeta
+        });
+      } else {
+        newFile.meta = _objectSpread(_objectSpread({}, newFile.meta), meta);
+      }
+    }
+    if (tags) {
+      newFile.tags = tagsForceUpdate ? tags : deepMerge(newFile.tags, tags, {
+        considerArray: true
+      });
+    }
+    updatedFiles[fileId] = newFile;
+  });
+  thunkApi.dispatch(uploadsReplaced(updatedFiles));
+  return updatedFiles;
+});
+export var getResumableUploadFastestServer = createThunk(async function (_, thunkApi) {
+  var adminApiEndpoint = thunkApi.extra.filerobot.opts.adminApiEndpoint;
+  var apiUrl = "".concat(adminApiEndpoint, "/constants/uploaders.connectors.endpoints/items");
+  var fetchEndpoints = async function fetchEndpoints() {
+    var response = await fetch(apiUrl);
+    if (!response.ok) {
+      throw new Error('Failed to fetch connector endpoints.');
+    }
+    return response.json();
+  };
+  var pingServer = async function pingServer(serverUrl) {
+    var responseTimes = await Promise.all(_toConsumableArray(new Array(3)).map(async function () {
+      var startTime = performance.now();
+      try {
+        var response = await fetch("https://".concat(serverUrl, "/ping"));
+        if (!response.ok) throw new Error('Ping failed');
+        var endTime = performance.now();
+        return endTime - startTime;
+      } catch (_unused) {
+        return null; // null means the ping failed
+      }
+    }));
+    return {
+      serverUrl: serverUrl,
+      responseTimes: responseTimes
+    };
+  };
+  try {
+    // Fetch the list of connector servers
+    var servers = await fetchEndpoints();
+
+    // Ping each server asynchronously
+    var pingResults = await Promise.all(servers === null || servers === void 0 ? void 0 : servers.items.map(pingServer));
+
+    // Filter servers with 100% successful responses
+    var successfulPings = pingResults.filter(function (_ref2) {
+      var responseTimes = _ref2.responseTimes;
+      return responseTimes.every(function (time) {
+        return time !== null;
+      });
+    });
+    if (successfulPings.length === 0) {
+      throw new Error('No servers with 100% successful ping responses.');
+    }
+
+    // Calculate average ping times
+    var serversAverages = successfulPings.map(function (_ref3) {
+      var serverUrl = _ref3.serverUrl,
+        responseTimes = _ref3.responseTimes;
+      var validPings = responseTimes.slice(1); // Ignore the first ping
+      var pingsAvgTime = validPings.reduce(function (totalPingsTime, pingTime) {
+        return totalPingsTime + pingTime;
+      }, 0) / validPings.length;
+      return {
+        serverUrl: serverUrl,
+        pingsAvgTime: pingsAvgTime
+      };
+    });
+
+    // Find the server with the lowest average time
+    var closestServer = serversAverages.reduce(function (fastestServer, currentServer) {
+      return currentServer.pingsAvgTime < fastestServer.pingsAvgTime ? currentServer : fastestServer;
+    });
+    sessionStorage.setItem(UPLOAD_CONNECTOR_SERVER, "https://".concat(closestServer.serverUrl));
+    return "https://".concat(closestServer.serverUrl);
+  } catch (error) {
+    // Retry logic
+    var retryCount = 0;
+    var MAX_RETRIES = 1;
+    if (error.message.includes('No servers') && retryCount < MAX_RETRIES) {
+      retryCount++;
+      try {
+        return await getResumableUploadFastestServer();
+      } catch (retryError) {
+        thunkApi.extra.filerobot.info(thunkApi.extra.filerobot.i18n('explorerResumableUploadFastestServerError'), 'error');
+        return null;
+      }
+    }
+    return null;
+  }
+});
+var uploadsSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    uploadsAdded: function uploadsAdded(state, action) {
+      var addedFiles = action.payload.files || action.payload;
+      var newFiles = addedFiles.reduce(function (filesByIds, file) {
+        return _objectSpread(_objectSpread({}, filesByIds), {}, _defineProperty({}, file.id, file));
+      }, {});
+      return _objectSpread(_objectSpread({}, state), {}, {
+        ids: _toConsumableArray(new Set([].concat(_toConsumableArray(state.ids), _toConsumableArray(Object.keys(newFiles))))),
+        files: _objectSpread(_objectSpread({}, state.files), newFiles)
+      });
+    },
+    uploadsReplaced: function uploadsReplaced(state, action) {
+      var files = action.payload;
+      var newFiles = Array.isArray(files) ? files.reduce(function (filesByIds, file) {
+        return _objectSpread(_objectSpread({}, filesByIds), {}, _defineProperty({}, file.id, file));
+      }, {}) : files;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        ids: Object.keys(newFiles),
+        files: newFiles
+      });
+    },
+    uploadsRemoved: function uploadsRemoved(state, action) {
+      // If no payload is provided with the filesIds to be removed, then all the files will get removed.
+      var removedFilesIds = action.payload || [];
+      var shouldRemoveAllFiles = removedFilesIds.length === 0;
+      var updatedFiles = shouldRemoveAllFiles ? {} : _objectSpread({}, state.files);
+      var updatedIds = shouldRemoveAllFiles ? [] : state.ids;
+      removedFilesIds.forEach(function (fileId) {
+        updatedIds = updatedIds.filter(function (id) {
+          return id !== fileId;
+        });
+        delete updatedFiles[fileId];
+      });
+      var isAllUploadsRemoved = Object.keys(updatedFiles).length === 0;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        ids: updatedIds,
+        files: updatedFiles,
+        capabilities: _objectSpread(_objectSpread({}, state.capabilities), {}, {
+          allowNewUpload: isAllUploadsRemoved || state.capabilities.allowNewUpload
+        })
+      });
+    },
+    uploadUpdated: function uploadUpdated(state, action) {
+      var fileId = action.payload.id;
+      var updatedFiles = _objectSpread({}, state.files);
+      updatedFiles[fileId] = _objectSpread(_objectSpread({}, state.files[fileId]), action.payload);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        files: updatedFiles
+      });
+    },
+    allUploadsCancelled: function allUploadsCancelled(state, action) {
+      var _ref4 = action.payload || {},
+        _ref4$capabilities = _ref4.capabilities,
+        capabilities = _ref4$capabilities === void 0 ? {} : _ref4$capabilities;
+      return _objectSpread(_objectSpread({}, initialState), {}, {
+        capabilities: _objectSpread(_objectSpread({}, state.capabilities), capabilities)
+      });
+    },
+    allUploadsRemoved: function allUploadsRemoved(state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        ids: [],
+        files: {}
+      });
+    },
+    uploadCapabilitiesUpdated: function uploadCapabilitiesUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        capabilities: _objectSpread(_objectSpread({}, state.capabilities), action.payload)
+      });
+    }
+  }
+});
+var _uploadsSlice$actions = uploadsSlice.actions,
+  uploadsAdded = _uploadsSlice$actions.uploadsAdded,
+  uploadsReplaced = _uploadsSlice$actions.uploadsReplaced,
+  uploadsRemoved = _uploadsSlice$actions.uploadsRemoved,
+  uploadUpdated = _uploadsSlice$actions.uploadUpdated,
+  allUploadsRemoved = _uploadsSlice$actions.allUploadsRemoved,
+  allUploadsCancelled = _uploadsSlice$actions.allUploadsCancelled,
+  uploadCapabilitiesUpdated = _uploadsSlice$actions.uploadCapabilitiesUpdated;
+export { uploadsAdded, uploadsReplaced, uploadsRemoved, uploadUpdated, allUploadsRemoved, allUploadsCancelled, uploadCapabilitiesUpdated };
+export var selectUploadsState = function selectUploadsState(state) {
+  return state[PLUGINS_IDS.CORE][slicePropName];
+};
+export var selectUploadCapabilities = function selectUploadCapabilities(state, property) {
+  return property ? selectUploadsState(state).capabilities[property] : selectUploadsState(state).capabilities;
+};
+
+// Note: this selector doesn't contain the data [File/Blob instance] in the property for avoiding always rerendering in case of state changing.
+export var selectUploads = function selectUploads(state) {
+  return selectUploadsState(state).files;
+};
+export var selectUploadsIds = function selectUploadsIds(state) {
+  return selectUploadsState(state).ids;
+};
+export var selectUploadsArray = createSelector(selectUploads, function (files) {
+  return Object.keys(files).map(function (fileId) {
+    return files[fileId] ? _objectSpread(_objectSpread({}, files[fileId]), {}, {
+      data: Filerobot.uploadFilesData[fileId]
+    }) : undefined;
+  });
+});
+export var selectUploadById = createSelector([selectUploads, function (_state, fileId) {
+  return fileId;
+}], function (files, fileId) {
+  return files[fileId] ? _objectSpread(_objectSpread({}, files[fileId]), {}, {
+    data: Filerobot.uploadFilesData[fileId]
+  }) : undefined;
+});
+export var selectUploadsByIds = createSelector([selectUploads, function (_state, filesIds) {
+  return filesIds;
+}], function (files, filesIds) {
+  return filesIds.map(function (fileId) {
+    return files[fileId] ? _objectSpread(_objectSpread({}, files[fileId]), {}, {
+      data: Filerobot.uploadFilesData[fileId]
+    }) : undefined;
+  });
+});
+export var selectUploadsCount = function selectUploadsCount(state) {
+  return Object.keys(selectUploads(state)).length;
+};
+export var selectIsNewUploadAllowed = function selectIsNewUploadAllowed(state, maxNumberOfFiles) {
+  if (!maxNumberOfFiles) {
+    return true;
+  }
+  var files = selectUploadsArray(state);
+  var allowNewUploadByDefault = selectUploadCapabilities(state, 'allowNewUpload');
+  return allowNewUploadByDefault && files.length < maxNumberOfFiles;
+};
+export default uploadsSlice.reducer;