@scaleflex/widget-explorer 0.0.1

package/lib/slices/folders.slice.js

@@ -0,0 +1,964 @@
+var _excluded = ["sortBy", "sortOrder", "fetchFiles", "replaceOldFolders"],
+  _excluded2 = ["path", "options", "limit", "offset", "withStats", "replaceOldFolders", "abortSignal", "skipDispatch", "skipPendingDispatch", "withPreviews"];
+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 _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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+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, createSelector, isAnyOf } from '@reduxjs/toolkit';
+import { PERMISSIONS, PLUGINS_IDS, VIEW_IDS, LAYOUTS_IDS, FMAW_URL_QUERY_PARAMS } from '@scaleflex/widget-utils/lib/constants';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import { generateUserKey } from '@scaleflex/widget-core/lib/slices/user.slice';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import getNormalizedItems from '@scaleflex/widget-utils/lib/getNormalizedItems';
+import { changeView, searchOrListViewFiles, selectIsFoldersView, selectIsSearchMode, selectViewLayout, viewChanged } from './views.slice';
+import { selectAllSelectedItemsCount, selectionsCleared } from './selections.slice';
+import { bubbleFetchFoldersTree, recursivelyFetchFoldersTree, selectFoldersTreeLoadedFolders } from './foldersTree.slice';
+import { DEFAULT_SORT_OPTION, SORT_ORDER } from '../components/common/Sort/Sort.constants';
+import { extractFolderTreeSlice } from '../components/FoldersView/FoldersTree/FoldersTree.utils';
+import getParentFolderPath from '../utils/getParentFolderPath';
+import { selectFilesSortedBy, selectFilesSortOrder } from './files.slice';
+
+/**
+ * The order of the code in slice file is:
+ *  1. getInitialState (*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 addedFolderExtraProps = {
+  loading: false,
+  error: null,
+  isFolder: true,
+  type: 'folder'
+};
+var slicePropName = 'folders';
+var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+var sliceNameWithSeparator = "".concat(sliceName, "/"); // we are using this instead of sliceName directly as it'll match the foldersTree reducers also as it starts with folders too, so we are adding the slash to make sure it's folders only.
+
+// Changed from object to function to always re-calculate the object on calling to have the latest value of referenced objects (sorting...etc if changed.
+var getInitialState = function getInitialState() {
+  return {
+    uuids: [],
+    entities: {},
+    baseFolderPath: '',
+    // loaded from backend (on having sass key of the user) if none, then added from opts otherwise '/' default is set
+    currentFolder: {},
+    // it should be the uuid only maybe and keep its object in the entities?
+    loading: true,
+    error: null,
+    showTree: true,
+    stats: {
+      loading: false,
+      totalFilesCount: 0,
+      totalFoldersCount: 0
+    },
+    offset: 0,
+    sortOrder: DEFAULT_SORT_OPTION.order,
+    sortedBy: DEFAULT_SORT_OPTION.by,
+    noMoreFolders: false,
+    isFetchFilesRecursively: false
+  };
+};
+export var activateFoldersView = createThunk(async function () {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    filesLimit = _ref.filesLimit,
+    _ref$itemToOpen = _ref.itemToOpen,
+    folderPathToOpen = _ref$itemToOpen === void 0 ? null : _ref$itemToOpen,
+    _ref$skipViewDispatch = _ref.skipViewDispatch,
+    skipViewDispatch = _ref$skipViewDispatch === void 0 ? false : _ref$skipViewDispatch,
+    _ref$keepFiltersAndSe = _ref.keepFiltersAndSearch,
+    keepFiltersAndSearch = _ref$keepFiltersAndSe === void 0 ? false : _ref$keepFiltersAndSe,
+    _ref$fromUrl = _ref.fromUrl,
+    fromUrl = _ref$fromUrl === void 0 ? false : _ref$fromUrl,
+    _ref$isRecursive = _ref.isRecursive,
+    isRecursive = _ref$isRecursive === void 0 ? false : _ref$isRecursive;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState;
+  var folderPath = folderPathToOpen || selectBaseFolderPath(getState());
+  if (!skipViewDispatch) {
+    dispatch(changeView({
+      view: VIEW_IDS.FOLDERS,
+      keepFiltersAndSearch: keepFiltersAndSearch,
+      fromUrl: fromUrl
+    }));
+  }
+  dispatch(bubbleFetchFoldersTree(folderPath));
+  if (isRecursive) {
+    dispatch(folderFilesRecursiveFetchUpdated({
+      isRecursive: isRecursive
+    }));
+  }
+  return dispatch(openFolderByPath({
+    folderPath: folderPath,
+    filesLimit: filesLimit,
+    dontFetchFoldersTree: true
+  }));
+});
+export var openBaseFolder = createThunk(function (_ref2, thunkApi) {
+  var _ref2$dontFetchFolder = _ref2.dontFetchFoldersTree,
+    dontFetchFoldersTree = _ref2$dontFetchFolder === void 0 ? true : _ref2$dontFetchFolder;
+  var baseFolderPath = selectBaseFolderPath(thunkApi.getState());
+  thunkApi.dispatch(openFolderByPath({
+    folderPath: baseFolderPath,
+    dontFetchFoldersTree: dontFetchFoldersTree
+  }));
+});
+export var toggleFoldersTree = createThunk(function (showTree, thunkApi) {
+  var newValue = showTree !== null && showTree !== void 0 ? showTree : !selectIsFoldersTreeOpened(thunkApi.getState());
+  thunkApi.dispatch(foldersStateUpdated({
+    showTree: newValue
+  }));
+  thunkApi.extra.filerobot.emit('folders-tree-trigger', newValue);
+  return newValue;
+});
+
+// // used in opening folders that expects to open a folder with a deep path (that its parents are not loaded/expanded/opened yet).
+// export const openFolderByPathWithBubbleFetch = createThunk((folderPath, thunkApi) => {
+//   thunkApi.dispatch(bubbleFetchFoldersTree(folderPath))
+//   return thunkApi.dispatch(openFolderByPath({ folderPath }))
+// })
+
+// if not `folderPath` then it will fetch the current opened folder.
+export var openFolderByPath = createThunk(function (_ref3, thunkApi) {
+  var _thunkApi$extra$filer;
+  var folderPath = _ref3.folderPath,
+    filesLimit = _ref3.filesLimit,
+    _ref3$dontFetchFolder = _ref3.dontFetchFoldersTree,
+    dontFetchFoldersTree = _ref3$dontFetchFolder === void 0 ? false : _ref3$dontFetchFolder,
+    _ref3$fetchFoldersTre = _ref3.fetchFoldersTreeInBubble,
+    fetchFoldersTreeInBubble = _ref3$fetchFoldersTre === void 0 ? false : _ref3$fetchFoldersTre;
+  var path = folderPath || selectCurrentFolderPath(thunkApi.getState());
+  var mutualArgs = {
+    path: path,
+    offset: 0,
+    withStats: true,
+    abortSignal: thunkApi.signal
+  };
+  thunkApi.dispatch(selectionsCleared());
+  if (!dontFetchFoldersTree) {
+    thunkApi.dispatch(fetchFoldersTreeInBubble ? bubbleFetchFoldersTree(path) : recursivelyFetchFoldersTree(mutualArgs));
+  }
+  // Cause sorted folders promise' response returns the folders results inside an array [foldersPromiseResult, ...] we're moving it outside of that array with keeping the promise's returned api.
+  var sortedFoldersPromise = thunkApi.dispatch(fetchSortedFolders(_objectSpread(_objectSpread({}, mutualArgs), {}, {
+    replaceOldFolders: true
+  })));
+  var foldersPromise = sortedFoldersPromise.throwRejection().then(function (_ref4) {
+    var _ref5 = _slicedToArray(_ref4, 1),
+      folders = _ref5[0];
+    return folders;
+  })["catch"](function () {});
+  // To copy the properties of the original promise eg. we will have (abort, requestId...etc.)
+  _extends(foldersPromise, sortedFoldersPromise);
+  var filesPromise = thunkApi.dispatch(fetchFolderFiles(_objectSpread(_objectSpread({}, mutualArgs), {}, {
+    skipPendingDispatch: false,
+    filesLimit: filesLimit
+  }))).throwRejection()["catch"](function () {});
+  (_thunkApi$extra$filer = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _thunkApi$extra$filer === void 0 ? void 0 : _thunkApi$extra$filer.updateViewQueryInUrl({
+    viewItem: path
+  });
+  return Promise.all([foldersPromise, filesPromise]);
+});
+export var fetchFolderFiles = createThunk(async function () {
+  var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    path = _ref6.path,
+    offset = _ref6.offset,
+    _ref6$skipPendingDisp = _ref6.skipPendingDispatch,
+    skipPendingDispatch = _ref6$skipPendingDisp === void 0 ? true : _ref6$skipPendingDisp,
+    _ref6$withStats = _ref6.withStats,
+    withStats = _ref6$withStats === void 0 ? false : _ref6$withStats,
+    filesLimit = _ref6.filesLimit,
+    sorting = _ref6.sorting,
+    _ref6$skipDispatch = _ref6.skipDispatch,
+    skipDispatch = _ref6$skipDispatch === void 0 ? false : _ref6$skipDispatch;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var state = thunkApi.getState();
+  var folderPath = path || selectCurrentFolderPath(state);
+  var isSearchMode = selectIsSearchMode(state);
+  if (isSearchMode) {
+    thunkApi.skipDispatch();
+  }
+  var _ref7 = (await thunkApi.dispatch(searchOrListViewFiles({
+      cachedViewQueries: {
+        folder: folderPath
+      },
+      offset: offset !== null && offset !== void 0 ? offset : 0,
+      skipPendingDispatch: skipPendingDispatch,
+      withStats: withStats,
+      limit: filesLimit,
+      sorting: sorting,
+      skipDispatch: skipDispatch,
+      applyActiveViewItemCheck: false // we are making sure we call the folder's files even before the folder is not set as current folder as its request isn't done yet
+    })).throwRejection()) || {},
+    _ref7$newOffset = _ref7.newOffset,
+    newOffset = _ref7$newOffset === void 0 ? 0 : _ref7$newOffset,
+    _ref7$noMoreFiles = _ref7.noMoreFiles,
+    noMoreFiles = _ref7$noMoreFiles === void 0 ? false : _ref7$noMoreFiles,
+    _ref7$files = _ref7.files,
+    files = _ref7$files === void 0 ? [] : _ref7$files,
+    _ref7$extendResult = _ref7.extendResult,
+    extendResult = _ref7$extendResult === void 0 ? {} : _ref7$extendResult;
+  if (isSearchMode && extendResult.folder) {
+    thunkApi.dispatch(currentFolderUpdated(extendResult.folder));
+  }
+  return {
+    offset: newOffset,
+    allFilesLoaded: noMoreFiles,
+    files: files
+  };
+});
+export var fetchFolderFilesWithRecursion = createThunk(function () {
+  var _thunkApi$extra$filer2;
+  var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    isRecursive = _ref8.isRecursive;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var state = thunkApi.getState();
+  var currentRecursiveState = selectIsFolderFilesRecursiveFetch(state);
+  if (isRecursive === currentRecursiveState) {
+    return;
+  }
+  thunkApi.dispatch(folderFilesRecursiveFetchUpdated({
+    isRecursive: isRecursive
+  }));
+  (_thunkApi$extra$filer2 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _thunkApi$extra$filer2 === void 0 ? void 0 : _thunkApi$extra$filer2.replaceUrlQueryParams({
+    params: _defineProperty({}, FMAW_URL_QUERY_PARAMS.VIEW_RECURSIVE, isRecursive ? 1 : 0)
+  });
+  return thunkApi.dispatch(fetchSortedFolders({
+    sortBy: selectFilesSortedBy(state),
+    sortOrder: selectFilesSortOrder(state),
+    fetchFiles: true,
+    replaceOldFolders: true,
+    skipPendingDispatch: false
+  }));
+});
+export var fetchSortedFolders = createThunk(async function (_ref9, thunkApi) {
+  var sortBy = _ref9.sortBy,
+    sortOrder = _ref9.sortOrder,
+    fetchFiles = _ref9.fetchFiles,
+    _ref9$replaceOldFolde = _ref9.replaceOldFolders,
+    replaceOldFolders = _ref9$replaceOldFolde === void 0 ? true : _ref9$replaceOldFolde,
+    rest = _objectWithoutProperties(_ref9, _excluded);
+  var dispatch = thunkApi.dispatch;
+  var state = thunkApi.getState();
+  var isRecursiveSearchMode = selectIsSearchMode(state) && selectIsFolderFilesRecursiveFetch(state);
+  var sorting;
+  if (sortBy && sortOrder) {
+    sorting = "".concat(sortBy, ":").concat(sortOrder);
+    dispatch(foldersSortingUpdated({
+      sortBy: sortBy,
+      order: sortOrder
+    }));
+  } else {
+    var _sortBy = selectFoldersSortedBy(state);
+    var _sortOrder = selectFoldersSortOrder(state);
+    sorting = "".concat(_sortBy, ":").concat(_sortOrder);
+  }
+  var promises = [];
+  if (!isRecursiveSearchMode) {
+    var foldersPromise = dispatch(fetchFolders(_objectSpread(_objectSpread({
+      replaceOldFolders: replaceOldFolders,
+      offset: replaceOldFolders === false ? undefined : 0,
+      withStats: true
+    }, rest), {}, {
+      path: rest.path || selectCurrentFolderPath(state),
+      sorting: sorting
+    }))).throwRejection();
+    promises.push(foldersPromise);
+  }
+  if (fetchFiles) {
+    var filesPromise = dispatch(fetchFolderFiles(_objectSpread(_objectSpread({
+      offset: 0,
+      withStats: true
+    }, rest), {}, {
+      skipPendingDispatch: false,
+      sorting: sorting
+    }))).throwRejection();
+    promises.push(filesPromise);
+  }
+  return Promise.all(promises);
+});
+export var fetchFoldersStats = createThunk(async function (_ref10, thunkApi) {
+  var fetchArgs = _ref10.fetchArgs;
+  var _ref11 = (await thunkApi.extra.apiClient.fetch('folders/stats', _objectSpread(_objectSpread({}, fetchArgs), {}, {
+      abortSignal: fetchArgs.abortSignal || thunkApi.signal,
+      noPagination: true,
+      noFormatAndSortParams: true,
+      noRecursiveParam: false
+    }))) || {},
+    _ref11$stats = _ref11.stats,
+    stats = _ref11$stats === void 0 ? {} : _ref11$stats;
+  return {
+    totalFilesCount: stats.approx_files_count,
+    totalFoldersCount: stats.approx_folders_count
+  };
+}, {
+  actionType: "".concat(sliceName, "/fetchFoldersStats")
+});
+export var fetchFolders = createThunk(async function (_ref12, thunkApi) {
+  var _ref13, _foldersResponse$base, _foldersResponse$info, _foldersResponse$stat, _foldersResponse$stat2, _foldersResponse$info2, _foldersResponse$info3;
+  var path = _ref12.path,
+    _ref12$options = _ref12.options,
+    options = _ref12$options === void 0 ? {} : _ref12$options,
+    limit = _ref12.limit,
+    offset = _ref12.offset,
+    _ref12$withStats = _ref12.withStats,
+    withStats = _ref12$withStats === void 0 ? false : _ref12$withStats,
+    _ref12$replaceOldFold = _ref12.replaceOldFolders,
+    replaceOldFolders = _ref12$replaceOldFold === void 0 ? false : _ref12$replaceOldFold,
+    _ref12$abortSignal = _ref12.abortSignal,
+    abortSignal = _ref12$abortSignal === void 0 ? null : _ref12$abortSignal,
+    _ref12$skipDispatch = _ref12.skipDispatch,
+    skipDispatch = _ref12$skipDispatch === void 0 ? false : _ref12$skipDispatch,
+    _ref12$skipPendingDis = _ref12.skipPendingDispatch,
+    skipPendingDispatch = _ref12$skipPendingDis === void 0 ? false : _ref12$skipPendingDis,
+    _ref12$withPreviews = _ref12.withPreviews,
+    withPreviews = _ref12$withPreviews === void 0 ? true : _ref12$withPreviews,
+    otherParams = _objectWithoutProperties(_ref12, _excluded2);
+  if (skipDispatch) {
+    thunkApi.skipDispatch();
+  } else if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  var i18n = thunkApi.extra.filerobot.i18n;
+  var _thunkApi$extra$filer3 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER).opts,
+    enableFoldersStatsApiRequest = _thunkApi$extra$filer3.enableFoldersStatsApiRequest,
+    isFastToken = _thunkApi$extra$filer3.isFastToken;
+  var explorerConfig = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER).opts.config;
+  var fetch = thunkApi.extra.apiClient.fetch;
+  var state = thunkApi.getState();
+  var viewLayout = selectViewLayout(state);
+  var usedOffset = offset !== null && offset !== void 0 ? offset : selectFoldersOffset(state);
+  var usedLimit = (_ref13 = limit || explorerConfig.foldersLimit) !== null && _ref13 !== void 0 ? _ref13 : 2000;
+  var requestAttrs = _objectSpread(_objectSpread(_objectSpread({
+    id: 'listFolders'
+  }, otherParams), options), {}, {
+    limit: usedLimit,
+    abortSignal: abortSignal || thunkApi.signal,
+    offset: usedOffset,
+    moreQueries: {
+      folder: path
+    },
+    noRecursiveParam: false
+  });
+  var selectedItemsCount = selectAllSelectedItemsCount(thunkApi.getState());
+  if ((replaceOldFolders || usedOffset === 0) && selectedItemsCount > 0) {
+    thunkApi.dispatch(selectionsCleared());
+  }
+  var foldersRequest = fetch('folders', requestAttrs);
+  if (enableFoldersStatsApiRequest && withStats) {
+    thunkApi.dispatch(fetchFoldersStats({
+      fetchArgs: _objectSpread(_objectSpread({}, requestAttrs), {}, {
+        id: 'foldersStats',
+        abortSignal: requestAttrs.abortSignal
+      })
+    }));
+  }
+  var foldersResponse = (await foldersRequest) || {};
+  var folders = (foldersResponse.folders || []).filter(function (folder) {
+    return (folder === null || folder === void 0 ? void 0 : folder.path) !== '/.internal';
+  });
+  var currentFolder = ((_foldersResponse$base = foldersResponse.base) === null || _foldersResponse$base === void 0 ? void 0 : _foldersResponse$base.path) === '/' ? _objectSpread(_objectSpread({}, foldersResponse.base), {}, {
+    name: i18n('mutualizedBaseFolderTitle')
+  }) : foldersResponse.base || {};
+  if (viewLayout === LAYOUTS_IDS.GRID && !isFastToken && withPreviews && folders.length > 0) {
+    thunkApi.dispatch(fetchFoldersPreviews({
+      uuids: [currentFolder.uuid].concat(_toConsumableArray(folders.map(function (_ref14) {
+        var uuid = _ref14.uuid;
+        return uuid;
+      }))),
+      abortSignal: requestAttrs.abortSignal
+    }));
+  }
+  return {
+    currentFolder: currentFolder,
+    folders: folders,
+    // Need to hide system folders but must be included in /list API response.
+    stats: withStats ? {
+      totalFilesCount: ((_foldersResponse$info = foldersResponse.info) === null || _foldersResponse$info === void 0 ? void 0 : _foldersResponse$info.total_files_count) || ((_foldersResponse$stat = foldersResponse.stats) === null || _foldersResponse$stat === void 0 ? void 0 : _foldersResponse$stat.approx_files_count),
+      totalFoldersCount: ((_foldersResponse$stat2 = foldersResponse.stats) === null || _foldersResponse$stat2 === void 0 ? void 0 : _foldersResponse$stat2.approx_folders_count) || ((_foldersResponse$info2 = foldersResponse.info) === null || _foldersResponse$info2 === void 0 ? void 0 : _foldersResponse$info2.total_dirs_count) || ((_foldersResponse$info3 = foldersResponse.info) === null || _foldersResponse$info3 === void 0 ? void 0 : _foldersResponse$info3.total_folders_count)
+    } : undefined,
+    replaceOldFolders: replaceOldFolders,
+    offset: usedOffset + usedLimit,
+    noMoreFolders: folders.length < usedLimit
+  };
+}, {
+  actionType: "".concat(sliceName, "/fetchFolders")
+});
+export var addNewFolder = createThunk(async function (_ref15, thunkApi) {
+  var path = _ref15.path,
+    name = _ref15.name,
+    _ref15$skipPendingDis = _ref15.skipPendingDispatch,
+    skipPendingDispatch = _ref15$skipPendingDis === void 0 ? true : _ref15$skipPendingDis;
+  if (skipPendingDispatch) thunkApi.skipPendingDispatch();
+  var state = thunkApi.getState();
+
+  // If no path is provided, then the folder will be created in the currentFolder folder.
+  var toFolderPath = path || selectCurrentFolderPath(state);
+  var _await$thunkApi$extra = await thunkApi.extra.apiClient.post('folders', {
+      data: {
+        name: "".concat(toFolderPath.trim(), "/").concat(name).replace('//', '/')
+      },
+      permissionToCheck: [PERMISSIONS.FOLDER_CREATE],
+      abortSignal: thunkApi.signal
+    }),
+    base = _await$thunkApi$extra.base,
+    _await$thunkApi$extra2 = _await$thunkApi$extra.folder,
+    folder = _await$thunkApi$extra2 === void 0 ? {} : _await$thunkApi$extra2;
+  return {
+    folder: folder,
+    parentFolder: base
+  };
+}, {
+  actionType: "".concat(sliceName, "/addNewFolder")
+});
+export var renameFolder = createThunk(async function (_ref16, thunkApi) {
+  var uuid = _ref16.uuid,
+    name = _ref16.name;
+  var response = await thunkApi.extra.apiClient.put("folder/".concat(uuid, "/name"), {
+    data: {
+      name: name
+    },
+    permissionToCheck: [PERMISSIONS.FOLDER_RENAME],
+    abortSignal: thunkApi.signal
+  });
+  return response.folder;
+}, {
+  actionType: "".concat(sliceName, "/updateFolderName")
+});
+export var updateFolderOwner = createThunk(function (_ref17, thunkApi) {
+  var uuid = _ref17.uuid,
+    userUuid = _ref17.userUuid;
+  return thunkApi.extra.apiClient.put("folders/".concat(uuid, "/owner"), {
+    data: {
+      user_uuid: userUuid
+    },
+    abortSignal: thunkApi.signal
+  });
+}, {
+  actionType: "".concat(sliceName, "/updateFolderOwner")
+});
+export var fetchFoldersPreviews = createThunk(async function (_ref18, thunkApi) {
+  var uuids = _ref18.uuids,
+    abortSignal = _ref18.abortSignal;
+  thunkApi.skipPendingDispatch();
+  var foldersUuids = uuids || selectFoldersUuids(thunkApi.getState());
+  var response = await thunkApi.extra.apiClient.post('folders/previews', {
+    data: {
+      folders: foldersUuids
+    },
+    abortSignal: abortSignal || thunkApi.signal,
+    avoidErrorMsg: true
+  });
+  return foldersUuids.map(function (uuid) {
+    return {
+      uuid: uuid,
+      previews: (response.folders[uuid] || []).slice(0, 3)
+    };
+  });
+}, {
+  actionType: "".concat(sliceName, "/updateFoldersPreviews")
+});
+export var searchFolders = createThunk(async function (_ref19, thunkApi) {
+  var folderPath = _ref19.folderPath,
+    query = _ref19.query,
+    _ref19$offset = _ref19.offset,
+    offset = _ref19$offset === void 0 ? 0 : _ref19$offset,
+    _ref19$limit = _ref19.limit,
+    limit = _ref19$limit === void 0 ? 500 : _ref19$limit,
+    _ref19$skipDispatch = _ref19.skipDispatch,
+    skipDispatch = _ref19$skipDispatch === void 0 ? false : _ref19$skipDispatch,
+    _ref19$sortBy = _ref19.sortBy,
+    sortBy = _ref19$sortBy === void 0 ? DEFAULT_SORT_OPTION.by : _ref19$sortBy,
+    _ref19$sortOrder = _ref19.sortOrder,
+    sortOrder = _ref19$sortOrder === void 0 ? SORT_ORDER.ASC : _ref19$sortOrder,
+    abortSignal = _ref19.abortSignal;
+  if (skipDispatch) {
+    thunkApi.skipDispatch();
+  }
+  var sorting = "".concat(sortBy, ":").concat(sortOrder);
+  var _await$thunkApi$extra3 = await thunkApi.extra.apiClient.fetch('folders', {
+      abortSignal: abortSignal || thunkApi.signal,
+      limit: limit,
+      offset: offset,
+      recursive: true,
+      sorting: sorting,
+      moreQueries: _objectSpread({
+        q: query
+      }, folderPath && {
+        folder: folderPath
+      })
+    }),
+    folders = _await$thunkApi$extra3.folders;
+  var updatedFolders = folders === null || folders === void 0 ? void 0 : folders.map(function (folder) {
+    return extractFolderTreeSlice(folder);
+  });
+  return updatedFolders;
+}, {
+  actionType: "".concat(sliceName, "/searchFolders")
+});
+export var moveFolders = createThunk(async function (_ref20, thunkApi) {
+  var _ref20$folderUuids = _ref20.folderUuids,
+    folderUuids = _ref20$folderUuids === void 0 ? [] : _ref20$folderUuids,
+    folderPath = _ref20.folderPath,
+    _ref20$skipPendingDis = _ref20.skipPendingDispatch,
+    skipPendingDispatch = _ref20$skipPendingDis === void 0 ? true : _ref20$skipPendingDis;
+  if (skipPendingDispatch) thunkApi.skipPendingDispatch();
+  var response = await thunkApi.extra.apiClient.post('folders', {
+    data: {
+      folders_uuids: folderUuids,
+      new_folder_name: folderPath
+    },
+    permissionToCheck: [PERMISSIONS.FOLDER_MOVE]
+  });
+  thunkApi.extra.filerobot.emit('folders-moved', folderUuids, folderPath);
+  return {
+    foldersUuids: response.folders.map(function (folder) {
+      return folder.uuid;
+    }),
+    toFolder: folderPath
+  };
+}, {
+  actionType: "".concat(sliceName, "/moveFolders")
+});
+export var deleteFolders = createThunk(async function () {
+  var uuids = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var response = await thunkApi.extra.apiClient["delete"]('folders', {
+    data: {
+      folders_uuids: uuids
+    },
+    permissionToCheck: [PERMISSIONS.FOLDER_DELETE]
+  });
+  thunkApi.extra.filerobot.emit('objects-removed', uuids, 'folders');
+  return response.folders_uuids;
+}, {
+  actionType: "".concat(sliceName, "/deleteFolders")
+});
+var foldersSlice = createSlice({
+  name: sliceName,
+  initialState: getInitialState(),
+  reducers: {
+    currentFolderUpdated: function currentFolderUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        currentFolder: action.payload
+      });
+    },
+    foldersAdded: function foldersAdded(state, action) {
+      var _action$payload = action.payload,
+        folders = _action$payload.folders,
+        currentFolder = _action$payload.currentFolder,
+        noMoreFolders = _action$payload.noMoreFolders,
+        offset = _action$payload.offset,
+        stats = _action$payload.stats,
+        parentFolder = _action$payload.parentFolder;
+      var currentOpenedFolder = currentFolder || state.currentFolder;
+      var baseFolderPath = state.baseFolderPath;
+      if (parentFolder !== null && parentFolder !== void 0 && parentFolder.uuid && currentOpenedFolder !== null && currentOpenedFolder !== void 0 && currentOpenedFolder.uuid && parentFolder.uuid !== currentOpenedFolder.uuid) {
+        return state;
+      }
+      var foldersToAdd = currentOpenedFolder ? folders.filter(function () {
+        var _ref21 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          path = _ref21.path;
+        return (getParentFolderPath(path) || baseFolderPath) === currentOpenedFolder.path;
+      }) : folders;
+      var _getNormalizedItems = getNormalizedItems(foldersToAdd, {
+          extraProps: addedFolderExtraProps
+        }),
+        normalizedSlices = _getNormalizedItems.normalizedSlices,
+        uuids = _getNormalizedItems.uuids;
+      var newFolders = _objectSpread(_objectSpread({}, state.entities), normalizedSlices);
+      var newUuids = [].concat(_toConsumableArray(state.uuids), _toConsumableArray(uuids));
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: newUuids,
+        entities: newFolders,
+        stats: stats || state.stats,
+        currentFolder: currentOpenedFolder,
+        noMoreFolders: noMoreFolders,
+        offset: offset !== null && offset !== void 0 ? offset : state.offset
+      });
+    },
+    foldersReplaced: function foldersReplaced(state, action) {
+      var _action$payload2 = action.payload,
+        folders = _action$payload2.folders,
+        currentFolder = _action$payload2.currentFolder,
+        noMoreFolders = _action$payload2.noMoreFolders,
+        _action$payload2$offs = _action$payload2.offset,
+        offset = _action$payload2$offs === void 0 ? 0 : _action$payload2$offs,
+        stats = _action$payload2.stats;
+      var newFolders = {};
+      var newUuids = [];
+      if (Array.isArray(folders)) {
+        var _getNormalizedItems2 = getNormalizedItems(folders, {
+            extraProps: addedFolderExtraProps
+          }),
+          normalizedSlices = _getNormalizedItems2.normalizedSlices,
+          uuids = _getNormalizedItems2.uuids;
+        newFolders = normalizedSlices;
+        newUuids = uuids;
+      } else {
+        newFolders = _objectSpread({}, folders);
+        newUuids = Object.keys(newFolders);
+        newUuids.forEach(function (uuid) {
+          newFolders[uuid] = _objectSpread(_objectSpread({}, newFolders[uuid]), addedFolderExtraProps);
+        });
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: newUuids,
+        entities: newFolders,
+        stats: stats || state.stats,
+        currentFolder: currentFolder || state.currentFolder,
+        offset: offset,
+        loading: false,
+        error: null,
+        noMoreFolders: noMoreFolders
+      });
+    },
+    foldersRemoved: function foldersRemoved(state, action) {
+      var removedFolderUuids = action.payload;
+      if (!removedFolderUuids) {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          entities: {},
+          stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+            totalFoldersCount: 0
+          })
+        });
+      }
+      var currentFolders = _objectSpread({}, state.entities);
+      var currentUuids = _toConsumableArray(state.uuids);
+      var isFolderRemoved = false;
+      removedFolderUuids.forEach(function (folderUuid) {
+        if (currentFolders[folderUuid]) {
+          delete currentFolders[folderUuid];
+          isFolderRemoved = true;
+          currentUuids.splice(currentUuids.indexOf(folderUuid), 1);
+        }
+      });
+      if (!isFolderRemoved) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: currentUuids,
+        entities: currentFolders,
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          totalFoldersCount: Math.max(0, state.stats.totalFoldersCount - removedFolderUuids.length)
+        })
+      });
+    },
+    folderUpdated: function folderUpdated(state, action) {
+      var folderUuid = action.payload.uuid;
+      var updatedFolders = _objectSpread({}, state.entities);
+      if (!updatedFolders[folderUuid]) {
+        return state;
+      }
+      updatedFolders[folderUuid] = _objectSpread(_objectSpread({}, state.entities[folderUuid]), action.payload);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: updatedFolders
+      });
+    },
+    foldersUpdated: function foldersUpdated(state, action) {
+      var _state$currentFolder;
+      var folders = action.payload;
+      var updatedFolders = _objectSpread({}, state.entities);
+      var currentFolderUuid = (_state$currentFolder = state.currentFolder) === null || _state$currentFolder === void 0 ? void 0 : _state$currentFolder.uuid;
+      var isFolderUpdated = false;
+      var updatedCurrentFolder = null;
+      folders.forEach(function (folder) {
+        if (updatedFolders[folder.uuid]) {
+          updatedFolders[folder.uuid] = _objectSpread(_objectSpread({}, state.entities[folder.uuid]), {}, {
+            // Those will get overridden if their values are assigned inside the filesUpdated
+            loading: false,
+            error: null
+          }, folder);
+          isFolderUpdated = true;
+        }
+        if (currentFolderUuid === folder.uuid) {
+          updatedCurrentFolder = _objectSpread(_objectSpread({}, state.currentFolder), folder);
+        }
+      });
+      if (!isFolderUpdated && !updatedCurrentFolder) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: updatedFolders
+      }, updatedCurrentFolder && {
+        currentFolder: updatedCurrentFolder
+      });
+    },
+    foldersStateUpdated: function foldersStateUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    },
+    foldersSortingUpdated: function foldersSortingUpdated(state, action) {
+      var _action$payload3 = action.payload,
+        _action$payload3$sort = _action$payload3.sortBy,
+        sortBy = _action$payload3$sort === void 0 ? state.sortedBy : _action$payload3$sort,
+        _action$payload3$orde = _action$payload3.order,
+        order = _action$payload3$orde === void 0 ? state.sortOrder : _action$payload3$orde;
+      var isTheSameSort = sortBy === state.sortedBy && order === state.sortOrder;
+      if (isTheSameSort) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        sortedBy: sortBy,
+        sortOrder: order
+      });
+    },
+    folderFilesRecursiveFetchUpdated: function folderFilesRecursiveFetchUpdated(state, action) {
+      var _action$payload4;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isFetchFilesRecursively: (_action$payload4 = action.payload) === null || _action$payload4 === void 0 ? void 0 : _action$payload4.isRecursive
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(fetchFolders.pending, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: [],
+        entities: {},
+        loading: true,
+        error: null
+      });
+    }).addCase(fetchFolders.fulfilled, function (state, action) {
+      return action.payload.replaceOldFolders ? foldersSlice.caseReducers.foldersReplaced(state, action) : foldersSlice.caseReducers.foldersAdded(state, action);
+    }).addCase(fetchFolders.rejected, function (state, action) {
+      return _objectSpread(_objectSpread({}, getActionErrorState(state, action)), {}, {
+        uuids: [],
+        entities: {}
+      });
+    }).addCase(searchFolders.fulfilled, function (state, action) {
+      return foldersSlice.caseReducers.foldersReplaced(state, action);
+    }).addCase(moveFolders.fulfilled, function (state, action) {
+      return foldersSlice.caseReducers.foldersRemoved(state, {
+        payload: action.payload.foldersUuids
+      });
+    }).addCase(deleteFolders.fulfilled, function (state, action) {
+      return foldersSlice.caseReducers.foldersRemoved(state, action);
+    }).addCase(addNewFolder.fulfilled, function (state, action) {
+      return foldersSlice.caseReducers.foldersAdded(state, {
+        payload: {
+          folders: [action.payload.folder],
+          parentFolder: action.payload.parentFolder
+        }
+      });
+    }).addCase(generateUserKey.fulfilled, function (state, action) {
+      // The allowed listing folders for the user
+      var _action$payload$secur = action.payload.securityData.list_scope,
+        listFolderScope = _action$payload$secur === void 0 ? [] : _action$payload$secur;
+      if (!(listFolderScope !== null && listFolderScope !== void 0 && listFolderScope[0]) || Array.isArray(listFolderScope) && listFolderScope.length > 1) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        baseFolderPath: listFolderScope[0].replace('/*', '') || '/'
+      });
+    }).addCase(fetchFoldersStats.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          totalFilesCount: 0,
+          totalFoldersCount: 0,
+          loading: true
+        })
+      });
+    }).addCase(fetchFoldersPreviews.fulfilled, function (state, action) {
+      return foldersSlice.caseReducers.foldersUpdated(state, action);
+    }).addCase(viewChanged.type, function (state) {
+      return _objectSpread(_objectSpread({}, getInitialState()), {}, {
+        baseFolderPath: state.baseFolderPath,
+        currentFolder: state.currentFolder,
+        showTree: state.showTree
+      });
+    }).addMatcher(isAnyOf(fetchFoldersStats.fulfilled, fetchFoldersStats.rejected), function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        stats: _objectSpread(_objectSpread(_objectSpread({}, state.stats), action.payload), {}, {
+          loading: false
+        })
+      });
+    }).addMatcher(function (_ref22) {
+      var type = _ref22.type;
+      return type.startsWith(sliceNameWithSeparator) && Boolean(type.match(/\/updateFolder.*\/pending/));
+    }, function (state, action) {
+      var _action$meta$arg, _action$meta$arg2;
+      return foldersSlice.caseReducers.folderUpdated(state, {
+        payload: {
+          uuid: ((_action$meta$arg = action.meta.arg) === null || _action$meta$arg === void 0 ? void 0 : _action$meta$arg.uuid) || ((_action$meta$arg2 = action.meta.arg) === null || _action$meta$arg2 === void 0 ? void 0 : _action$meta$arg2.folderUuid) || action.meta.arg,
+          loading: true,
+          error: null
+        }
+      });
+    }).addMatcher(function (_ref23) {
+      var type = _ref23.type;
+      return type.startsWith(sliceNameWithSeparator) && Boolean(type.match(/\/updateFolder.*\/fulfilled/));
+    }, function (state, action) {
+      return foldersSlice.caseReducers.folderUpdated(state, {
+        payload: _objectSpread(_objectSpread({}, action.payload), {}, {
+          loading: false,
+          error: null
+        })
+      });
+    }).addMatcher(function (_ref24) {
+      var type = _ref24.type;
+      return type.startsWith(sliceNameWithSeparator) && Boolean(type.match(/\/updateFolder.*\/rejected/));
+    }, function (state, action) {
+      var _action$meta$arg3, _action$meta$arg4;
+      return foldersSlice.caseReducers.folderUpdated(state, {
+        payload: {
+          uuid: ((_action$meta$arg3 = action.meta.arg) === null || _action$meta$arg3 === void 0 ? void 0 : _action$meta$arg3.uuid) || ((_action$meta$arg4 = action.meta.arg) === null || _action$meta$arg4 === void 0 ? void 0 : _action$meta$arg4.folderUuid) || action.meta.arg,
+          loading: false,
+          error: getActionErrorState(state, action, true)
+        }
+      });
+    });
+    // Does the same as updateFolder extraReducers, but for multiple folders, commented for now as it is not used but kept in-case of future usage.
+    // .addMatcher(
+    //   ({ type }) => type.startsWith(sliceNameWithSeparator) && Boolean(type.match(/\/updateFolders.*\/pending/)),
+    //   (state, action) => (
+    //     foldersSlice.caseReducers.foldersUpdated(state, {
+    //       payload: (action.meta.arg?.foldersUuids || action.meta.arg?.uuids || action.meta.arg || []).map((uuid) => ({
+    //         uuid, loading: true, error: null
+    //       }))
+    //     })
+    //   ))
+    // .addMatcher(
+    //   ({ type }) => type.startsWith(sliceNameWithSeparator) && Boolean(type.match(/\/updateFolders.*\/fulfilled/)),
+    //   (state, action) => (
+    //     action.payload.removeFolders
+    //       ? foldersSlice.caseReducers.foldersRemoved(state, { payload: action.payload.foldersUuids })
+    //       : foldersSlice.caseReducers.foldersUpdated(state, action)
+    //   ))
+    // .addMatcher(
+    //   ({ type }) => type.startsWith(sliceNameWithSeparator) && Boolean(type.match(/\/updateFolders.*\/rejected/)),
+    //   (state, action) => (
+    //     foldersSlice.caseReducers.foldersUpdated(state, {
+    //       payload: (action.meta.arg?.foldersUuids || action.meta.arg?.uuids || action.meta.arg || []).map((uuid) => ({
+    //         uuid, loading: false, error: getActionErrorState(state, action, true)
+    //       }))
+    //     })
+    //   ))
+  }
+});
+var _foldersSlice$actions = foldersSlice.actions,
+  foldersAdded = _foldersSlice$actions.foldersAdded,
+  foldersReplaced = _foldersSlice$actions.foldersReplaced,
+  foldersRemoved = _foldersSlice$actions.foldersRemoved,
+  foldersUpdated = _foldersSlice$actions.foldersUpdated,
+  folderUpdated = _foldersSlice$actions.folderUpdated,
+  foldersStateUpdated = _foldersSlice$actions.foldersStateUpdated,
+  foldersSortingUpdated = _foldersSlice$actions.foldersSortingUpdated,
+  currentFolderUpdated = _foldersSlice$actions.currentFolderUpdated,
+  folderFilesRecursiveFetchUpdated = _foldersSlice$actions.folderFilesRecursiveFetchUpdated;
+export { foldersAdded, foldersReplaced, foldersRemoved, foldersUpdated, folderUpdated, foldersStateUpdated, foldersSortingUpdated, currentFolderUpdated, folderFilesRecursiveFetchUpdated };
+export var selectFoldersState = function selectFoldersState(state) {
+  var _state$PLUGINS_IDS$EX;
+  return ((_state$PLUGINS_IDS$EX = state[PLUGINS_IDS.EXPLORER]) === null || _state$PLUGINS_IDS$EX === void 0 ? void 0 : _state$PLUGINS_IDS$EX[slicePropName]) || getInitialState();
+};
+export var selectFoldersUuids = function selectFoldersUuids(state) {
+  return selectFoldersState(state).uuids;
+};
+export var selectFolders = function selectFolders(state) {
+  return selectFoldersState(state).entities;
+};
+export var selectFoldersArray = createSelector(selectFolders, function (folders) {
+  return Object.values(folders);
+});
+export var selectFoldersStats = function selectFoldersStats(state) {
+  return selectFoldersState(state).stats;
+};
+export var selectFolderByUuid = function selectFolderByUuid(state, folderUuid) {
+  return selectFolders(state)[folderUuid] || selectCurrentFolderUuid(state) === folderUuid && selectCurrentFolder(state);
+};
+export var selectFolderByPath = function selectFolderByPath(state, folderPath) {
+  return Object.values(selectFolders(state)).find(function (_ref25) {
+    var path = _ref25.path;
+    return path === folderPath;
+  });
+};
+export var selectFoldersByUuids = createSelector([selectFolders, selectFoldersTreeLoadedFolders, function (_state) {
+  var folderUuids = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return folderUuids;
+}], function (folders, foldersTreeLoadedFolders, folderUuids) {
+  return folderUuids.map(function (folderUuid) {
+    return folders[folderUuid] || foldersTreeLoadedFolders[folderUuid];
+  });
+});
+export var selectFoldersOffset = function selectFoldersOffset(state) {
+  return selectFoldersState(state).offset;
+};
+export var selectCurrentFolder = function selectCurrentFolder(state) {
+  return selectFoldersState(state).currentFolder;
+};
+export var selectCurrentFolderUuid = function selectCurrentFolderUuid(state) {
+  var _selectFoldersState$c;
+  return (_selectFoldersState$c = selectFoldersState(state).currentFolder) === null || _selectFoldersState$c === void 0 ? void 0 : _selectFoldersState$c.uuid;
+};
+export var selectCurrentFolderPath = function selectCurrentFolderPath(state) {
+  var _selectFoldersState$c2;
+  return ((_selectFoldersState$c2 = selectFoldersState(state).currentFolder) === null || _selectFoldersState$c2 === void 0 ? void 0 : _selectFoldersState$c2.path) || selectBaseFolderPath(state);
+};
+export var selectIsFoldersLoading = function selectIsFoldersLoading(state) {
+  return selectIsFoldersView(state) && selectFoldersState(state).loading;
+};
+export var selectIsFolderExisted = function selectIsFolderExisted(state, folderUuid) {
+  return Boolean(selectFolderByUuid(state, folderUuid));
+};
+export var selectBaseFolderPath = function selectBaseFolderPath(state) {
+  return selectFoldersState(state).baseFolderPath;
+};
+export var selectTotalFoldersCount = function selectTotalFoldersCount(state) {
+  return selectFoldersState(state).totalFoldersCount;
+};
+export var selectIsFoldersTreeOpened = function selectIsFoldersTreeOpened(state) {
+  return selectFoldersState(state).showTree;
+};
+export var selectNoMoreFolders = function selectNoMoreFolders(state) {
+  return selectFoldersState(state).noMoreFolders;
+};
+export var selectOpenedFolders = createSelector([selectCurrentFolder, selectFoldersTreeLoadedFolders], function (currentFolder, allTreeFolders) {
+  var openedFolders = [];
+  var _retrieveFoldersTillBase = function retrieveFoldersTillBase(folderUuid) {
+    var folder = allTreeFolders[folderUuid];
+    if (!folder) {
+      return;
+    }
+    openedFolders.unshift(folder);
+    if (folder !== null && folder !== void 0 && folder.parentUuid) {
+      _retrieveFoldersTillBase(folder.parentUuid);
+    }
+  };
+  _retrieveFoldersTillBase(currentFolder.uuid);
+  return openedFolders;
+});
+export var selectFoldersSortedBy = function selectFoldersSortedBy(state) {
+  return selectFoldersState(state).sortedBy;
+};
+export var selectFoldersSortOrder = function selectFoldersSortOrder(state) {
+  return selectFoldersState(state).sortOrder;
+};
+export var selectFoldersError = function selectFoldersError(state) {
+  return selectFoldersState(state).error;
+};
+export var selectIsFoldersSortedAsc = function selectIsFoldersSortedAsc(state) {
+  return selectFoldersSortOrder(state) === SORT_ORDER.ASC;
+};
+
+// return undefined to make it proper to be used with (??) as possible to be false if the folders view enabled with local folder option.
+export var selectIsFolderFilesRecursiveFetch = function selectIsFolderFilesRecursiveFetch(state) {
+  return selectIsFoldersView(state) ? selectFoldersState(state).isFetchFilesRecursively : undefined;
+};
+export default foldersSlice.reducer;