@scaleflex/widget-explorer 0.0.1

package/lib/slices/foldersTree.slice.js

@@ -0,0 +1,501 @@
+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); }
+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; }
+import { PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import { createSlice } from '@reduxjs/toolkit';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import { addNewFolder, deleteFolders, fetchFolders, moveFolders, renameFolder, selectBaseFolderPath, selectCurrentFolderPath } from './folders.slice';
+import { extractFolderTreeSlice, getNormalizedFoldersSlicesByUuids, getSortedFoldersUuids } from '../components/FoldersView/FoldersTree/FoldersTree.utils';
+import { SORT_BY, SORT_ORDER } from '../components/common/Sort/Sort.constants';
+import getParentFolderPath from '../utils/getParentFolderPath';
+var slicePropName = 'foldersTree';
+var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+var initialState = {
+  baseFolderUuid: null,
+  rootFoldersUuids: [],
+  allLoadedFolders: {},
+  loading: true,
+  error: null,
+  sortedBy: SORT_BY.NAME,
+  isLoadTriggered: false,
+  sortOrder: SORT_ORDER.ASC
+};
+var foldersTreeLimit = 5000;
+export var recursivelyFetchFoldersTree = createThunk(async function (_ref, thunkApi) {
+  var path = _ref.path,
+    _ref$offset = _ref.offset,
+    offset = _ref$offset === void 0 ? 0 : _ref$offset,
+    abortSignal = _ref.abortSignal,
+    skipDispatch = _ref.skipDispatch;
+  if (skipDispatch) {
+    thunkApi.skipDispatch();
+  }
+  var state = thunkApi.getState();
+  var sortedBy = selectFoldersTreeSortBy(state);
+  var sortOrder = selectFoldersTreeSortOrder(state);
+  var sorting = "".concat(sortedBy, ":").concat(sortOrder);
+  var _ref2 = (await thunkApi.dispatch(fetchFolders({
+      path: path,
+      offset: offset,
+      sorting: sorting,
+      limit: foldersTreeLimit,
+      skipDispatch: true,
+      abortSignal: abortSignal,
+      id: undefined,
+      withPreviews: false
+    }))) || {},
+    _ref2$folders = _ref2.folders,
+    folders = _ref2$folders === void 0 ? [] : _ref2$folders,
+    _ref2$currentFolder = _ref2.currentFolder,
+    currentFolder = _ref2$currentFolder === void 0 ? {} : _ref2$currentFolder;
+  var fetchedFolders = folders.length >= foldersTreeLimit ? [].concat(_toConsumableArray(folders), _toConsumableArray((await thunkApi.dispatch(recursivelyFetchFoldersTree({
+    path: path,
+    offset: offset + foldersTreeLimit,
+    abortSignal: abortSignal,
+    skipDispatch: skipDispatch
+  }))).folders)) : folders;
+  return {
+    folders: fetchedFolders,
+    parentFolder: currentFolder
+  };
+}, {
+  actionType: "".concat(sliceName, "/recursivelyFetchFoldersTree")
+});
+
+// bubble is same concept as event bubbling in DOM, here we are fetching all the parent folders of the provided folder path in the tree, considering the tree's roots & base.
+// path or uuid
+export var bubbleFetchFoldersTree = createThunk(async function (folderPath, thunkApi) {
+  var _baseFolderResponse$p, _baseFolderResponse$p2;
+  var i18n = thunkApi.extra.filerobot.i18n;
+  var baseFolderPath = selectBaseFolderPath(thunkApi.getState());
+  var parentFoldersPaths = [baseFolderPath].concat(_toConsumableArray(folderPath.substr(folderPath.indexOf(baseFolderPath) + baseFolderPath.length).split('/').filter(Boolean)));
+  var lastPath = '';
+  var fetchRequests = parentFoldersPaths.map(function (path) {
+    lastPath = "".concat(lastPath, "/").concat(path).replace('//', '/');
+    var request = thunkApi.dispatch(recursivelyFetchFoldersTree({
+      skipDispatch: true,
+      path: lastPath,
+      abortSignal: thunkApi.signal
+    })).throwRejection();
+    return request;
+  });
+  var fetchResults = await Promise.allSettled(fetchRequests);
+  var baseFolderResponse = fetchResults[0];
+  if (baseFolderResponse.status === 'rejected') {
+    return thunkApi.rejectWithValue(baseFolderResponse.reason.message);
+  } else {
+    baseFolderResponse = baseFolderResponse.value;
+  }
+  var successResults = fetchResults.filter(function (_ref3) {
+    var status = _ref3.status;
+    return status === 'fulfilled';
+  }).map(function (_ref4) {
+    var value = _ref4.value;
+    return value;
+  });
+  var _getNormalizedFolders = getNormalizedFoldersSlicesByUuids(baseFolderResponse.folders, baseFolderResponse.parentFolder.uuid),
+    _getNormalizedFolders2 = _getNormalizedFolders.normalizedFoldersSlices,
+    normalizedFoldersSlices = _getNormalizedFolders2 === void 0 ? {} : _getNormalizedFolders2,
+    rootFoldersUuids = _getNormalizedFolders.uuids;
+  var baseFolder = extractFolderTreeSlice(_objectSpread(_objectSpread({}, baseFolderResponse.parentFolder), {}, {
+    name: ((_baseFolderResponse$p = baseFolderResponse.parentFolder) === null || _baseFolderResponse$p === void 0 ? void 0 : _baseFolderResponse$p.name) !== '/' && ((_baseFolderResponse$p2 = baseFolderResponse.parentFolder) === null || _baseFolderResponse$p2 === void 0 ? void 0 : _baseFolderResponse$p2.name) || i18n('mutualizedBaseFolderTitle')
+  }));
+  delete baseFolder.childrenUuids;
+  normalizedFoldersSlices[baseFolderResponse.parentFolder.uuid] = baseFolder;
+  var allLoadedFolders = successResults.slice(1).reduce(function (normalizedFolders, foldersResponse) {
+    var parentUuid = foldersResponse.parentFolder.uuid;
+    var _getNormalizedFolders3 = getNormalizedFoldersSlicesByUuids(foldersResponse.folders, parentUuid),
+      currentFoldersNormalized = _getNormalizedFolders3.normalizedFoldersSlices,
+      uuids = _getNormalizedFolders3.uuids;
+    return _objectSpread(_objectSpread(_objectSpread({}, normalizedFolders), currentFoldersNormalized), {}, _defineProperty({}, parentUuid, _objectSpread(_objectSpread({}, normalizedFolders[parentUuid]), {}, {
+      isExpanded: true,
+      isLoaded: true,
+      childrenUuids: uuids
+    })));
+  }, normalizedFoldersSlices);
+  return {
+    baseFolderUuid: baseFolder.uuid,
+    allLoadedFolders: allLoadedFolders,
+    rootFoldersUuids: rootFoldersUuids
+  };
+}, {
+  actionType: "".concat(sliceName, "/bubbleFetchFoldersTree")
+});
+export var fetchFolderChildrenInTreeByUuid = createThunk(async function (folderUuid, thunkApi) {
+  var folderPath = selectFolderTreeFolderByUuid(thunkApi.getState(), folderUuid).path;
+  var _await$thunkApi$dispa = await thunkApi.dispatch(recursivelyFetchFoldersTree({
+      path: folderPath,
+      skipDispatch: true,
+      offset: 0,
+      abortSignal: thunkApi.signal
+    })),
+    folders = _await$thunkApi$dispa.folders,
+    parentFolder = _await$thunkApi$dispa.parentFolder;
+  return {
+    folders: folders,
+    parentFolder: parentFolder
+  };
+}, {
+  actionType: "".concat(sliceName, "/fetchFolderChildrenInTreeByUuid")
+});
+export var updateFoldersTreeSort = createThunk(async function (_ref5, thunkApi) {
+  var sortedBy = _ref5.sortedBy,
+    sortOrder = _ref5.sortOrder;
+  var currentFolderPath = selectCurrentFolderPath(thunkApi.getState());
+  thunkApi.dispatch(foldersTreeSortingUpdated({
+    sortedBy: sortedBy,
+    sortOrder: sortOrder
+  }));
+  thunkApi.dispatch(bubbleFetchFoldersTree(currentFolderPath));
+});
+export var toggleFolderExpansion = createThunk(async function (folderUuid, thunkApi) {
+  var allLoadedFolders = selectFoldersTreeLoadedFolders(thunkApi.getState());
+  var folder = allLoadedFolders[folderUuid];
+  if (folder.loading) {
+    return;
+  }
+  if (folder.isLoaded) {
+    return thunkApi.dispatch(foldersTreeFolderUpdated({
+      uuid: folder.uuid,
+      isExpanded: !folder.isExpanded
+    }));
+  }
+  return thunkApi.dispatch(fetchFolderChildrenInTreeByUuid(folderUuid));
+});
+var foldersTreeSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    foldersTreeFolderUpdated: function foldersTreeFolderUpdated(state, action) {
+      var folderUuid = action.payload.uuid;
+      var folderUpdates = _objectSpread(_objectSpread({}, state.allLoadedFolders[folderUuid]), action.payload);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        allLoadedFolders: _objectSpread(_objectSpread({}, state.allLoadedFolders), {}, _defineProperty({}, folderUuid, extractFolderTreeSlice(folderUpdates)))
+      });
+    },
+    foldersTreeFolderRenamed: function foldersTreeFolderRenamed(state, action) {
+      var _action$payload = action.payload,
+        folderUuid = _action$payload.uuid,
+        folderPath = _action$payload.path;
+      var allLoadedFolders = state.allLoadedFolders,
+        sortOrder = state.sortOrder,
+        sortedBy = state.sortedBy,
+        rootFoldersUuids = state.rootFoldersUuids;
+      var parentFolderPath = getParentFolderPath(folderPath);
+      var folderUpdates = _objectSpread(_objectSpread({}, state.allLoadedFolders[folderUuid]), action.payload);
+      var newLoadedFolders = _objectSpread(_objectSpread({}, state.allLoadedFolders), {}, _defineProperty({}, folderUuid, extractFolderTreeSlice(folderUpdates)));
+
+      // If we have parent folder we sort its children else we sort the root folders
+      if (parentFolderPath) {
+        var parentFolderUuid = Object.keys(allLoadedFolders).find(function (uuid) {
+          return allLoadedFolders[uuid].path === parentFolderPath;
+        });
+        var parentFolder = allLoadedFolders[parentFolderUuid];
+        var sortedParentChildrenUuids = getSortedFoldersUuids({
+          allFolders: newLoadedFolders,
+          foldersUuidsToSort: _toConsumableArray(parentFolder === null || parentFolder === void 0 ? void 0 : parentFolder.childrenUuids),
+          sortedBy: sortedBy,
+          sortOrder: sortOrder
+        });
+        return _objectSpread(_objectSpread({}, state), {}, {
+          allLoadedFolders: _objectSpread(_objectSpread({}, newLoadedFolders), {}, _defineProperty({}, parentFolderUuid, _objectSpread(_objectSpread({}, parentFolder), {}, {
+            childrenUuids: sortedParentChildrenUuids
+          })))
+        });
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        allLoadedFolders: newLoadedFolders,
+        rootFoldersUuids: getSortedFoldersUuids({
+          foldersUuidsToSort: _toConsumableArray(rootFoldersUuids),
+          allFolders: newLoadedFolders,
+          sortedBy: sortedBy,
+          sortOrder: sortOrder
+        })
+      });
+    },
+    foldersTreeFoldersUpdated: function foldersTreeFoldersUpdated(state, action) {
+      var _folders$, _parentFolder$uuid;
+      var _ref6 = action.payload || {},
+        addableFolders = _ref6.folders,
+        parentFolder = _ref6.parentFolder,
+        _ref6$overwriteChildr = _ref6.overwriteChildren,
+        overwriteChildren = _ref6$overwriteChildr === void 0 ? false : _ref6$overwriteChildr,
+        _ref6$disregardChildr = _ref6.disregardChildren,
+        disregardChildren = _ref6$disregardChildr === void 0 ? false : _ref6$disregardChildr,
+        _ref6$noRootFolders = _ref6.noRootFolders,
+        noRootFolders = _ref6$noRootFolders === void 0 ? false : _ref6$noRootFolders;
+      var folders = Array.isArray(addableFolders) ? addableFolders : [addableFolders];
+      var sortOrder = state.sortOrder,
+        sortedBy = state.sortedBy,
+        allLoadedFolders = state.allLoadedFolders,
+        baseFolderUuid = state.baseFolderUuid;
+      var parentFolderPath = getParentFolderPath((_folders$ = folders[0]) === null || _folders$ === void 0 ? void 0 : _folders$.path);
+      var parentUuid = !disregardChildren && ((_parentFolder$uuid = parentFolder === null || parentFolder === void 0 ? void 0 : parentFolder.uuid) !== null && _parentFolder$uuid !== void 0 ? _parentFolder$uuid : !parentFolderPath // means it's directly under the root folder.
+      ? baseFolderUuid : Object.keys(allLoadedFolders).find(function (uuid) {
+        return allLoadedFolders[uuid].path === parentFolderPath;
+      }));
+      var _getNormalizedFolders4 = getNormalizedFoldersSlicesByUuids(folders, parentUuid),
+        normalizedFoldersSlices = _getNormalizedFolders4.normalizedFoldersSlices,
+        uuids = _getNormalizedFolders4.uuids;
+      var newFoldersEntities = _objectSpread(_objectSpread({}, allLoadedFolders), normalizedFoldersSlices);
+      var addedRootFoldersUuids = [];
+      var isRootFolder = !noRootFolders && parentUuid === baseFolderUuid;
+      if (isRootFolder) {
+        addedRootFoldersUuids.push.apply(addedRootFoldersUuids, _toConsumableArray(uuids));
+      } else if (!disregardChildren && newFoldersEntities[parentUuid]) {
+        var _newFoldersEntities$p;
+        // Setting the info/meta of the folder being opened`, as they don't get set in-case of fulfilled action as it calls this reducer.
+        newFoldersEntities[parentUuid] = _objectSpread(_objectSpread({}, allLoadedFolders[parentUuid]), {}, {
+          loading: false,
+          isExpanded: true,
+          isLoaded: true,
+          error: null,
+          childrenUuids: _toConsumableArray(new Set(_toConsumableArray(getSortedFoldersUuids({
+            sortedBy: sortedBy,
+            sortOrder: sortOrder,
+            allFolders: newFoldersEntities,
+            foldersUuidsToSort: [].concat(_toConsumableArray(overwriteChildren ? [] : ((_newFoldersEntities$p = newFoldersEntities[parentUuid]) === null || _newFoldersEntities$p === void 0 ? void 0 : _newFoldersEntities$p.childrenUuids) || []), _toConsumableArray(uuids))
+          }))))
+        });
+      }
+      var currentRootFoldersUuids = state.rootFoldersUuids;
+      var newRootFoldersUuids = addedRootFoldersUuids.length > 0 ? _toConsumableArray(new Set(_toConsumableArray(getSortedFoldersUuids({
+        sortedBy: sortedBy,
+        sortOrder: sortOrder,
+        allFolders: newFoldersEntities,
+        foldersUuidsToSort: [].concat(_toConsumableArray(currentRootFoldersUuids), addedRootFoldersUuids)
+      })))) : currentRootFoldersUuids;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        rootFoldersUuids: newRootFoldersUuids,
+        allLoadedFolders: newFoldersEntities
+      });
+    },
+    foldersTreeFoldersRemoved: function foldersTreeFoldersRemoved(state, action) {
+      var foldersUuids = Array.isArray(action.payload) ? action.payload : [action.payload];
+      var baseFolderUuid = state.baseFolderUuid;
+      var newFoldersEntities = _objectSpread({}, state.allLoadedFolders);
+      var newRootFoldersUuids = state.rootFoldersUuids;
+      foldersUuids.forEach(function (uuid) {
+        if (newFoldersEntities[uuid]) {
+          var parentUuid = newFoldersEntities[uuid].parentUuid;
+          var isRootFolder = parentUuid === baseFolderUuid;
+          delete newFoldersEntities[uuid];
+          if (isRootFolder) {
+            newRootFoldersUuids = newRootFoldersUuids.filter(function (rootUuid) {
+              return rootUuid !== uuid;
+            });
+            return;
+          }
+          if (newFoldersEntities[parentUuid]) {
+            newFoldersEntities[parentUuid] = _objectSpread(_objectSpread({}, newFoldersEntities[parentUuid]), {}, {
+              childrenUuids: newFoldersEntities[parentUuid].childrenUuids.filter(function (childUuid) {
+                return childUuid !== uuid;
+              })
+            });
+          }
+        }
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        rootFoldersUuids: newRootFoldersUuids,
+        allLoadedFolders: newFoldersEntities
+      });
+    },
+    foldersTreeFoldersMoved: function foldersTreeFoldersMoved(state, action) {
+      var _action$payload2 = action.payload,
+        foldersUuids = _action$payload2.foldersUuids,
+        toFolder = _action$payload2.toFolder;
+      var baseFolderUuid = state.baseFolderUuid,
+        allLoadedFolders = state.allLoadedFolders,
+        sortOrder = state.sortOrder,
+        sortedBy = state.sortedBy,
+        rootFoldersUuids = state.rootFoldersUuids;
+      var newLoadedFolders = _objectSpread({}, allLoadedFolders);
+      var newRootFoldersUuids = rootFoldersUuids;
+      foldersUuids.forEach(function (folderUuid) {
+        if (newLoadedFolders[folderUuid]) {
+          var folder = _objectSpread({}, newLoadedFolders[folderUuid]);
+          var oldParentUuid = folder.parentUuid;
+          folder.parentUuid = toFolder.uuid;
+          var folderLastPath = folder.path.lastIndexOf('/');
+          // if the toFolder has no name i.e only '/', we just keep the moved folder last path i.e /folderName
+          if (toFolder.path === '/') {
+            folder.path = folder.path.slice(folderLastPath);
+          } else {
+            folder.path = folder.path.replace(folder.path.slice(0, folderLastPath), toFolder.path);
+          }
+          newLoadedFolders[folderUuid] = folder;
+          if (oldParentUuid === baseFolderUuid) {
+            newRootFoldersUuids = newRootFoldersUuids.filter(function (uuid) {
+              return uuid !== folder.uuid;
+            });
+          } else {
+            var oldParentFolder = newLoadedFolders[oldParentUuid];
+            if (oldParentFolder) {
+              newLoadedFolders[oldParentUuid] = _objectSpread(_objectSpread({}, oldParentFolder), {}, {
+                childrenUuids: oldParentFolder.childrenUuids.filter(function (uuid) {
+                  return uuid !== folder.uuid;
+                })
+              });
+            }
+          }
+          var newParentFolder = newLoadedFolders[toFolder.uuid];
+          if (newParentFolder) {
+            if (newParentFolder.uuid === baseFolderUuid) {
+              newRootFoldersUuids = getSortedFoldersUuids({
+                sortedBy: sortedBy,
+                sortOrder: sortOrder,
+                allFolders: newLoadedFolders,
+                foldersUuidsToSort: [folderUuid].concat(_toConsumableArray(newRootFoldersUuids))
+              });
+            } else {
+              newLoadedFolders[toFolder.uuid] = _objectSpread(_objectSpread({}, newParentFolder), {}, {
+                childrenUuids: _toConsumableArray(new Set(_toConsumableArray(getSortedFoldersUuids({
+                  sortedBy: sortedBy,
+                  sortOrder: sortOrder,
+                  allFolders: newLoadedFolders,
+                  foldersUuidsToSort: [].concat(_toConsumableArray(newParentFolder.childrenUuids), [folderUuid])
+                }))))
+              });
+            }
+          }
+        }
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        allLoadedFolders: newLoadedFolders,
+        rootFoldersUuids: newRootFoldersUuids
+      });
+    },
+    foldersTreeAllFoldersCollapsed: function foldersTreeAllFoldersCollapsed(state) {
+      var newLoadedFolders = _objectSpread({}, state.allLoadedFolders);
+      var rootFoldersUuids = state.rootFoldersUuids;
+      rootFoldersUuids.forEach(function (uuid) {
+        newLoadedFolders[uuid] = _objectSpread(_objectSpread({}, newLoadedFolders[uuid]), {}, {
+          isExpanded: false
+        });
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        allLoadedFolders: newLoadedFolders
+      });
+    },
+    foldersTreeSortingUpdated: function foldersTreeSortingUpdated(state, action) {
+      var _action$payload3 = action.payload,
+        _action$payload3$sort = _action$payload3.sortedBy,
+        sortedBy = _action$payload3$sort === void 0 ? state.sortedBy : _action$payload3$sort,
+        _action$payload3$sort2 = _action$payload3.sortOrder,
+        sortOrder = _action$payload3$sort2 === void 0 ? state.sortOrder : _action$payload3$sort2;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        sortedBy: sortedBy,
+        sortOrder: sortOrder
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(bubbleFetchFoldersTree.pending, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isLoadTriggered: true,
+        loading: true,
+        error: null
+      });
+    }).addCase(bubbleFetchFoldersTree.fulfilled, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        baseFolderUuid: action.payload.baseFolderUuid,
+        rootFoldersUuids: action.payload.rootFoldersUuids,
+        allLoadedFolders: _objectSpread(_objectSpread({}, state.allLoadedFolders || {}), action.payload.allLoadedFolders),
+        loading: false,
+        error: null
+      });
+    }).addCase(bubbleFetchFoldersTree.rejected, function (state, action) {
+      return getActionErrorState(state, action);
+    }).addCase(recursivelyFetchFoldersTree.fulfilled, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFoldersUpdated(state, {
+        payload: _objectSpread(_objectSpread({}, action.payload), {}, {
+          overwriteChildren: true
+        })
+      });
+    }).addCase(addNewFolder.fulfilled, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFoldersUpdated(state, {
+        payload: {
+          parentFolder: action.payload.parentFolder,
+          folders: [action.payload.folder]
+        }
+      });
+    }).addCase(moveFolders.fulfilled, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFoldersMoved(state, action);
+    }).addCase(renameFolder.fulfilled, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFolderRenamed(state, action);
+    }).addCase(fetchFolderChildrenInTreeByUuid.pending, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFolderUpdated(state, {
+        payload: {
+          uuid: action.meta.arg,
+          loading: true,
+          error: null
+        }
+      });
+    }).addCase(fetchFolderChildrenInTreeByUuid.fulfilled, foldersTreeSlice.caseReducers.foldersTreeFoldersUpdated).addCase(fetchFolderChildrenInTreeByUuid.rejected, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFolderUpdated(state, {
+        payload: {
+          uuid: action.payload,
+          loading: false,
+          error: getActionErrorState(state, action, true)
+        }
+      });
+    }).addCase(deleteFolders.fulfilled, function (state, action) {
+      return foldersTreeSlice.caseReducers.foldersTreeFoldersRemoved(state, action);
+    });
+  }
+});
+var _foldersTreeSlice$act = foldersTreeSlice.actions,
+  foldersTreeFolderUpdated = _foldersTreeSlice$act.foldersTreeFolderUpdated,
+  foldersTreeFoldersUpdated = _foldersTreeSlice$act.foldersTreeFoldersUpdated,
+  foldersTreeFoldersRemoved = _foldersTreeSlice$act.foldersTreeFoldersRemoved,
+  foldersTreeFoldersMoved = _foldersTreeSlice$act.foldersTreeFoldersMoved,
+  foldersTreeFolderRenamed = _foldersTreeSlice$act.foldersTreeFolderRenamed,
+  foldersTreeAllFoldersCollapsed = _foldersTreeSlice$act.foldersTreeAllFoldersCollapsed,
+  foldersTreeSortingUpdated = _foldersTreeSlice$act.foldersTreeSortingUpdated;
+export { foldersTreeFolderUpdated, foldersTreeFoldersUpdated, foldersTreeFoldersRemoved, foldersTreeFoldersMoved, foldersTreeFolderRenamed, foldersTreeAllFoldersCollapsed, foldersTreeSortingUpdated };
+var selectFoldersTreeState = function selectFoldersTreeState(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]) || initialState;
+};
+export var selectFoldersTreeBaseFolderUuid = function selectFoldersTreeBaseFolderUuid(state) {
+  return selectFoldersTreeState(state).baseFolderUuid;
+};
+export var selectFoldersTreeRootsUuids = function selectFoldersTreeRootsUuids(state) {
+  return selectFoldersTreeState(state).rootFoldersUuids;
+};
+export var selectFoldersTreeLoadedFolders = function selectFoldersTreeLoadedFolders(state) {
+  return selectFoldersTreeState(state).allLoadedFolders;
+};
+var EMPTY_OBJECT = {};
+export var selectFolderTreeFolderByUuid = function selectFolderTreeFolderByUuid(state, uuid) {
+  return selectFoldersTreeLoadedFolders(state)[uuid] || EMPTY_OBJECT;
+};
+export var selectFoldersTreeBaseFolder = function selectFoldersTreeBaseFolder(state) {
+  return selectFolderTreeFolderByUuid(state, selectFoldersTreeBaseFolderUuid(state));
+};
+export var selectFoldersTreeLoading = function selectFoldersTreeLoading(state) {
+  return selectFoldersTreeState(state).loading;
+};
+export var selectFoldersTreeError = function selectFoldersTreeError(state) {
+  return selectFoldersTreeState(state).error;
+};
+export var selectFoldersTreeSortBy = function selectFoldersTreeSortBy(state) {
+  return selectFoldersTreeState(state).sortedBy;
+};
+export var selectFoldersTreeSortOrder = function selectFoldersTreeSortOrder(state) {
+  return selectFoldersTreeState(state).sortOrder;
+};
+export var selectFoldersTreeIsLoadTriggered = function selectFoldersTreeIsLoadTriggered(state) {
+  return selectFoldersTreeState(state).isLoadTriggered;
+};
+export default foldersTreeSlice.reducer;

package/lib/slices/index.js

@@ -0,0 +1,32 @@
+import { combineReducers } from '@reduxjs/toolkit';
+import common from './common.slice';
+import targets from './targets.slice';
+import panels from './panels.slice';
+import folders from './folders.slice';
+import files from './files.slice';
+import selections from './selections.slice';
+import metadata from './metadata.slice';
+import search from './search.slice';
+import topSection from './topSection.slice';
+import filters from './filters.slice';
+import views from './views.slice';
+import foldersTree from './foldersTree.slice';
+import drag from './drag.slice';
+
+// Any new slice is added, must be imported here.
+var explorerReducer = combineReducers({
+  common: common,
+  targets: targets,
+  views: views,
+  panels: panels,
+  folders: folders,
+  files: files,
+  selections: selections,
+  metadata: metadata,
+  search: search,
+  topSection: topSection,
+  filters: filters,
+  foldersTree: foldersTree,
+  drag: drag
+});
+export default explorerReducer;