@scaleflex/widget-explorer 0.0.1

package/lib/slices/files.slice.js

@@ -0,0 +1,1307 @@
+var _excluded = ["method"],
+  _excluded2 = ["recursive", "path", "noPagination"],
+  _excluded3 = ["requestProgress", "abortFunction", "sendStatsReq", "responseType", "headers", "replaceOldFiles"],
+  _excluded4 = ["addNotFound"];
+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 _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function _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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { createSlice, createSelector, isAnyOf } from '@reduxjs/toolkit';
+import { PLUGINS_IDS, PERMISSIONS, SEARCH_METHODS, REMOVE_BACKGROUND_ENDPOINT, REMOVE_BACKGROUND_LINK_PLACEHOLDER, FMAW_URL_QUERY_PARAMS, DESCRIBE_AI_SUPPORTED_LANGUAGES } from '@scaleflex/widget-utils/lib/constants';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import { selectUploads, selectUploadsIds } from '@scaleflex/widget-core/lib/slices/uploads.slice';
+import getFileLink from '@scaleflex/widget-utils/lib/getFileLink';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import getNormalizedItems from '@scaleflex/widget-utils/lib/getNormalizedItems';
+import copyText from '@scaleflex/widget-utils/lib/copyText';
+import prepareSearchUrl from '../utils/prepareSearchUrl';
+import { fileWindowUpdated, selectFileWindowFor, selectIsUploadsPanelOpened } from './panels.slice';
+import { selectAppliedFilters } from './filters.slice';
+import { exactAndExtendedFilesUpdated, searchFilesWithAiText, searchSimilarFiles, selectAllSearchFiles, selectAllSearchFilesUuids, selectExactSearchFileByUuid, selectExtendedSearchFileByUuid, selectIsAiSearch, selectIsExtendFetching, selectIsQuickFetching, selectSearchQuery, selectSearchSuggestionsFilters, selectSearchSuggestionsTags } from './search.slice';
+import { selectAllSelectedItemsCount, selectionsCleared } from './selections.slice';
+import { DEFAULT_SORT_OPTION, SORT_BY } from '../components/common/Sort/Sort.constants';
+import { selectIsSearchOrFiltersMode, selectIsSearchMode, selectIsFoldersView, viewChanged, selectIsAssetsView, viewCachedFetchFilesQueries, changeViewFetchFilesCachedQueries, selectActiveViewItem } from './views.slice';
+import { FILTER_SECTION_KEYS } from '../components/Filters/Filters.constants';
+import { selectCurrentFolderPath, selectIsFolderFilesRecursiveFetch } from './folders.slice';
+import decodeB64ToStr from '../utils/decodeB64ToStr';
+import { getMetaRegionalGroupsLanguagesApiValues } from '../components/metadata.adapter';
+import { selectActiveRegionalLang, selectIsCdnPermalinkEnabled, selectMetadataRegionalGroups } from './metadata.slice';
+import { adaptFiltersToBackendNotation } from '../utils/filters';
+
+/**
+ * The order of the code in slice file is:
+ *  1. initialState (*No* export needed)
+ *  2. automated thunks functions -- uses createThunk API-- (export needed)
+ *  3. createSlice (*No* export needed)
+ *  4. actions exports
+ *  5. selectors (export needed)
+ *  6. default reducer export
+ *
+ */
+var slicePropName = 'files';
+export var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+export var ACTION_TYPE = {
+  FETCH_FILES: "".concat(sliceName, "/fetchFiles"),
+  FETCH_FILES_STATS: "".concat(sliceName, "/fetchFilesStats")
+};
+
+// Changed from object to function to always re-calculate the object on calling to have the latest value of referenced objects (sorting...etc if changed.
+var getInitialState = function getInitialState() {
+  return {
+    uuids: [],
+    entities: {},
+    stats: {
+      loading: false,
+      filesCount: 0,
+      filesCountMethod: null,
+      filesSize: 0
+    },
+    tmpFile: null,
+    // used to show a file temporary from any place after fetching it for ex. (showing a file in file window if not existed in entities)
+    loading: true,
+    variations: {},
+    offset: 0,
+    noMoreFiles: false,
+    sortOrder: DEFAULT_SORT_OPTION.order,
+    sortedBy: DEFAULT_SORT_OPTION.by
+  };
+};
+export var getQueryForSearchAndFilters = function getQueryForSearchAndFilters(state) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$noSearch = _ref.noSearch,
+    noSearch = _ref$noSearch === void 0 ? false : _ref$noSearch,
+    _ref$noFilters = _ref.noFilters,
+    noFilters = _ref$noFilters === void 0 ? false : _ref$noFilters,
+    _ref$moreFilters = _ref.moreFilters,
+    moreFilters = _ref$moreFilters === void 0 ? {} : _ref$moreFilters,
+    _ref$filterKeysToDisr = _ref.filterKeysToDisregard,
+    filterKeysToDisregard = _ref$filterKeysToDisr === void 0 ? [] : _ref$filterKeysToDisr;
+  var searchSuggestionsFilters = selectSearchSuggestionsFilters(state);
+  var searchSuggestionsTags = selectSearchSuggestionsTags(state);
+  var searchQuery = selectSearchQuery(state);
+  // De-structuring to make it possible to delete filters.
+  var filters = _objectSpread(_objectSpread({}, moreFilters), selectAppliedFilters(state));
+  var queries = [];
+  if (!noSearch) {
+    queries.push.apply(queries, [searchQuery].concat(_toConsumableArray((searchSuggestionsFilters || []).map(function (filter) {
+      var _filter$value;
+      return "".concat(filter.key, ":\"").concat(((_filter$value = filter.value) === null || _filter$value === void 0 ? void 0 : _filter$value.sys_key) || filter.value, "\"");
+    })), _toConsumableArray((searchSuggestionsTags || []).map(function (tag) {
+      return tag.input;
+    }))));
+  }
+  if (!noFilters) {
+    if (Array.isArray(filterKeysToDisregard) && filterKeysToDisregard.length > 0) {
+      filterKeysToDisregard.forEach(function (filterKey) {
+        return delete filters[filterKey];
+      });
+    }
+    queries.push.apply(queries, _toConsumableArray(adaptFiltersToBackendNotation(filters)));
+  }
+  return queries.filter(Boolean).join(' ');
+};
+export var updateFiles = createThunk(function (_ref2, thunkApi) {
+  var _ref2$files = _ref2.files,
+    files = _ref2$files === void 0 ? [] : _ref2$files,
+    _ref2$addNotFoundSing = _ref2.addNotFoundSingleFile,
+    addNotFoundSingleFile = _ref2$addNotFoundSing === void 0 ? false : _ref2$addNotFoundSing;
+  var state = thunkApi.getState();
+  var isSearchMode = selectIsSearchMode(state);
+  if (isSearchMode) {
+    thunkApi.dispatch(exactAndExtendedFilesUpdated({
+      files: files
+    }));
+  } else if (Array.isArray(files) && files.length === 1 && addNotFoundSingleFile) {
+    var singleFile = files[0];
+    if (singleFile !== null && singleFile !== void 0 && singleFile.uuid) {
+      thunkApi.dispatch(fileUpdated(_objectSpread(_objectSpread({}, singleFile), {}, {
+        addNotFound: addNotFoundSingleFile
+      })));
+    }
+  } else {
+    thunkApi.dispatch(filesUpdated(files));
+  }
+});
+export var removeFilesBackground = createThunk(function () {
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    files = _ref3.files,
+    removeBackgroundFolder = _ref3.removeBackgroundFolder;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    _thunkApi$extra = thunkApi.extra,
+    apiClient = _thunkApi$extra.apiClient,
+    _thunkApi$extra$filer = _thunkApi$extra.filerobot,
+    opts = _thunkApi$extra$filer.opts,
+    info = _thunkApi$extra$filer.info;
+  var container = opts.container;
+  var _thunkApi$extra$filer2 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    i18n = _thunkApi$extra$filer2.i18n;
+  var isInternalFolder = removeBackgroundFolder === 'internal';
+  info(i18n('backgroundRemovedProcessingInfo'), 'success');
+  var updatedFiles = files.map(function (file) {
+    var uuid = file.uuid,
+      _file$folder = file.folder,
+      _file$folder2 = _file$folder === void 0 ? {} : _file$folder,
+      folderPath = _file$folder2.name;
+    var fileLink = getFileLink(file);
+    var endpointWithFileLink = REMOVE_BACKGROUND_ENDPOINT.replace(REMOVE_BACKGROUND_LINK_PLACEHOLDER, fileLink);
+    apiClient.get(endpointWithFileLink, {
+      checkOnlySuccessStatus: true,
+      headers: _objectSpread({
+        'Filerobot-Token': container,
+        'Filerobot-uuid': uuid
+      }, !isInternalFolder && {
+        'Filerobot-folder': folderPath
+      })
+    }).then(function () {
+      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        status = _ref4.status;
+      setTimeout(function () {
+        return dispatch(handleFileBackgroundRemoval({
+          originalFile: file,
+          statusUrl: status,
+          info: info,
+          i18n: i18n
+        }));
+      }, 3000);
+    });
+    return _objectSpread(_objectSpread({}, file), {}, {
+      isRemovingBackground: true
+    });
+  });
+  return thunkApi.dispatch(updateFiles({
+    files: updatedFiles
+  }));
+});
+var handleFileBackgroundRemoval = createThunk(async function (_ref5, thunkApi) {
+  var originalFile = _ref5.originalFile,
+    statusUrl = _ref5.statusUrl,
+    info = _ref5.info,
+    i18n = _ref5.i18n,
+    signal = _ref5.signal;
+  if (!statusUrl) {
+    return;
+  }
+  var _ref6 = (await thunkApi.extra.apiClient.get(statusUrl, {
+      abortSignal: signal,
+      checkOnlySuccessStatus: true
+    })) || {},
+    status = _ref6.status,
+    result = _ref6.result;
+  if (status === 'success') {
+    var _file$folder3;
+    var _ref7 = result || {},
+      _ref7$filerobot_info = _ref7.filerobot_info,
+      _ref7$filerobot_info2 = _ref7$filerobot_info === void 0 ? {} : _ref7$filerobot_info,
+      file = _ref7$filerobot_info2.file;
+    var fileFolderPath = file === null || file === void 0 ? void 0 : (_file$folder3 = file.folder) === null || _file$folder3 === void 0 ? void 0 : _file$folder3.name;
+    var state = thunkApi.getState();
+    var currentFolderPath = selectCurrentFolderPath(state);
+    if (fileFolderPath === currentFolderPath || selectIsAssetsView(state)) {
+      thunkApi.dispatch(fileUpdated(_objectSpread(_objectSpread({}, originalFile), {}, {
+        isRemovingBackground: false,
+        removedBackground: true
+      })));
+      if (file) {
+        thunkApi.dispatch(fileAdded(file));
+      }
+    }
+    info(i18n('backgroundRemovedSuccessfullyInfo', {
+      fileName: originalFile.name,
+      folder: fileFolderPath || '.internal'
+    }), 'success');
+    return;
+  }
+  if (status === 'error') {
+    info(i18n('backgroundRemovedFailInfo', {
+      fileName: originalFile.name
+    }), 'error');
+    return;
+  }
+  setTimeout(function () {
+    return !(signal !== null && signal !== void 0 && signal.aborted) && thunkApi.dispatch(handleFileBackgroundRemoval({
+      originalFile: originalFile,
+      statusUrl: statusUrl,
+      info: info,
+      i18n: i18n,
+      signal: signal
+    }));
+  }, 3000);
+});
+export var fetchFilesStats = createThunk(async function (_ref8, thunkApi) {
+  var _stats$approx_files_c, _stats$approx_files_c2, _stats$approx_files_s;
+  var path = _ref8.path,
+    queryParams = _ref8.queryParams,
+    fetchArgs = _ref8.fetchArgs;
+  var _ref9 = (fetchArgs === null || fetchArgs === void 0 ? void 0 : fetchArgs.moreQueries) || {},
+    method = _ref9.method,
+    moreQueries = _objectWithoutProperties(_ref9, _excluded);
+  var _ref10 = (await thunkApi.extra.apiClient.fetch("".concat(path, "/stats").concat((queryParams === null || queryParams === void 0 ? void 0 : queryParams.length) > 0 ? "?".concat(queryParams.join('&')) : ''), _objectSpread(_objectSpread({}, fetchArgs), {}, {
+      moreQueries: moreQueries,
+      abortSignal: fetchArgs.abortSignal || thunkApi.signal,
+      noPagination: true,
+      noFormatAndSortParams: true
+    }))) || {},
+    _ref10$stats = _ref10.stats,
+    stats = _ref10$stats === void 0 ? {} : _ref10$stats;
+  return {
+    filesCount: (_stats$approx_files_c = stats.approx_files_count) !== null && _stats$approx_files_c !== void 0 ? _stats$approx_files_c : selectFilesUuids(thunkApi.getState()).length,
+    filesCountMethod: (_stats$approx_files_c2 = stats.approx_files_count_method) !== null && _stats$approx_files_c2 !== void 0 ? _stats$approx_files_c2 : null,
+    filesSize: (_stats$approx_files_s = stats.approx_files_size) !== null && _stats$approx_files_s !== void 0 ? _stats$approx_files_s : Object.values(selectFiles(thunkApi.getState())).reduce(function (acc, file) {
+      var _file$size;
+      return acc + (file === null || file === void 0 ? void 0 : (_file$size = file.size) === null || _file$size === void 0 ? void 0 : _file$size.bytes) || 0;
+    }, 0)
+  };
+}, {
+  actionType: ACTION_TYPE.FETCH_FILES_STATS
+});
+var updateFilesSorting = function updateFilesSorting(_ref11) {
+  var state = _ref11.state,
+    sorting = _ref11.sorting,
+    thunkApi = _ref11.thunkApi;
+  var dispatch = thunkApi.dispatch,
+    extra = thunkApi.extra;
+  var sortBy;
+  var sortOrder;
+  // If there is custom sorting provided, then let's update it while using.
+  if (Array.isArray(sorting) || typeof sorting === 'string') {
+    var _ref12 = Array.isArray(sorting) ? sorting : sorting.split(':');
+    var _ref13 = _slicedToArray(_ref12, 2);
+    sortBy = _ref13[0];
+    sortOrder = _ref13[1];
+    if (sortBy && sortOrder) {
+      dispatch(filesSortingUpdated({
+        sortBy: sortBy,
+        order: sortOrder
+      }));
+    }
+  } else {
+    sortOrder = selectFilesSortOrder(state);
+    sortBy = selectFilesSortedBy(state);
+    if (!selectIsSearchMode(state)) {
+      var _extra$filerobot$getP2, _extra$filerobot$getP3;
+      var _extra$filerobot$getP = extra === null || extra === void 0 ? void 0 : (_extra$filerobot$getP2 = extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _extra$filerobot$getP2 === void 0 ? void 0 : (_extra$filerobot$getP3 = _extra$filerobot$getP2.opts) === null || _extra$filerobot$getP3 === void 0 ? void 0 : _extra$filerobot$getP3.config,
+        defaultSort = _extra$filerobot$getP.defaultSort;
+      sortBy = sortBy || defaultSort.by || DEFAULT_SORT_OPTION.by;
+      sortOrder = sortOrder || defaultSort.order || DEFAULT_SORT_OPTION.order;
+      if (sortBy === SORT_BY.RELEVANCE) {
+        sortBy = defaultSort.by || DEFAULT_SORT_OPTION.by;
+      }
+      dispatch(filesSortingUpdated({
+        sortBy: sortBy,
+        order: sortOrder
+      }));
+    }
+  }
+  return !sortBy ? undefined : "".concat(sortBy, ":").concat(sortOrder);
+};
+/**
+ * cachedViewQueries === { [key]: value }, means we are fetching the files for which view-mode/feature (folder/label/...etc), examples:
+ *    { folder: 'folderUuid' } or { labels: 'labelSid' }
+ *    or { search: 'searchQuery' } or { search: 'searchQuery', folder: 'folderPath' }
+ * -- u could add `recursive: true` to be cached with the view also to be considered always in the request till changing the view.
+ *
+*/
+// `lastViewOptions` - used to keep tracked of the last applied view for fetchFiles...
+//  to be used in fetching files again for the same query without providing query one more time (easier to call the thunk from anyplace without query or complex/spaghetti logic).
+export var fetchInitialFiles = function fetchInitialFiles(args) {
+  return fetchFiles(_objectSpread(_objectSpread({
+    withStats: true
+  }, args), {}, {
+    offset: 0
+  }));
+};
+export var fetchFiles = createThunk(async function () {
+  var _selectIsFolderFilesR;
+  var _ref14 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref14$cachedViewQuer = _ref14.cachedViewQueries,
+    cachedViewQueries = _ref14$cachedViewQuer === void 0 ? viewCachedFetchFilesQueries : _ref14$cachedViewQuer,
+    queries = _ref14.queries,
+    offset = _ref14.offset,
+    limit = _ref14.limit,
+    filters = _ref14.filters,
+    format = _ref14.format,
+    _ref14$recursive = _ref14.recursive,
+    recursive = _ref14$recursive === void 0 ? false : _ref14$recursive,
+    sorting = _ref14.sorting,
+    _ref14$path = _ref14.path,
+    path = _ref14$path === void 0 ? 'files' : _ref14$path,
+    _ref14$abortSignal = _ref14.abortSignal,
+    abortSignal = _ref14$abortSignal === void 0 ? null : _ref14$abortSignal,
+    _ref14$withStats = _ref14.withStats,
+    withStats = _ref14$withStats === void 0 ? false : _ref14$withStats,
+    _ref14$replaceOldFile = _ref14.replaceOldFiles,
+    replaceOldFiles = _ref14$replaceOldFile === void 0 ? false : _ref14$replaceOldFile,
+    _ref14$noPagination = _ref14.noPagination,
+    noPagination = _ref14$noPagination === void 0 ? false : _ref14$noPagination,
+    _ref14$id = _ref14.id,
+    id = _ref14$id === void 0 ? 'listFiles' : _ref14$id,
+    _ref14$useSameApiStat = _ref14.useSameApiStats,
+    useSameApiStats = _ref14$useSameApiStat === void 0 ? false : _ref14$useSameApiStat,
+    _ref14$skipDispatch = _ref14.skipDispatch,
+    skipDispatch = _ref14$skipDispatch === void 0 ? false : _ref14$skipDispatch,
+    _ref14$skipPendingDis = _ref14.skipPendingDispatch,
+    skipPendingDispatch = _ref14$skipPendingDis === void 0 ? false : _ref14$skipPendingDis,
+    _ref14$returnBlob = _ref14.returnBlob,
+    returnBlob = _ref14$returnBlob === void 0 ? false : _ref14$returnBlob,
+    _ref14$xhrOptions = _ref14.xhrOptions,
+    xhrOptions = _ref14$xhrOptions === void 0 ? {} : _ref14$xhrOptions,
+    _ref14$noSearch = _ref14.noSearch,
+    noSearch = _ref14$noSearch === void 0 ? false : _ref14$noSearch,
+    _ref14$noFilters = _ref14.noFilters,
+    noFilters = _ref14$noFilters === void 0 ? false : _ref14$noFilters,
+    _ref14$noSorting = _ref14.noSorting,
+    noSorting = _ref14$noSorting === void 0 ? false : _ref14$noSorting,
+    _ref14$deleteFiltersA = _ref14.deleteFiltersAndSearchUrlQueries,
+    deleteFiltersAndSearchUrlQueries = _ref14$deleteFiltersA === void 0 ? false : _ref14$deleteFiltersA,
+    _ref14$applyActiveVie = _ref14.applyActiveViewItemCheck,
+    applyActiveViewItemCheck = _ref14$applyActiveVie === void 0 ? true : _ref14$applyActiveVie;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  if (applyActiveViewItemCheck && !selectActiveViewItem(thunkApi.getState())) {
+    thunkApi.skipDispatch();
+    return;
+  }
+  if (skipDispatch) {
+    thunkApi.skipDispatch();
+  } else if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  var _thunkApi$extra$filer3 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    opts = _thunkApi$extra$filer3.opts,
+    replaceUrlQueryParams = _thunkApi$extra$filer3.replaceUrlQueryParams;
+  var defaultFilters = opts.defaultFilters,
+    forceFilters = opts.forceFilters,
+    disableFiltersAndSearch = opts.disableFiltersAndSearch,
+    _opts$config = opts.config,
+    config = _opts$config === void 0 ? {} : _opts$config;
+  var filesLimit = config.filesLimit;
+  var fetch = thunkApi.extra.apiClient.fetch;
+  var state = thunkApi.getState();
+  var currentOffset = (['undefined', 'null'].includes(_typeof(offset)) && !replaceOldFiles ? selectFilesOffset(state) : offset) || 0;
+  var currentLimit = limit || filesLimit;
+  if (!disableFiltersAndSearch && deleteFiltersAndSearchUrlQueries) {
+    replaceUrlQueryParams({
+      keysToDelete: [!forceFilters && FMAW_URL_QUERY_PARAMS.FILTER_PREFIX, FMAW_URL_QUERY_PARAMS.SEARCH_PREFIX]
+    });
+  }
+
+  // If there is custom sorting provided, then let's update it while using.
+  var currentSorting = updateFilesSorting({
+    state: state,
+    sorting: sorting,
+    thunkApi: thunkApi
+  });
+  changeViewFetchFilesCachedQueries(cachedViewQueries);
+  var _ref15 = cachedViewQueries || {},
+    isRecursiveView = _ref15.recursive,
+    viewPath = _ref15.path,
+    isNoPaginationView = _ref15.noPagination,
+    viewQueries = _objectWithoutProperties(_ref15, _excluded2);
+  var customQueries = _objectSpread(_objectSpread({}, viewQueries), queries);
+  var filterKeysToDisregard = [];
+  var isFoldersView = selectIsFoldersView(state);
+  if (!noFilters && (isFoldersView || customQueries.folder)) {
+    filterKeysToDisregard.push(FILTER_SECTION_KEYS.FOLDERS);
+  }
+  var searchAndFiltersQuery = getQueryForSearchAndFilters(state, {
+    noSearch: noSearch,
+    noFilters: noFilters,
+    filterKeysToDisregard: filterKeysToDisregard,
+    moreFilters: _objectSpread(_objectSpread({}, filters), defaultFilters)
+  });
+  var isCdnPermalinkEnabled = selectIsCdnPermalinkEnabled(state);
+  var moreQueries = _objectSpread(_objectSpread(_objectSpread({}, searchAndFiltersQuery && {
+    q: searchAndFiltersQuery
+  }), customQueries), isCdnPermalinkEnabled && {
+    fields: 'cdn_permalink'
+  });
+  if (!noFilters && moreQueries.folder && selectAppliedFilters(state)[FILTER_SECTION_KEYS.FOLDERS]) {
+    var _selectAppliedFilters;
+    moreQueries.folder = ((_selectAppliedFilters = selectAppliedFilters(state)[FILTER_SECTION_KEYS.FOLDERS].value) === null || _selectAppliedFilters === void 0 ? void 0 : _selectAppliedFilters[0]) || moreQueries.folder;
+  }
+  var fetchArgs = _objectSpread(_objectSpread({}, xhrOptions), {}, {
+    id: id,
+    offset: currentOffset,
+    limit: currentLimit,
+    sorting: noSorting ? undefined : currentSorting,
+    format: format,
+    noPagination: isNoPaginationView || noPagination,
+    abortSignal: abortSignal || thunkApi.signal,
+    moreQueries: moreQueries,
+    recursive: (_selectIsFolderFilesR = selectIsFolderFilesRecursiveFetch(state)) !== null && _selectIsFolderFilesR !== void 0 ? _selectIsFolderFilesR : isRecursiveView || recursive,
+    noRecursiveParam: false,
+    useCustomEncoding: true
+  });
+  var selectedItemsCount = selectAllSelectedItemsCount(state);
+  if ((replaceOldFiles || currentOffset === 0) && selectedItemsCount > 0) {
+    thunkApi.dispatch(selectionsCleared());
+  }
+  var filesRequest = fetch("".concat(viewPath || path, "?preview=2301"), fetchArgs);
+  if (returnBlob) {
+    var filesResponse = await filesRequest;
+    return filesResponse;
+  }
+  if (withStats) {
+    thunkApi.dispatch(fetchFilesStats({
+      path: path,
+      fetchArgs: _objectSpread(_objectSpread({}, fetchArgs), {}, {
+        id: 'listFilesStats'
+      })
+    }));
+  }
+  var _ref16 = (await filesRequest) || {},
+    folder = _ref16.base,
+    _ref16$files = _ref16.files,
+    files = _ref16$files === void 0 ? [] : _ref16$files,
+    _ref16$info = _ref16.info,
+    info = _ref16$info === void 0 ? {} : _ref16$info,
+    type = _ref16.type;
+  return _objectSpread(_objectSpread({
+    fetchType: type
+  }, isFoldersView && {
+    folder: folder
+  }), {}, {
+    files: files,
+    // if `replace` is provided, then the files response will contain `replace` for the reducer
+    // to replace current files in the store, otherwise they will get appended.
+    replaceOldFiles: replaceOldFiles || currentOffset === 0,
+    noMoreFiles: files.length < currentLimit * 0.5,
+    // TODO: Remove "* 0.5" when BE fix issue and send correct number of files, now sometimes they send less. To avoid lazy loading stops we need this hack.
+    newOffset: currentLimit + currentOffset
+  }, useSameApiStats && {
+    stats: {
+      loading: false,
+      filesCountMethod: null,
+      filesCount: info.total_files_count || files.length,
+      filesSize: info.total_files_size || files.reduce(function (acc, file) {
+        var _file$size2;
+        return acc + (file === null || file === void 0 ? void 0 : (_file$size2 = file.size) === null || _file$size2 === void 0 ? void 0 : _file$size2.bytes) || 0;
+      }, 0)
+    }
+  });
+}, {
+  actionType: ACTION_TYPE.FETCH_FILES
+});
+var getCdnPermalinkFieldsQueryParams = function getCdnPermalinkFieldsQueryParams(isEnabled) {
+  return isEnabled ? '?fields=cdn_permalink' : '';
+};
+export var fetchFileByUuid = createThunk(async function () {
+  var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  // To support old params type in-case of not modified one, but in-fact as a new there is no use-case for it and we should provide object.
+  var _ref17 = typeof params === 'string' ? {
+      uuid: params,
+      addNotFound: true
+    } : params,
+    uuid = _ref17.uuid,
+    _ref17$addNotFound = _ref17.addNotFound,
+    addNotFound = _ref17$addNotFound === void 0 ? true : _ref17$addNotFound,
+    _ref17$skipDispatch = _ref17.skipDispatch,
+    skipDispatch = _ref17$skipDispatch === void 0 ? false : _ref17$skipDispatch;
+  var isCdnPermalinkEnabled = selectIsCdnPermalinkEnabled(thunkApi.getState());
+  if (skipDispatch) {
+    thunkApi.skipDispatch();
+  }
+  var _await$thunkApi$extra = await thunkApi.extra.apiClient.get("file/".concat(uuid).concat(getCdnPermalinkFieldsQueryParams(isCdnPermalinkEnabled)), {
+      id: 'getFile',
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra2 = _await$thunkApi$extra.file,
+    file = _await$thunkApi$extra2 === void 0 ? {} : _await$thunkApi$extra2;
+  return _objectSpread(_objectSpread({}, file), {}, {
+    addNotFound: addNotFound
+  });
+}, {
+  actionType: "".concat(sliceName, "/updateFileByUuid")
+});
+
+// gets the file from the state only without fetching to be used in places that not able to use selectors.
+export var getFileByUuidFromState = createThunk(function (uuid, thunkApi) {
+  return selectFileByUuid(thunkApi.getState(), uuid);
+});
+export var renameFile = createThunk(async function (_ref18, thunkApi) {
+  var uuid = _ref18.uuid,
+    name = _ref18.name,
+    _ref18$skipPendingDis = _ref18.skipPendingDispatch,
+    skipPendingDispatch = _ref18$skipPendingDis === void 0 ? false : _ref18$skipPendingDis;
+  if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  var _await$thunkApi$extra3 = await thunkApi.extra.apiClient.put("file/".concat(uuid, "/name"), {
+      data: {
+        name: name
+      },
+      permissionsToCheck: [PERMISSIONS.FILE_RENAME],
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra4 = _await$thunkApi$extra3.file,
+    file = _await$thunkApi$extra4 === void 0 ? {} : _await$thunkApi$extra4;
+  return file;
+}, {
+  actionType: "".concat(sliceName, "/updateFileName")
+});
+export var updateFileMeta = createThunk(async function (_ref19, thunkApi) {
+  var uuid = _ref19.uuid,
+    meta = _ref19.meta,
+    _ref19$skipPendingDis = _ref19.skipPendingDispatch,
+    skipPendingDispatch = _ref19$skipPendingDis === void 0 ? false : _ref19$skipPendingDis;
+  if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  if (Object.keys(meta).length < 1) {
+    return selectFileByUuid(thunkApi.getState(), uuid);
+  }
+  var _await$thunkApi$extra5 = await thunkApi.extra.apiClient.put("file/".concat(uuid, "/meta"), {
+      data: {
+        meta: meta
+      },
+      permissionToCheck: [PERMISSIONS.FILE_META],
+      enabledAbort: false,
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra6 = _await$thunkApi$extra5.file,
+    file = _await$thunkApi$extra6 === void 0 ? {} : _await$thunkApi$extra6;
+  return file;
+}, {
+  actionType: "".concat(sliceName, "/updateFileMeta")
+});
+export var updateFileTags = createThunk(async function (_ref20, thunkApi) {
+  var uuid = _ref20.uuid,
+    languageKey = _ref20.languageKey,
+    existingTags = _ref20.existingTags,
+    newTags = _ref20.newTags,
+    _ref20$skipPendingDis = _ref20.skipPendingDispatch,
+    skipPendingDispatch = _ref20$skipPendingDis === void 0 ? false : _ref20$skipPendingDis;
+  if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  var _await$thunkApi$extra7 = await thunkApi.extra.apiClient.put("file/".concat(uuid, "/tags"), {
+      data: _objectSpread(_objectSpread({
+        lang: languageKey
+      }, existingTags ? {
+        existing_tags: existingTags
+      } : {}), newTags ? {
+        new_tags: newTags
+      } : {}),
+      permissionToCheck: [PERMISSIONS.FILE_META],
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra8 = _await$thunkApi$extra7.file,
+    file = _await$thunkApi$extra8 === void 0 ? {} : _await$thunkApi$extra8;
+  return file;
+}, {
+  actionType: "".concat(sliceName, "/updateFileTags")
+});
+export var updateFileProduct = createThunk(async function (_ref21, thunkApi) {
+  var uuid = _ref21.uuid,
+    product = _ref21.product,
+    _ref21$skipPendingDis = _ref21.skipPendingDispatch,
+    skipPendingDispatch = _ref21$skipPendingDis === void 0 ? false : _ref21$skipPendingDis;
+  if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  var _await$thunkApi$extra9 = await thunkApi.extra.apiClient.put("file/".concat(uuid, "/product"), {
+      data: {
+        product: product
+      },
+      permissionToCheck: [PERMISSIONS.FILE_PRODUCT_CHANGE],
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra10 = _await$thunkApi$extra9.file,
+    file = _await$thunkApi$extra10 === void 0 ? {} : _await$thunkApi$extra10;
+  return file;
+}, {
+  actionType: "".concat(sliceName, "/updateFileProduct")
+});
+export var generateFileTags = createThunk(async function (_ref22, thunkApi) {
+  var _ref22$uuid = _ref22.uuid,
+    uuid = _ref22$uuid === void 0 ? '' : _ref22$uuid,
+    _ref22$provider = _ref22.provider,
+    provider = _ref22$provider === void 0 ? 'google' : _ref22$provider,
+    _ref22$confidence = _ref22.confidence,
+    confidence = _ref22$confidence === void 0 ? 60 : _ref22$confidence,
+    _ref22$limit = _ref22.limit,
+    limit = _ref22$limit === void 0 ? 10 : _ref22$limit,
+    _ref22$languages = _ref22.languages,
+    languages = _ref22$languages === void 0 ? ['en'] : _ref22$languages;
+  var _await$thunkApi$extra11 = await thunkApi.extra.apiClient.post('process/autotag', {
+      data: {
+        file: {
+          uuid: uuid
+        },
+        meta: {
+          languages: languages,
+          provider: provider,
+          limit: limit,
+          confidence: confidence
+        }
+      },
+      permissionToCheck: [PERMISSIONS.FILE_META],
+      id: 'generateTags',
+      abortSignal: thunkApi.signal
+    }),
+    file = _await$thunkApi$extra11.file;
+  return file;
+});
+export var generateFileDescription = createThunk(async function (_ref23, thunkApi) {
+  var _ref23$uuid = _ref23.uuid,
+    uuid = _ref23$uuid === void 0 ? '' : _ref23$uuid;
+  var state = thunkApi.getState();
+  var metaRegionalGroups = selectMetadataRegionalGroups(state);
+  var activeRegionalLangKey = selectActiveRegionalLang(state);
+  var regionalLanguages = getMetaRegionalGroupsLanguagesApiValues(metaRegionalGroups);
+  var includeActiveLang = DESCRIBE_AI_SUPPORTED_LANGUAGES[activeRegionalLangKey];
+  var supportedLanguages = regionalLanguages.filter(function (lang) {
+    return lang !== activeRegionalLangKey && lang !== 'en' && DESCRIBE_AI_SUPPORTED_LANGUAGES[lang];
+  });
+  var languages = [].concat(_toConsumableArray(includeActiveLang ? [activeRegionalLangKey] : []), _toConsumableArray(supportedLanguages)).slice(0, 5);
+  var response = await thunkApi.extra.apiClient.post('process/describe', {
+    data: {
+      file: {
+        uuid: uuid
+      },
+      meta: {
+        languages: languages
+      }
+    },
+    abortSignal: thunkApi.signal
+  });
+  if (response !== null && response !== void 0 && response.translations) {
+    return _objectSpread({
+      en: response.response
+    }, response.translations);
+  }
+  return _defineProperty({}, languages[0], response === null || response === void 0 ? void 0 : response.response);
+});
+export var searchFilesService = async function searchFilesService(params, thunkApi) {
+  var requestProgress = params.requestProgress,
+    abortFunction = params.abortFunction,
+    sendStatsReq = params.sendStatsReq,
+    responseType = params.responseType,
+    headers = params.headers,
+    replaceOldFiles = params.replaceOldFiles,
+    searchParams = _objectWithoutProperties(params, _excluded3);
+  var url = prepareSearchUrl(_objectSpread(_objectSpread({}, searchParams), {}, {
+    apiPath: 'files?preview=2301'
+  }), function (queryItems) {
+    if (sendStatsReq) {
+      thunkApi.dispatch(fetchFilesStats({
+        path: 'files',
+        queryParams: queryItems,
+        fetchArgs: {
+          id: 'searchFilesStats',
+          abortSignal: thunkApi.signal
+        }
+      }));
+    }
+  });
+  var searchResponse = (await thunkApi.extra.apiClient.get(url, {
+    id: searchParams.method === SEARCH_METHODS.EXTENDED ? 'searchFilesExtended' : 'searchFiles',
+    onProgress: requestProgress,
+    onAbort: abortFunction,
+    headers: headers,
+    responseType: responseType,
+    abortSignal: thunkApi.signal
+  })) || {};
+  return responseType === 'blob' ? searchResponse : {
+    files: searchResponse.files,
+    replaceOldFiles: replaceOldFiles
+  };
+};
+export var moveFiles = createThunk(async function (_ref25, thunkApi) {
+  var _ref25$fileUuids = _ref25.fileUuids,
+    fileUuids = _ref25$fileUuids === void 0 ? [] : _ref25$fileUuids,
+    folderPath = _ref25.folderPath;
+  var response = await thunkApi.extra.apiClient.post("files".concat(getCdnPermalinkFieldsQueryParams(selectIsCdnPermalinkEnabled(thunkApi.getState()))), {
+    data: {
+      files_uuids: fileUuids,
+      new_folder_name: folderPath
+    },
+    permissionToCheck: [PERMISSIONS.FILE_MOVE],
+    abortSignal: thunkApi.signal
+  });
+  return response.files.map(function (file) {
+    return file.uuid;
+  });
+}, {
+  actionType: "".concat(sliceName, "/moveFiles")
+});
+export var deleteFiles = createThunk(async function (uuids, thunkApi) {
+  var response = await thunkApi.extra.apiClient["delete"]("files".concat(getCdnPermalinkFieldsQueryParams(selectIsCdnPermalinkEnabled(thunkApi.getState()))), {
+    data: {
+      files_uuids: uuids
+    },
+    permissionToCheck: [PERMISSIONS.FILE_DELETE],
+    abortSignal: thunkApi.signal
+  });
+  thunkApi.extra.filerobot.emit('objects-removed', uuids, 'files');
+  return response.files_uuids;
+}, {
+  actionType: "".concat(sliceName, "/deleteFiles")
+});
+export var openFileWindowFromUrl = createThunk(function (_, thunkApi) {
+  var _thunkApi$extra$filer4 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    getUrlQueryParam = _thunkApi$extra$filer4.getUrlQueryParam;
+  var fileUuidFromUrl = decodeB64ToStr(getUrlQueryParam(FMAW_URL_QUERY_PARAMS.FILE_WINDOW));
+  var currentFileWindowUuid = selectFileWindowFor(thunkApi.getState());
+  if (fileUuidFromUrl && fileUuidFromUrl !== currentFileWindowUuid) {
+    var tabToOpen = getUrlQueryParam(FMAW_URL_QUERY_PARAMS.FILE_WINDOW_TAB);
+    thunkApi.dispatch(fileWindowUpdated({
+      "for": fileUuidFromUrl,
+      tabId: tabToOpen
+    }));
+    return thunkApi.dispatch(fetchFileByUuid({
+      uuid: fileUuidFromUrl
+    }));
+  }
+});
+export var getFileConfiguredCdnLink = createThunk(function (file, thunkApi) {
+  if (!file || _typeof(file) !== 'object') {
+    return;
+  }
+  var isCdnPermalinkEnabled = selectIsCdnPermalinkEnabled(thunkApi.getState());
+  var cdnPermalink = isCdnPermalinkEnabled && getFileLink(file, 'cdn_permalink');
+  return cdnPermalink || getFileLink(file);
+});
+export var copyFileCdnLink = createThunk(function (file, thunkApi) {
+  if (!file || _typeof(file) !== 'object') {
+    return;
+  }
+  var _thunkApi$extra$filer5 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    info = _thunkApi$extra$filer5.info,
+    i18n = _thunkApi$extra$filer5.i18n;
+  var link = thunkApi.dispatch(getFileConfiguredCdnLink(file));
+  copyText({
+    text: link,
+    i18n: i18n,
+    info: info
+  });
+  return link;
+});
+var filesSlice = createSlice({
+  name: sliceName,
+  initialState: getInitialState(),
+  reducers: {
+    filesAdded: function filesAdded(state, action) {
+      var _action$payload = action.payload,
+        files = _action$payload.files,
+        newOffset = _action$payload.newOffset,
+        noMoreFiles = _action$payload.noMoreFiles,
+        stats = _action$payload.stats;
+      var _getNormalizedItems = getNormalizedItems(files, {
+          extraProps: {
+            loading: false,
+            error: null
+          }
+        }),
+        normalizedSlices = _getNormalizedItems.normalizedSlices;
+      var newFiles = _objectSpread(_objectSpread({}, state.entities), normalizedSlices);
+      var newUuids = Object.keys(newFiles);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newFiles,
+        uuids: newUuids,
+        loading: false,
+        error: null,
+        offset: newOffset,
+        noMoreFiles: noMoreFiles
+      }, stats && {
+        stats: stats
+      });
+    },
+    fileAdded: function fileAdded(state, action) {
+      var _state$stats$filesCou;
+      var newUuids = state.uuids;
+      var addedFile = action.payload;
+      var newFiles = _objectSpread({}, state.entities);
+      // This case for handling the case when we upload a file that same considered as version for a current file, we recognize that through their names
+      var foundFile = Object.values(state.entities).find(function (file) {
+        return file.name === addedFile.name;
+      });
+      if (foundFile) {
+        delete newFiles[foundFile.uuid];
+        newUuids = newUuids.filter(function (uuid) {
+          return uuid !== foundFile.uuid;
+        });
+      }
+      newFiles[addedFile.uuid] = addedFile;
+      newUuids = [addedFile.uuid].concat(_toConsumableArray(newUuids));
+      return _objectSpread(_objectSpread({}, state), {}, {
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          // if `foundFile` true then don't increase the files count, as the file is replacing the current one.
+          filesCount: ((_state$stats$filesCou = state.stats.filesCount) !== null && _state$stats$filesCou !== void 0 ? _state$stats$filesCou : 0) + (foundFile ? 0 : 1)
+        }),
+        entities: newFiles,
+        uuids: newUuids,
+        loading: false,
+        error: null
+      });
+    },
+    filesReplaced: function filesReplaced(state, action) {
+      var _action$payload2 = action.payload,
+        files = _action$payload2.files,
+        _action$payload2$newO = _action$payload2.newOffset,
+        newOffset = _action$payload2$newO === void 0 ? 0 : _action$payload2$newO,
+        noMoreFiles = _action$payload2.noMoreFiles,
+        _action$payload2$erro = _action$payload2.error,
+        error = _action$payload2$erro === void 0 ? null : _action$payload2$erro,
+        stats = _action$payload2.stats,
+        overrideLoading = _action$payload2.overrideLoading;
+      var newFiles = {};
+      var newFilesUuids = [];
+      if (Array.isArray(files)) {
+        var _getNormalizedItems2 = getNormalizedItems(files, {
+            extraProps: _objectSpread(_objectSpread({}, !overrideLoading && {
+              loading: false
+            }), {}, {
+              error: null
+            })
+          }),
+          normalizedSlices = _getNormalizedItems2.normalizedSlices,
+          uuids = _getNormalizedItems2.uuids;
+        newFiles = normalizedSlices;
+        newFilesUuids = uuids;
+      } else {
+        newFiles = _objectSpread({}, files);
+        newFilesUuids = Object.keys(newFiles);
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newFiles,
+        uuids: newFilesUuids,
+        loading: false,
+        error: error,
+        offset: newOffset,
+        noMoreFiles: noMoreFiles
+      }, stats && {
+        stats: stats
+      });
+    },
+    fileReplacedByNewer: function fileReplacedByNewer(state, action) {
+      var _action$payload3 = action.payload,
+        oldFileUuid = _action$payload3.oldFileUuid,
+        newFile = _action$payload3.newFile,
+        _action$payload3$erro = _action$payload3.error,
+        error = _action$payload3$erro === void 0 ? null : _action$payload3$erro;
+      var newFiles = _objectSpread({}, state.entities);
+      var newUuids = _toConsumableArray(state.uuids);
+      delete newFiles[oldFileUuid];
+      newFiles[newFile.uuid] = newFile;
+      var findOlderUuidIndex = newUuids.indexOf(oldFileUuid);
+      if (findOlderUuidIndex > -1) {
+        newUuids[findOlderUuidIndex] = newFile.uuid;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: false,
+        error: error,
+        entities: newFiles,
+        uuids: newUuids
+      });
+    },
+    filesRemoved: function filesRemoved(state) {
+      var _state$stats, _state$stats2;
+      var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var removedFileUuids = action.payload;
+      if (!Array.isArray(removedFileUuids)) {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          entities: {},
+          uuids: [],
+          loading: false,
+          error: null,
+          stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+            filesCount: 0,
+            filesSize: 0
+          })
+        });
+      }
+      var currentFiles = _objectSpread({}, state.entities);
+      var newUuids = state.uuids;
+      var isFileRemoved = false;
+      var removedFilesSize = 0;
+      removedFileUuids.forEach(function (fileUuid) {
+        if (currentFiles[fileUuid]) {
+          var _currentFiles$fileUui;
+          removedFilesSize += ((_currentFiles$fileUui = currentFiles[fileUuid].size) === null || _currentFiles$fileUui === void 0 ? void 0 : _currentFiles$fileUui.bytes) || 0;
+          delete currentFiles[fileUuid];
+          newUuids = newUuids.filter(function (uuid) {
+            return fileUuid !== uuid;
+          });
+          isFileRemoved = true;
+        }
+      });
+      if (!isFileRemoved) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: currentFiles,
+        uuids: newUuids,
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          filesSize: Math.max(0, (((_state$stats = state.stats) === null || _state$stats === void 0 ? void 0 : _state$stats.filesSize) || 0) - removedFilesSize),
+          filesCount: Math.max(0, (((_state$stats2 = state.stats) === null || _state$stats2 === void 0 ? void 0 : _state$stats2.filesCount) || 0) - removedFileUuids.length)
+        })
+      });
+    },
+    filesUpdated: function filesUpdated(state, action) {
+      var files = action.payload;
+      var updatedFiles = _objectSpread({}, state.entities);
+      files.forEach(function (file) {
+        if (!updatedFiles[file.uuid]) {
+          return;
+        }
+        updatedFiles[file.uuid] = _objectSpread(_objectSpread({}, state.entities[file.uuid]), {}, {
+          // Those will get overridden if their values are assigned inside the filesUpdated
+          loading: false,
+          error: null
+        }, file);
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: updatedFiles
+      });
+    },
+    fileUpdated: function fileUpdated(state, action) {
+      var _ref26 = action.payload || {},
+        fileUuid = _ref26.uuid,
+        _ref26$addNotFound = _ref26.addNotFound,
+        addNotFound = _ref26$addNotFound === void 0 ? false : _ref26$addNotFound;
+      if (!fileUuid) {
+        return state;
+      }
+      var updatedFiles = _objectSpread({}, state.entities);
+      if (!updatedFiles[fileUuid] && !addNotFound) {
+        return state;
+      }
+      var _action$payload4 = action.payload,
+        _ = _action$payload4.addNotFound,
+        newFile = _objectWithoutProperties(_action$payload4, _excluded4);
+      updatedFiles[fileUuid] = _objectSpread(_objectSpread({}, updatedFiles[fileUuid]), newFile);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: updatedFiles
+      }, addNotFound && {
+        tmpFile: updatedFiles[fileUuid]
+      });
+    },
+    removingBackgroundUuidsUpdated: function removingBackgroundUuidsUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        removingBackgroundUuids: action.payload
+      });
+    },
+    filesLoadingSet: function filesLoadingSet(state, action) {
+      var isLoading = action.payload;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: isLoading
+      }, isLoading && {
+        entities: {},
+        uuids: [],
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          filesCount: 0,
+          filesSize: 0
+        })
+      });
+    },
+    filesSortingUpdated: function filesSortingUpdated(state, action) {
+      var _action$payload5 = action.payload,
+        _action$payload5$sort = _action$payload5.sortBy,
+        sortBy = _action$payload5$sort === void 0 ? state.sortedBy : _action$payload5$sort,
+        _action$payload5$orde = _action$payload5.order,
+        order = _action$payload5$orde === void 0 ? state.sortOrder : _action$payload5$orde;
+      var isTheSameSort = sortBy === state.sortedBy && order === state.sortOrder;
+      if (isTheSameSort) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        sortedBy: sortBy,
+        sortOrder: order
+      });
+    },
+    filesVariationsUpdated: function filesVariationsUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        variations: action.payload
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(moveFiles.fulfilled, function (state, action) {
+      return filesSlice.caseReducers.filesRemoved(state, action);
+    }).addCase(deleteFiles.fulfilled, function (state, action) {
+      return filesSlice.caseReducers.filesRemoved(state, action);
+    }).addCase(fetchFilesStats.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          filesCount: 0,
+          filesSize: 0,
+          loading: true
+        })
+      });
+    }).addCase(viewChanged.type, getInitialState).addCase(fileWindowUpdated.type, function (state, action) {
+      return action.payload === null ? _objectSpread(_objectSpread({}, state), {}, {
+        tmpFile: null
+      }) : state;
+    }).addMatcher(isAnyOf(fetchFiles.pending, searchFilesWithAiText.pending, searchSimilarFiles.pending), function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: [],
+        entities: {},
+        loading: true,
+        error: null
+      });
+    }).addMatcher(isAnyOf(fetchFiles.fulfilled, searchFilesWithAiText.fulfilled, searchSimilarFiles.fulfilled), function (state, action) {
+      return action.payload.replaceOldFiles ? filesSlice.caseReducers.filesReplaced(state, action) : filesSlice.caseReducers.filesAdded(state, action);
+    }).addMatcher(isAnyOf(fetchFiles.rejected, searchFilesWithAiText.rejected, searchSimilarFiles.rejected), function (state, action) {
+      return _objectSpread(_objectSpread({}, getActionErrorState(state, action)), {}, {
+        uuids: [],
+        entities: {}
+      });
+    }).addMatcher(isAnyOf(fetchFilesStats.fulfilled, fetchFilesStats.rejected), function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        stats: _objectSpread(_objectSpread(_objectSpread({}, state.stats), action.payload), {}, {
+          loading: false
+        })
+      });
+    }).addMatcher(function (_ref27) {
+      var type = _ref27.type;
+      return type.startsWith(sliceName) && Boolean(type.match(/\/updateFile.*\/pending/));
+    }, function (state, action) {
+      var _action$meta$arg, _action$meta$arg2;
+      return filesSlice.caseReducers.fileUpdated(state, {
+        payload: {
+          uuid: ((_action$meta$arg = action.meta.arg) === null || _action$meta$arg === void 0 ? void 0 : _action$meta$arg.uuid) || ((_action$meta$arg2 = action.meta.arg) === null || _action$meta$arg2 === void 0 ? void 0 : _action$meta$arg2.fileUuid) || action.meta.arg,
+          loading: true,
+          error: null
+        }
+      });
+    }).addMatcher(function (_ref28) {
+      var type = _ref28.type;
+      return type.startsWith(sliceName) && Boolean(type.match(/\/updateFile.*\/fulfilled/));
+    }, function (state, action) {
+      return filesSlice.caseReducers.fileUpdated(state, {
+        payload: _objectSpread(_objectSpread({}, action.payload), {}, {
+          loading: false,
+          error: null
+        })
+      });
+    }).addMatcher(function (_ref29) {
+      var type = _ref29.type;
+      return type.startsWith(sliceName) && Boolean(type.match(/\/updateFile.*\/rejected/));
+    }, function (state, action) {
+      var _action$meta$arg3, _action$meta$arg4;
+      return filesSlice.caseReducers.fileUpdated(state, {
+        payload: {
+          uuid: ((_action$meta$arg3 = action.meta.arg) === null || _action$meta$arg3 === void 0 ? void 0 : _action$meta$arg3.uuid) || ((_action$meta$arg4 = action.meta.arg) === null || _action$meta$arg4 === void 0 ? void 0 : _action$meta$arg4.fileUuid) || action.meta.arg,
+          loading: false,
+          error: getActionErrorState(state, action, true)
+        }
+      });
+    }).addMatcher(function (_ref30) {
+      var type = _ref30.type;
+      return type.startsWith(sliceName) && Boolean(type.match(/\/updateFiles.*\/pending/));
+    }, function (state, action) {
+      var _action$meta$arg5, _action$meta$arg6;
+      return filesSlice.caseReducers.filesUpdated(state, {
+        payload: (((_action$meta$arg5 = action.meta.arg) === null || _action$meta$arg5 === void 0 ? void 0 : _action$meta$arg5.filesUuids) || ((_action$meta$arg6 = action.meta.arg) === null || _action$meta$arg6 === void 0 ? void 0 : _action$meta$arg6.uuids) || action.meta.arg || []).map(function (uuid) {
+          return {
+            uuid: uuid,
+            loading: true,
+            error: null
+          };
+        })
+      });
+    }).addMatcher(function (_ref31) {
+      var type = _ref31.type;
+      return type.startsWith(sliceName) && Boolean(type.match(/\/updateFiles.*\/fulfilled/));
+    }, function (state, action) {
+      return action.payload.removeFiles ? filesSlice.caseReducers.filesRemoved(state, {
+        payload: action.payload.filesUuids
+      }) : filesSlice.caseReducers.filesUpdated(state, action);
+    }).addMatcher(function (_ref32) {
+      var type = _ref32.type;
+      return type.startsWith(sliceName) && Boolean(type.match(/\/updateFiles.*\/rejected/));
+    }, function (state, action) {
+      var _action$meta$arg7, _action$meta$arg8;
+      return filesSlice.caseReducers.filesUpdated(state, {
+        payload: (((_action$meta$arg7 = action.meta.arg) === null || _action$meta$arg7 === void 0 ? void 0 : _action$meta$arg7.filesUuids) || ((_action$meta$arg8 = action.meta.arg) === null || _action$meta$arg8 === void 0 ? void 0 : _action$meta$arg8.uuids) || action.meta.arg || []).map(function (uuid) {
+          return {
+            uuid: uuid,
+            loading: false,
+            error: getActionErrorState(state, action, true)
+          };
+        })
+      });
+    });
+  }
+});
+var _filesSlice$actions = filesSlice.actions,
+  filesAdded = _filesSlice$actions.filesAdded,
+  fileAdded = _filesSlice$actions.fileAdded,
+  filesReplaced = _filesSlice$actions.filesReplaced,
+  filesRemoved = _filesSlice$actions.filesRemoved,
+  filesUpdated = _filesSlice$actions.filesUpdated,
+  fileUpdated = _filesSlice$actions.fileUpdated,
+  fileReplacedByNewer = _filesSlice$actions.fileReplacedByNewer,
+  removingBackgroundUuidsUpdated = _filesSlice$actions.removingBackgroundUuidsUpdated,
+  filesLoadingSet = _filesSlice$actions.filesLoadingSet,
+  filesSortingUpdated = _filesSlice$actions.filesSortingUpdated,
+  filesVariationsUpdated = _filesSlice$actions.filesVariationsUpdated;
+export { filesAdded, fileAdded, filesReplaced, filesRemoved, filesUpdated, fileUpdated, fileReplacedByNewer, removingBackgroundUuidsUpdated, filesLoadingSet, filesSortingUpdated, filesVariationsUpdated };
+export var selectFilesState = function selectFilesState(state) {
+  var _state$PLUGINS_IDS$EX;
+  return ((_state$PLUGINS_IDS$EX = state[PLUGINS_IDS.EXPLORER]) === null || _state$PLUGINS_IDS$EX === void 0 ? void 0 : _state$PLUGINS_IDS$EX[slicePropName]) || getInitialState();
+};
+
+// returns the files entities object that are relative to folder's/backend's files not searched nor being uploaded.
+export var selectFiles = function selectFiles(state) {
+  return selectFilesState(state).entities;
+};
+export var selectFilesArray = createSelector(selectFiles, function (files) {
+  return Object.values(files);
+});
+export var selectFilesUuids = function selectFilesUuids(state) {
+  return selectFilesState(state).uuids;
+};
+export var selectFilesStats = function selectFilesStats(state) {
+  return selectFilesState(state).stats;
+};
+export var selectFileByUuid = function selectFileByUuid(state, fileUuid) {
+  return selectFiles(state)[fileUuid];
+};
+export var selectFilesByUuids = createSelector([selectFiles, function (_state, fileUuids) {
+  return fileUuids;
+}], function (files, fileUuids) {
+  return fileUuids.map(function (fileUuid) {
+    return files[fileUuid];
+  });
+});
+export var selectIsFilesLoading = function selectIsFilesLoading(state) {
+  return selectFilesState(state).loading;
+};
+export var selectFilesOffset = function selectFilesOffset(state) {
+  return selectFilesState(state).offset;
+};
+export var selectIsNoMoreFiles = function selectIsNoMoreFiles(state) {
+  return selectFilesState(state).noMoreFiles;
+};
+export var selectCurrentFiles = function selectCurrentFiles(state) {
+  var isUploadsPanelShown = selectIsUploadsPanelOpened(state);
+  if (isUploadsPanelShown) {
+    return selectUploads(state);
+  }
+
+  // If search view (exact & extended) files, if filters only applied then deal with it as files normally.
+  if (selectIsSearchMode(state)) {
+    return selectAllSearchFiles(state);
+  }
+  return selectFiles(state);
+};
+export var selectCurrentFilesUuids = function selectCurrentFilesUuids(state) {
+  // If search view (exact & extended) files, if filters only applied then deal with it as files normally.
+  if (selectIsSearchMode(state) && !selectIsAiSearch(state)) {
+    return selectAllSearchFilesUuids(state);
+  }
+  return selectFilesUuids(state);
+};
+export var selectIsCurrentFilesLoading = function selectIsCurrentFilesLoading(state) {
+  // If search view (exact & extended) files, if filters only applied then deal with it as files normally.
+  if (selectIsSearchMode(state) && !selectIsAiSearch(state)) {
+    return selectIsQuickFetching(state) && selectIsQuickFetching(state);
+  }
+  return selectIsFilesLoading(state);
+};
+export var selectCurrentFilesIdsOrUuids = function selectCurrentFilesIdsOrUuids(state) {
+  var isUploadsPanelShown = selectIsUploadsPanelOpened(state);
+  if (isUploadsPanelShown) {
+    return selectUploadsIds(state);
+  }
+  return selectCurrentFilesUuids(state);
+};
+
+// Once files uploaded in contextual menu we need to get file data from server
+var getAlreadyUploadedFilesFromCurrentUploads = function getAlreadyUploadedFilesFromCurrentUploads(currentUploads) {
+  return Object.values(currentUploads).reduce(function (acc, currentFileInUpload) {
+    if (currentFileInUpload.response) {
+      var file = currentFileInUpload.response.body.file;
+      if (file !== null && file !== void 0 && file.uuid) {
+        acc[file.uuid] = file;
+      }
+    }
+    return acc;
+  }, {});
+};
+
+// Selectors for the file window/bulk edit modal...etc, as they are possible to be opened through upload panel or items' browser.
+// priority goes for uploads so if we found the passed files in uploads then use them instead of current files.
+export var selectCurrentFilesByIdsOrUuids = createSelector([function (state) {
+  return selectIsSearchOrFiltersMode(state);
+},
+// called like that to avoid initialization issue
+function (state) {
+  return selectAllSearchFiles(state);
+}, selectFiles, selectUploads, function (_state, filesIdsOrUuids) {
+  return filesIdsOrUuids;
+}], function (isSearchView, searchedFiles, files, uploads, filesIdsOrUuids) {
+  return (filesIdsOrUuids || []).map(function (idOrUuid) {
+    return isSearchView && searchedFiles[idOrUuid] || files[idOrUuid] || uploads[idOrUuid];
+  }).filter(Boolean);
+});
+export var selectCurrentFileByIdOrUuid = function selectCurrentFileByIdOrUuid(state, fileIdOrUuid) {
+  // In case it's not a string then we expect it to be file object.
+  if (typeof fileIdOrUuid !== 'string') return fileIdOrUuid;
+
+  // If in searchView find the file using fileIdOrUuid in the searched files
+  if (selectIsSearchOrFiltersMode(state)) {
+    var searchedFile = selectAllSearchFiles(state)[fileIdOrUuid];
+    // Return file if found in the searched files
+    if (searchedFile) return searchedFile;
+  }
+
+  // Find the file using fileIdOrUuid in the uploaded files
+  var files = selectFiles(state);
+  var selectedFile = files[fileIdOrUuid];
+
+  // Return file if found in the already uploaded files
+  if (selectedFile) return selectedFile;
+
+  // Find the file using fileIdOrUuid in the staging uploads
+  var uploads = selectUploads(state);
+  return uploads[fileIdOrUuid] || getAlreadyUploadedFilesFromCurrentUploads(uploads)[fileIdOrUuid] || selectCurrentTmpFile(state, fileIdOrUuid);
+};
+export var selectCurrentTmpFile = function selectCurrentTmpFile(state, fileUuid) {
+  var file = selectFilesState(state).tmpFile;
+  return !fileUuid || (file === null || file === void 0 ? void 0 : file.uuid) === fileUuid ? file : undefined;
+};
+export var selectCurrentFileByUuid = function selectCurrentFileByUuid(state, fileUuid) {
+  return selectExactSearchFileByUuid(state, fileUuid) || selectExtendedSearchFileByUuid(state, fileUuid) || selectFileByUuid(state, fileUuid) || selectCurrentTmpFile(state, fileUuid);
+};
+export var selectCurrentFilesArray = createSelector(selectCurrentFiles, function () {
+  var files = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return Object.values(files);
+});
+export var selectFilesSortedBy = function selectFilesSortedBy(state) {
+  return selectFilesState(state).sortedBy;
+};
+export var selectFilesSortOrder = function selectFilesSortOrder(state) {
+  return selectFilesState(state).sortOrder;
+};
+export var selectFilesError = function selectFilesError(state) {
+  return selectFilesState(state).error;
+};
+export var selectIsNoFilesFound = function selectIsNoFilesFound(state) {
+  var _selectCurrentFilesUu;
+  return ((_selectCurrentFilesUu = selectCurrentFilesUuids(state)) === null || _selectCurrentFilesUu === void 0 ? void 0 : _selectCurrentFilesUu.length) === 0;
+};
+export var selectFilesVariations = function selectFilesVariations(state) {
+  return selectFilesState(state).variations;
+};
+export var selectIsSearchOrFilesLoading = function selectIsSearchOrFilesLoading(state) {
+  return selectIsSearchMode(state) && !selectIsAiSearch(state) ? selectIsQuickFetching(state) || selectIsExtendFetching(state) : selectIsFilesLoading(state);
+};
+export default filesSlice.reducer;