@scaleflex/widget-explorer 4.5.0 → 4.5.4

package/lib/slices/collections.slice.js

@@ -0,0 +1,714 @@
+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 { createSelector, createSlice, isAnyOf } from '@reduxjs/toolkit';
+import { PLUGINS_IDS, VIEW_IDS, FMAW_URL_QUERY_PARAMS } from '@scaleflex/widget-utils/lib/constants';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import escapeRegExp from '@scaleflex/widget-utils/lib/escapeRegExp';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import { filesRemoved, selectFilesOffset } from './files.slice';
+import { changeView, changeViewFetchFilesCachedQueries, resetSearchAndFiltersMode, searchOrListViewFiles, selectIsCollectionsView } from './views.slice';
+import { filterFolders } from '../components/CollectionsView/CollectionVirtualFoldersTree/CollectionVirtualFoldersTree.utils';
+import { COLLECTIONS_SORT_OPTIONS, SORT_ORDER } from '../components/common/Sort/Sort.constants';
+import { currentFolderUpdated } from './folders.slice';
+import { exactAndExtendedFilesRemoved } from './search.slice';
+var slicePropName = 'collections';
+var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+var initialState = {
+  uuids: [],
+  entities: {},
+  activeUuid: null,
+  searchTerm: '',
+  selectedUuids: [],
+  sortOrder: SORT_ORDER.ASC,
+  sortedBy: null,
+  loading: true,
+  isSending: false,
+  isIntermediateVirtualFolder: false,
+  activeVirtualFolder: null,
+  isActiveVirtualFolderLoading: false,
+  showTree: true,
+  activeVirtualFolders: {},
+  activeVirtualFoldersPaths: [],
+  error: null
+};
+export var DEFAULT_COLLECTION_SORT = {
+  BY: COLLECTIONS_SORT_OPTIONS[0].value,
+  ORDER: SORT_ORDER.ASC
+};
+var compareCollectionsToSort = function compareCollectionsToSort(_ref) {
+  var _x$sortBy, _y$sortBy;
+  var sortOrder = _ref.sortOrder,
+    sortBy = _ref.sortBy,
+    aCollection = _ref.aCollection,
+    bCollection = _ref.bCollection;
+  var x = sortOrder === SORT_ORDER.ASC ? aCollection : bCollection;
+  var y = sortOrder === SORT_ORDER.ASC ? bCollection : aCollection;
+  var xValue = (_x$sortBy = x === null || x === void 0 ? void 0 : x[sortBy]) !== null && _x$sortBy !== void 0 ? _x$sortBy : '';
+  var yValue = (_y$sortBy = y === null || y === void 0 ? void 0 : y[sortBy]) !== null && _y$sortBy !== void 0 ? _y$sortBy : '';
+  if (!Number.isNaN(+xValue) && !Number.isNaN(+yValue)) return +xValue - +yValue;
+  if (!isNaN(new Date(xValue)) && !isNaN(new Date(yValue))) return yValue.toString().localeCompare(xValue);
+  return xValue.toString().localeCompare(yValue);
+};
+export var sortCollections = createThunk(function (_ref2, thunkApi) {
+  var sortBy = _ref2.sortBy,
+    sortOrder = _ref2.sortOrder;
+  // Creating new array as sorting is done in the same array reference.
+  var state = thunkApi.getState();
+  var collections = selectCollections(state);
+  var sortedCollectionUuids = _toConsumableArray(selectCollectionsUuids(state));
+  if (sortBy) {
+    sortedCollectionUuids.sort(function (aUuid, bUuid) {
+      var aCollection = collections[aUuid];
+      var bCollection = collections[bUuid];
+      return compareCollectionsToSort({
+        sortBy: sortBy,
+        sortOrder: sortOrder,
+        aCollection: aCollection,
+        bCollection: bCollection
+      });
+    });
+    thunkApi.dispatch(collectionsSortingUpdated({
+      uuids: sortedCollectionUuids
+    }));
+  }
+});
+var getSortedCollections = function getSortedCollections(collectionsBeforeNormalization, sortBy, sortOrder) {
+  return _toConsumableArray(collectionsBeforeNormalization).sort(function (aCollection, bCollection) {
+    return compareCollectionsToSort({
+      sortBy: sortBy,
+      sortOrder: sortOrder,
+      aCollection: aCollection,
+      bCollection: bCollection
+    });
+  });
+};
+export var activateFirstCollection = createThunk(function (_, thunkApi) {
+  var _collections$;
+  var collections = selectCollectionsArray(thunkApi.getState());
+  return thunkApi.dispatch(activateCollection({
+    uuid: (_collections$ = collections[0]) === null || _collections$ === void 0 ? void 0 : _collections$.uuid
+  }));
+});
+export var activateCollection = createThunk(function () {
+  var _extra$filerobot$getP;
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    collectionUuid = _ref3.uuid,
+    refreshActiveCollection = _ref3.refreshActiveCollection;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState,
+    extra = thunkApi.extra;
+  var state = getState();
+  var currentActiveCollectionUuid = selectActiveCollectionUuid(state);
+  if (!collectionUuid || currentActiveCollectionUuid === collectionUuid && !refreshActiveCollection) return;
+  var isCollectionsViewNotActivated = !selectIsCollectionsView(state);
+  var requestToReturn;
+  if (isCollectionsViewNotActivated) {
+    requestToReturn = dispatch(activateCollectionsView({
+      itemToOpen: collectionUuid
+    }));
+  } else {
+    requestToReturn = dispatch(fetchCollectionVirtualFolders({
+      collectionUuid: collectionUuid
+    }));
+  }
+  dispatch(collectionActivated(collectionUuid));
+  (_extra$filerobot$getP = extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _extra$filerobot$getP === void 0 ? void 0 : _extra$filerobot$getP.updateViewQueryInUrl({
+    viewItem: collectionUuid
+  });
+  return requestToReturn;
+});
+export var activateCollectionsView = createThunk(async function () {
+  var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    collectionUuidToActivate = _ref4.itemToOpen,
+    collectionFolderF64ToOpen = _ref4.subItemToOpen,
+    _ref4$skipViewDispatc = _ref4.skipViewDispatch,
+    skipViewDispatch = _ref4$skipViewDispatc === void 0 ? false : _ref4$skipViewDispatc,
+    _ref4$skipFetch = _ref4.skipFetch,
+    skipFetch = _ref4$skipFetch === void 0 ? false : _ref4$skipFetch,
+    _ref4$keepFiltersAndS = _ref4.keepFiltersAndSearch,
+    keepFiltersAndSearch = _ref4$keepFiltersAndS === void 0 ? false : _ref4$keepFiltersAndS,
+    _ref4$fromUrl = _ref4.fromUrl,
+    fromUrl = _ref4$fromUrl === void 0 ? false : _ref4$fromUrl;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState,
+    extra = thunkApi.extra;
+  var _extra$filerobot = extra.filerobot,
+    info = _extra$filerobot.info,
+    i18n = _extra$filerobot.i18n;
+  if (!skipViewDispatch) dispatch(changeView({
+    view: VIEW_IDS.COLLECTIONS,
+    keepFiltersAndSearch: keepFiltersAndSearch,
+    fromUrl: fromUrl
+  }));
+  dispatch(collectionsStateReset());
+  dispatch(currentFolderUpdated({}));
+  dispatch(filesRemoved());
+  dispatch(exactAndExtendedFilesRemoved([]));
+  var collections = skipFetch ? selectCollectionsArray(getState()) : await dispatch(fetchCollections()).throwRejection();
+  var firstCollection = (collections || [])[0] || {};
+  var collectionUuid = collectionUuidToActivate || firstCollection.uuid;
+  if (!collectionUuid) return;
+  if (collectionUuidToActivate && !selectCollectionByUuid(getState(), collectionUuidToActivate)) {
+    info(i18n('collectionsDefaultCollectionError'), 'error', 3000);
+    thunkApi.dispatch(collectionsStateUpdated({
+      error: {
+        message: i18n('collectionsDefaultCollectionError'),
+        details: i18n('collectionsDefaultCollectionErrorDescription')
+      }
+    }));
+    return;
+  }
+  var requestToReturn = dispatch(activateCollection({
+    uuid: collectionUuid
+  }));
+  if (collectionFolderF64ToOpen) {
+    // We are waiting the activateCollection to finish to make sure we are fetching the files of the opened virtual folder
+    // cause we need to have the opened/passed virtual folder data from the API that's why we are waiting.
+    await requestToReturn;
+    requestToReturn = dispatch(fetchCollectionsFiles({
+      collectionUuid: collectionUuid,
+      folder: {
+        filters: collectionFolderF64ToOpen
+      },
+      offset: 0
+    }));
+  }
+  return requestToReturn;
+});
+export var toggleCollectionsTree = createThunk(function (showTree, thunkApi) {
+  var newValue = showTree !== null && showTree !== void 0 ? showTree : !selectIsCollectionTreeOpened(thunkApi.getState());
+  thunkApi.dispatch(collectionsStateUpdated({
+    showTree: newValue
+  }));
+  thunkApi.extra.filerobot.emit('collections-tree-trigger', newValue);
+  return newValue;
+});
+export var fetchCollections = createThunk(async function () {
+  var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    avoidCollectionsUpdate = _ref5.avoidCollectionsUpdate;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var sortBy = DEFAULT_COLLECTION_SORT.BY,
+    sortOrder = DEFAULT_COLLECTION_SORT.ORDER;
+  var _await$thunkApi$extra = await thunkApi.extra.apiClient.get('collections', {
+      id: 'listCollections',
+      abortSignal: thunkApi.signal
+    }),
+    collections = _await$thunkApi$extra.collections;
+  var sortedCollections = collections ? getSortedCollections(collections, sortBy, sortOrder) : [];
+  if (!avoidCollectionsUpdate) {
+    thunkApi.dispatch(collectionsReplaced(sortedCollections));
+  }
+  return sortedCollections;
+}, {
+  actionType: "".concat(sliceName, "/fetchCollections")
+});
+export var fetchCollectionVirtualFolders = createThunk(async function () {
+  var _filerobot$getPlugin;
+  var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    avoidCollectionVirtualUpdate = _ref6.avoidCollectionVirtualUpdate,
+    collectionUuid = _ref6.collectionUuid;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    _thunkApi$extra = thunkApi.extra,
+    apiClient = _thunkApi$extra.apiClient,
+    filerobot = _thunkApi$extra.filerobot,
+    getState = thunkApi.getState;
+  var state = getState();
+  var activeCollectionUuid = collectionUuid || selectActiveCollectionUuid(state);
+  dispatch(resetSearchAndFiltersMode());
+  dispatch(collectionActivated(activeCollectionUuid));
+  (_filerobot$getPlugin = filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _filerobot$getPlugin === void 0 ? void 0 : _filerobot$getPlugin.updateViewQueryInUrl({
+    viewItem: activeCollectionUuid
+  });
+  var _await$apiClient$get = await apiClient.get("collections/".concat(activeCollectionUuid, "/folders"), {
+      id: 'listCollectionVirtualFolders',
+      abortSignal: thunkApi.signal
+    }),
+    _await$apiClient$get$ = _await$apiClient$get.folders,
+    folders = _await$apiClient$get$ === void 0 ? [] : _await$apiClient$get$;
+
+  // TODO: (Remove this if fixed on BE)... Issue from backend, that error is being returned as a 200 response and inside folders object, solving it here till backend fix it.
+  if (folders.status === 'error') {
+    filerobot.info(folders.msg, 'error');
+    return thunkApi.rejectWithValue(folders.msg);
+  }
+  if (!avoidCollectionVirtualUpdate) {
+    thunkApi.dispatch(collectionVirtualFoldersReplaced(folders));
+  }
+  return folders;
+}, {
+  actionType: "".concat(sliceName, "/fetchCollectionVirtualFolders")
+});
+
+// export const createCollection = createThunk(
+//   async ({ collection = {} }, thunkApi) => {
+//     const { signal, dispatch, extra: { apiClient } } = thunkApi
+
+//     /** (Dima: I suppose it's same as for labels)
+//      * !TODO: Once we have the whole new label object returned in the backend request's response, we should return the addedLabel const...
+//      * then add a case for it in extraReducer to append that label to labels entities for enabling auto updating with no additional requests
+//      */
+//     const { collection: addedCollection = {} } = await apiClient.post('collections', { data: collection, abortSignal: signal })
+
+//     dispatch(collectionModalOpened({ show: false, collectionToEdit: null }))
+
+//     return addedCollection
+//   },
+//   { actionType: `${sliceName}/createCollection` }
+// )
+
+// export const updateCollectionByUuid = createThunk(
+//   async ({ collection } = {}, thunkApi) => {
+//     const { signal, dispatch, extra: { apiClient } } = thunkApi
+//     const { uuid: collectionUuid } = collection
+
+//     const { collection: updatedCollection } = await apiClient.put(
+//       `collections/${collectionUuid}`,
+//       { data: collection, abortSignal: signal }
+//     )
+
+//     dispatch(collectionModalOpened({ show: false, collectionToEdit: null }))
+
+//     return updatedCollection
+//   },
+//   { actionType: `${sliceName}/updateCollectionByUuid` }
+// )
+
+export var deleteCollections = createThunk(async function () {
+  var collectionsUuids = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var signal = thunkApi.signal,
+    apiClient = thunkApi.extra.apiClient;
+  collectionsUuids.length === 1 ? await apiClient["delete"]("collections/".concat(collectionsUuids[0]), {
+    abortSignal: signal
+  }) : await apiClient["delete"]('collections', {
+    data: {
+      collections_uuids: collectionsUuids
+    },
+    abortSignal: signal
+  });
+
+  // Deactivate collection if it was deleted + remove all previously active collection files + remove URL query param
+  var activeCollectionUuid = selectActiveCollectionUuid(thunkApi.getState());
+  if (activeCollectionUuid && collectionsUuids.includes(activeCollectionUuid)) {
+    var _thunkApi$extra$filer;
+    thunkApi.dispatch(filesRemoved());
+    thunkApi.dispatch(exactAndExtendedFilesRemoved([]));
+    thunkApi.dispatch(collectionActivated(null));
+    (_thunkApi$extra$filer = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _thunkApi$extra$filer === void 0 ? void 0 : _thunkApi$extra$filer.deleteUrlQueryParams([FMAW_URL_QUERY_PARAMS.VIEW_ITEM, FMAW_URL_QUERY_PARAMS.VIEW_SUB_ITEM]);
+    changeViewFetchFilesCachedQueries(null);
+  }
+  thunkApi.extra.filerobot.emit('objects-removed', collectionsUuids, 'collections');
+  return collectionsUuids;
+}, {
+  actionType: "".concat(sliceName, "/deleteCollections")
+});
+export var fetchCollectionsFiles = createThunk(async function () {
+  var _extra$filerobot$getP2;
+  var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    folder = _ref7.folder,
+    offset = _ref7.offset,
+    _ref7$collectionUuid = _ref7.collectionUuid,
+    collectionUuid = _ref7$collectionUuid === void 0 ? null : _ref7$collectionUuid,
+    sortBy = _ref7.sortBy,
+    sortOrder = _ref7.sortOrder;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState,
+    extra = thunkApi.extra;
+  var state = getState();
+  var currentActiveVirtualFolder = selectCollectionsActiveVirtualFolder(state);
+  var virtualFolder = folder || currentActiveVirtualFolder || {};
+  var filters = virtualFolder.filters;
+  var uuid = collectionUuid || selectActiveCollection(state).uuid;
+  var usedOffset = offset !== null && offset !== void 0 ? offset : selectFilesOffset(state);
+  if (!(currentActiveVirtualFolder !== null && currentActiveVirtualFolder !== void 0 && currentActiveVirtualFolder.path) || (currentActiveVirtualFolder === null || currentActiveVirtualFolder === void 0 ? void 0 : currentActiveVirtualFolder.path) !== (virtualFolder === null || virtualFolder === void 0 ? void 0 : virtualFolder.path)) {
+    dispatch(activeCollectionsVirtualFolderUpdated(virtualFolder));
+  }
+  if (!filters) return;
+  (_extra$filerobot$getP2 = extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _extra$filerobot$getP2 === void 0 ? void 0 : _extra$filerobot$getP2.updateViewQueryInUrl({
+    viewItem: uuid,
+    viewSubItem: filters
+  });
+  var result = await dispatch(searchOrListViewFiles({
+    cachedViewQueries: {
+      collection_uuid: uuid,
+      f64: filters,
+      recursive: true
+    },
+    offset: usedOffset,
+    replaceOldFiles: usedOffset === 0,
+    skipPendingDispatch: usedOffset > 0,
+    sorting: sortBy && sortOrder && [sortBy, sortOrder],
+    withStats: false
+  }));
+  return result;
+}, {
+  actionType: "".concat(sliceName, "/fetchCollectionsFiles")
+});
+var collectionsSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    collectionsAdded: function collectionsAdded(state, action) {
+      var newCollections = _objectSpread({}, state.entities);
+      var newUuids = _toConsumableArray(state.uuids);
+      action.payload.forEach(function (collection) {
+        newCollections[collection.uuid] = collection;
+        newUuids.push(collection.uuid);
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newCollections,
+        uuids: newUuids
+      });
+    },
+    collectionAdded: function collectionAdded(state, action) {
+      var newCollections = _objectSpread({}, state.entities);
+      var newUuids = _toConsumableArray(state.uuids);
+      var collection = action.payload;
+      newCollections[collection.uuid] = collection;
+      newUuids.push(collection.uuid);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newCollections,
+        uuids: newUuids
+      });
+    },
+    collectionUpdated: function collectionUpdated(state, action) {
+      var newCollections = _objectSpread({}, state.entities);
+      newCollections[action.payload.uuid] = _objectSpread(_objectSpread({}, newCollections[action.payload.uuid]), action.payload);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newCollections
+      });
+    },
+    collectionsRemoved: function collectionsRemoved(state, action) {
+      var collectionsUuids = action.payload;
+      var newCollections = _objectSpread({}, state.entities);
+      var newUuids = _toConsumableArray(state.uuids);
+      collectionsUuids.forEach(function (collectionUuid) {
+        var deletedCollectionIndex = newUuids.indexOf(collectionUuid);
+        delete newCollections[collectionUuid];
+        newUuids.splice(deletedCollectionIndex, 1);
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newCollections,
+        uuids: newUuids
+      });
+    },
+    collectionsReplaced: function collectionsReplaced(state, action) {
+      var newCollections = {};
+      var collectionsUuids = [];
+      action.payload.forEach(function (collection) {
+        newCollections[collection.uuid] = collection;
+        collectionsUuids.push(collection.uuid);
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newCollections,
+        uuids: collectionsUuids,
+        activeVirtualFolder: initialState.activeVirtualFolder,
+        activeUuid: initialState.activeUuid,
+        isIntermediateVirtualFolder: initialState.isIntermediateVirtualFolder,
+        activeVirtualFolders: initialState.activeVirtualFolders,
+        activeVirtualFoldersPaths: initialState.activeVirtualFoldersPaths
+      });
+    },
+    collectionVirtualFoldersReplaced: function collectionVirtualFoldersReplaced(state, action) {
+      if (!Array.isArray(action.payload)) {
+        return state;
+      }
+      var activeVirtualFolders = {};
+      var activeVirtualFoldersPaths = [];
+      action.payload.forEach(function (folder) {
+        activeVirtualFolders[folder.path] = folder;
+        activeVirtualFoldersPaths.push(folder.path);
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        activeVirtualFolders: activeVirtualFolders,
+        activeVirtualFoldersPaths: activeVirtualFoldersPaths,
+        isIntermediateVirtualFolder: true
+      });
+    },
+    collectionsSearchTermUpdated: function collectionsSearchTermUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        searchTerm: action.payload
+      });
+    },
+    collectionsSortingUpdated: function collectionsSortingUpdated(state, action) {
+      var _action$payload = action.payload,
+        _action$payload$sortB = _action$payload.sortBy,
+        sortBy = _action$payload$sortB === void 0 ? state.sortedBy : _action$payload$sortB,
+        _action$payload$order = _action$payload.order,
+        order = _action$payload$order === void 0 ? state.sortOrder : _action$payload$order,
+        uuids = _action$payload.uuids;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        sortedBy: sortBy,
+        sortOrder: order
+      }, uuids && {
+        uuids: uuids
+      });
+    },
+    collectionActivated: function collectionActivated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        activeUuid: action.payload,
+        activeVirtualFolder: null
+        // noMoreActiveCollectionsFiles: false // TODO: Do we need it? This state doesn't used.
+      });
+    },
+    collectionsSelected: function collectionsSelected(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        selectedUuids: action.payload
+      });
+    },
+    collectionsDeselected: function collectionsDeselected(state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        selectedUuids: initialState.selectedUuids
+      });
+    },
+    activeCollectionsVirtualFolderUpdated: function activeCollectionsVirtualFolderUpdated(state, action) {
+      var _action$payload2, _action$payload3, _Object$values;
+      var virtualFolder = !((_action$payload2 = action.payload) !== null && _action$payload2 !== void 0 && _action$payload2.path) && (_action$payload3 = action.payload) !== null && _action$payload3 !== void 0 && _action$payload3.filters ? (_Object$values = Object.values(state.activeVirtualFolders || {})) === null || _Object$values === void 0 ? void 0 : _Object$values.find(function () {
+        var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          filters = _ref8.filters;
+        return action.payload.filters === filters;
+      }) : action.payload;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        activeVirtualFolder: virtualFolder,
+        sortedBy: initialState.sortedBy,
+        sortOrder: initialState.sortOrder
+      });
+    },
+    allCollectionsSelected: function allCollectionsSelected(state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        selectedUuids: state.uuids
+      });
+    },
+    collectionsStateUpdated: function collectionsStateUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    },
+    collectionsStateReset: function collectionsStateReset(state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        activeUuid: null,
+        searchTerm: '',
+        selectedUuids: [],
+        sortOrder: SORT_ORDER.ASC,
+        sortedBy: null,
+        // loading: true,
+        isSending: false,
+        isIntermediateVirtualFolder: false,
+        activeVirtualFolder: null,
+        isActiveVirtualFolderLoading: false,
+        showTree: true,
+        activeVirtualFolders: {},
+        activeVirtualFoldersPaths: [],
+        error: null
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder
+    // .addCase(createCollection.fulfilled, (state, action) => (
+    //   collectionsSlice.caseReducers.collectionAdded(state, action)
+    // ))
+    .addCase(deleteCollections.fulfilled, function (state, action) {
+      return collectionsSlice.caseReducers.collectionsRemoved(state, action);
+    })
+    // .addCase(updateCollectionByUuid.fulfilled, (state, action) => (
+    //   collectionsSlice.caseReducers.collectionUpdated(state, action)
+    // ))
+    // .addCase(collectionModalOpened.type, (state) => (
+    //   collectionsSlice.caseReducers.collectionsDeselected(state)
+    // ))
+    .addCase(fetchCollectionVirtualFolders.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isActiveVirtualFolderLoading: true,
+        error: null,
+        isIntermediateVirtualFolder: true
+      });
+    }).addCase(fetchCollectionVirtualFolders.fulfilled, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isActiveVirtualFolderLoading: false,
+        isIntermediateVirtualFolder: true
+      });
+    }).addCase(fetchCollectionVirtualFolders.rejected, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isActiveVirtualFolderLoading: initialState.isActiveVirtualFolderLoading,
+        activeUuid: initialState.activeUuid,
+        isIntermediateVirtualFolder: initialState.isIntermediateVirtualFolder,
+        error: getActionErrorState(state, action, true)
+      });
+    }).addCase(fetchCollections.pending, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: true,
+        error: null
+      });
+    }).addCase(fetchCollections.rejected, function (state, action) {
+      return getActionErrorState(state, action);
+    }).addCase(fetchCollections.fulfilled, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: false,
+        error: null
+      });
+    }).addMatcher(isAnyOf(activeCollectionsVirtualFolderUpdated, collectionActivated), function (state) {
+      var _activeCollection$dat;
+      var entities = state.entities,
+        activeUuid = state.activeUuid,
+        activeVirtualFolder = state.activeVirtualFolder;
+      var activeCollection = entities[activeUuid];
+      if (!activeCollection) return;
+      var isIntermediateVirtualFolder = (((_activeCollection$dat = activeCollection.data) === null || _activeCollection$dat === void 0 ? void 0 : _activeCollection$dat.groupby) || []).length && !(activeVirtualFolder !== null && activeVirtualFolder !== void 0 && activeVirtualFolder.filters);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isIntermediateVirtualFolder: isIntermediateVirtualFolder
+      });
+    }).addMatcher(function (_ref9) {
+      var type = _ref9.type;
+      return type.startsWith(sliceName) && type.endsWith('/rejected');
+    }, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: false,
+        isActiveVirtualFolderLoading: false,
+        error: getActionErrorState(state, action, true)
+      });
+    });
+  }
+});
+var _collectionsSlice$act = collectionsSlice.actions,
+  collectionsAdded = _collectionsSlice$act.collectionsAdded,
+  collectionAdded = _collectionsSlice$act.collectionAdded,
+  collectionUpdated = _collectionsSlice$act.collectionUpdated,
+  collectionsRemoved = _collectionsSlice$act.collectionsRemoved,
+  collectionsReplaced = _collectionsSlice$act.collectionsReplaced,
+  collectionVirtualFoldersReplaced = _collectionsSlice$act.collectionVirtualFoldersReplaced,
+  collectionsSearchTermUpdated = _collectionsSlice$act.collectionsSearchTermUpdated,
+  collectionsSortingUpdated = _collectionsSlice$act.collectionsSortingUpdated,
+  collectionActivated = _collectionsSlice$act.collectionActivated,
+  collectionsSelected = _collectionsSlice$act.collectionsSelected,
+  activeCollectionsVirtualFolderUpdated = _collectionsSlice$act.activeCollectionsVirtualFolderUpdated,
+  collectionsDeselected = _collectionsSlice$act.collectionsDeselected,
+  singleCollectionUpdated = _collectionsSlice$act.singleCollectionUpdated,
+  allCollectionsSelected = _collectionsSlice$act.allCollectionsSelected,
+  collectionsStateUpdated = _collectionsSlice$act.collectionsStateUpdated,
+  collectionsStateReset = _collectionsSlice$act.collectionsStateReset;
+export { collectionsAdded, collectionAdded, collectionUpdated, collectionsRemoved, collectionsReplaced, collectionVirtualFoldersReplaced, collectionsSearchTermUpdated, collectionsSortingUpdated, collectionActivated, collectionsSelected, activeCollectionsVirtualFolderUpdated, collectionsDeselected, singleCollectionUpdated, allCollectionsSelected, collectionsStateUpdated, collectionsStateReset };
+export var selectCollectionsState = function selectCollectionsState(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 selectCollections = function selectCollections(state) {
+  return selectCollectionsState(state).entities;
+};
+export var selectCollectionsUuids = function selectCollectionsUuids(state) {
+  return selectCollectionsState(state).uuids;
+};
+export var selectCollectionsArray = function selectCollectionsArray(state) {
+  return Object.values(selectCollections(state));
+};
+export var selectCollectionByUuid = function selectCollectionByUuid(state, uuid) {
+  return selectCollections(state)[uuid];
+};
+export var selectActiveCollectionUuid = function selectActiveCollectionUuid(state) {
+  return selectCollectionsState(state).activeUuid;
+};
+export var selectActiveCollection = function selectActiveCollection(state) {
+  return selectCollectionByUuid(state, selectActiveCollectionUuid(state));
+};
+export var selectIsCollectionsLoading = function selectIsCollectionsLoading(state) {
+  return selectIsCollectionsView(state) && selectCollectionsState(state).loading;
+};
+export var selectCollectionsSearchTerm = function selectCollectionsSearchTerm(state) {
+  return selectCollectionsState(state).searchTerm;
+};
+export var selectSelectedCollectionsUuids = function selectSelectedCollectionsUuids(state) {
+  return selectCollectionsState(state).selectedUuids;
+};
+export var selectIsCollectionsActivated = function selectIsCollectionsActivated(state) {
+  return !!selectActiveCollectionUuid(state);
+};
+export var selectCollectionsActiveVirtualFolder = function selectCollectionsActiveVirtualFolder(state) {
+  return selectCollectionsState(state).activeVirtualFolder;
+};
+export var selectCollectionsActiveVirtualFolderChildren = function selectCollectionsActiveVirtualFolderChildren(state) {
+  var _selectCollectionsAct;
+  return (_selectCollectionsAct = selectCollectionsActiveVirtualFolder(state)) === null || _selectCollectionsAct === void 0 ? void 0 : _selectCollectionsAct.children;
+};
+export var selectIsCollectionTreeOpened = function selectIsCollectionTreeOpened(state) {
+  return selectCollectionsState(state).showTree;
+};
+export var selectIsIntermediateVirtualFolder = function selectIsIntermediateVirtualFolder(state) {
+  return selectCollectionsState(state).isIntermediateVirtualFolder;
+};
+export var selectIsActiveVirtualFolderLoading = function selectIsActiveVirtualFolderLoading(state) {
+  return selectCollectionsState(state).isActiveVirtualFolderLoading;
+};
+export var selectCollectionsActiveVirtualFolders = function selectCollectionsActiveVirtualFolders(state) {
+  return selectCollectionsState(state).activeVirtualFolders;
+};
+export var selectCollectionsActiveVirtualFoldersArray = function selectCollectionsActiveVirtualFoldersArray(state) {
+  return Object.values(selectCollectionsActiveVirtualFolders(state));
+};
+export var selectCollectionsActiveVirtualFolderByUuid = function selectCollectionsActiveVirtualFolderByUuid(state, uuid) {
+  return selectCollectionsActiveVirtualFolders(state)[uuid];
+};
+export var selectActiveCollectionsVirtualFoldersPaths = function selectActiveCollectionsVirtualFoldersPaths(state) {
+  return selectCollectionsState(state).activeVirtualFoldersPaths;
+};
+export var selectCollectionsSortBy = function selectCollectionsSortBy(state) {
+  return selectCollectionsState(state).sortedBy;
+};
+export var selectCollectionsSortOrder = function selectCollectionsSortOrder(state) {
+  return selectCollectionsState(state).sortOrder;
+};
+export var selectCollectionsError = function selectCollectionsError(state) {
+  return selectCollectionsState(state).error;
+};
+export var selectSelectedCollections = createSelector([selectCollections, selectSelectedCollectionsUuids], function (collections, selectedUuids) {
+  return selectedUuids.map(function (uuid) {
+    return collections[uuid];
+  });
+});
+export var selectIsAllCollectionsSelected = createSelector([selectSelectedCollectionsUuids, selectCollectionsUuids], function (selectedUuids, collectionsUuids) {
+  return selectedUuids.length > 0 && selectedUuids.length === collectionsUuids.length;
+});
+export var selectCollectionsUuidsBySearchTerm = createSelector([selectCollections, selectCollectionsUuids, function (_state, searchTerm) {
+  return searchTerm;
+}], function (collections, collectionsUuids, searchTerm) {
+  return !searchTerm ? _toConsumableArray(collectionsUuids) : _toConsumableArray(collectionsUuids).filter(function (collectionUuid) {
+    var _collections$collecti = collections[collectionUuid].title,
+      title = _collections$collecti === void 0 ? '' : _collections$collecti;
+    return new RegExp(escapeRegExp(searchTerm), 'i').test(title);
+  });
+});
+export var selectCollectionsFilteredVirtualFolders = createSelector([selectCollectionsActiveVirtualFoldersArray, function (_state, searchTerm) {
+  return searchTerm;
+}], function (virtualFolders, searchTerm) {
+  return !searchTerm ? virtualFolders : filterFolders(virtualFolders, searchTerm);
+});
+var sortFolders = function sortFolders() {
+  var folders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var sortBy = arguments.length > 1 ? arguments[1] : undefined;
+  var sortOrder = arguments.length > 2 ? arguments[2] : undefined;
+  if (sortBy) {
+    return _toConsumableArray(folders).sort(function (aFolder, bFolder) {
+      var _x$sortBy2, _y$sortBy2;
+      var x = sortOrder === SORT_ORDER.ASC ? aFolder : bFolder;
+      var y = sortOrder === SORT_ORDER.ASC ? bFolder : aFolder;
+      var xValue = (_x$sortBy2 = x === null || x === void 0 ? void 0 : x[sortBy]) !== null && _x$sortBy2 !== void 0 ? _x$sortBy2 : '';
+      var yValue = (_y$sortBy2 = y === null || y === void 0 ? void 0 : y[sortBy]) !== null && _y$sortBy2 !== void 0 ? _y$sortBy2 : '';
+      return xValue.toString().localeCompare(yValue);
+    });
+  }
+  return folders;
+};
+export var selectSortedCollectionsActiveVirtualFoldersArray = createSelector([selectCollectionsActiveVirtualFoldersArray, selectCollectionsSortBy, selectCollectionsSortOrder], sortFolders);
+export var selectCollectionsActiveVirtualFolderSortedChildren = createSelector([selectCollectionsActiveVirtualFolderChildren, selectCollectionsSortBy, selectCollectionsSortOrder], sortFolders);
+export default collectionsSlice.reducer;