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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
import { PLUGINS_IDS } from '@filerobot/utils/lib/constants';
import { createSlice } from '@reduxjs/toolkit';
import createThunk from '@filerobot/utils/lib/createThunk';
import { addNewFolder, deleteFolders, fetchFolders, moveFolders, renameFolder, selectBaseFolderPath, selectCurrentFolderPath } from './folders.slice';
import { extractFolderTreeSlice, getNormalizedFoldersSlicesByUuids, getParentFolderPath, getSortedFoldersUuids } from '../components/FoldersView/FoldersTree/FoldersTree.utils';
import { SORT_BY, SORT_ORDER } from '../components/common/Sort/Sort.constants';
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
        })
      });
    },
    foldersTreeFoldersAdded: function foldersTreeFoldersAdded(state, action) {
      var _folders$, _action$payload$paren, _action$payload$paren2;
      var folders = Array.isArray(action.payload.folders) ? action.payload.folders : [action.payload.folders];
      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 loadedFolders = allLoadedFolders;
      var parentUuid = (_action$payload$paren = (_action$payload$paren2 = action.payload.parentFolder) === null || _action$payload$paren2 === void 0 ? void 0 : _action$payload$paren2.uuid) !== null && _action$payload$paren !== void 0 ? _action$payload$paren : !parentFolderPath // means it's directly under the root folder.
      ? baseFolderUuid : Object.keys(loadedFolders).find(function (uuid) {
        return loadedFolders[uuid].path === parentFolderPath;
      });
      var _getNormalizedFolders4 = getNormalizedFoldersSlicesByUuids(folders, parentUuid),
        normalizedFoldersSlices = _getNormalizedFolders4.normalizedFoldersSlices,
        uuids = _getNormalizedFolders4.uuids;
      var newFoldersEntities = _objectSpread(_objectSpread({}, allLoadedFolders), normalizedFoldersSlices);
      var addedRootFoldersUuids = [];
      var isRootFolder = parentUuid === baseFolderUuid;
      if (isRootFolder) {
        addedRootFoldersUuids.push.apply(addedRootFoldersUuids, _toConsumableArray(uuids));
      } else if (newFoldersEntities[parentUuid]) {
        // 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(newFoldersEntities[parentUuid].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) {
        var folder = _objectSpread({}, newLoadedFolders[folderUuid]);
        if (folder) {
          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;
            });
            return;
          }
          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: action.payload.allLoadedFolders,
        loading: false,
        error: null
      });
    }).addCase(bubbleFetchFoldersTree.rejected, function (state, action) {
      return _objectSpread(_objectSpread({}, state), {}, {
        loading: false,
        error: action.error
      });
    }).addCase(recursivelyFetchFoldersTree.fulfilled, function (state, action) {
      return foldersTreeSlice.caseReducers.foldersTreeFoldersAdded(state, action);
    }).addCase(addNewFolder.fulfilled, function (state, action) {
      return foldersTreeSlice.caseReducers.foldersTreeFoldersAdded(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.foldersTreeFoldersAdded).addCase(fetchFolderChildrenInTreeByUuid.rejected, function (state, action) {
      return foldersTreeSlice.caseReducers.foldersTreeFolderUpdated(state, {
        payload: {
          uuid: action.payload,
          loading: false,
          error: action.error
        }
      });
    }).addCase(deleteFolders.fulfilled, function (state, action) {
      return foldersTreeSlice.caseReducers.foldersTreeFoldersRemoved(state, action);
    });
  }
});
var _foldersTreeSlice$act = foldersTreeSlice.actions,
  foldersTreeFolderUpdated = _foldersTreeSlice$act.foldersTreeFolderUpdated,
  foldersTreeFoldersAdded = _foldersTreeSlice$act.foldersTreeFoldersAdded,
  foldersTreeFoldersRemoved = _foldersTreeSlice$act.foldersTreeFoldersRemoved,
  foldersTreeFoldersMoved = _foldersTreeSlice$act.foldersTreeFoldersMoved,
  foldersTreeFolderRenamed = _foldersTreeSlice$act.foldersTreeFolderRenamed,
  foldersTreeAllFoldersCollapsed = _foldersTreeSlice$act.foldersTreeAllFoldersCollapsed,
  foldersTreeSortingUpdated = _foldersTreeSlice$act.foldersTreeSortingUpdated;
export { foldersTreeFolderUpdated, foldersTreeFoldersAdded, foldersTreeFoldersRemoved, foldersTreeFoldersMoved, foldersTreeFolderRenamed, foldersTreeAllFoldersCollapsed, foldersTreeSortingUpdated };
var selectFoldersTreeState = function selectFoldersTreeState(state) {
  return state[PLUGINS_IDS.EXPLORER][slicePropName];
};
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;
};
export var selectFolderTreeFolderByUuid = function selectFolderTreeFolderByUuid(state, uuid) {
  return selectFoldersTreeLoadedFolders(state)[uuid] || {};
};
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;