@scaleflex/widget-explorer 4.3.0 → 4.4.0

package/lib/slices/foldersTree.slice.js

@@ -1,501 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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;