@scaleflex/widget-explorer 4.4.0 → 4.5.1

package/lib/slices/search.slice.js

@@ -0,0 +1,995 @@
+var _excluded = ["searchQuery"],
+  _excluded2 = ["searchQuery", "offset", "replaceOldFiles", "skipPendingDispatch"],
+  _excluded3 = ["searchQuery", "offset", "replaceOldFiles", "skipPendingDispatch"],
+  _excluded4 = ["searchQuery", "id", "moreQueries", "offset", "limit", "withStats", "skipDispatch"];
+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 _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 _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 _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 _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 _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 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 { createSelector, createSlice, isAnyOf } from '@reduxjs/toolkit';
+import { FMAW_URL_QUERY_PARAMS, PLUGINS_IDS, SEARCH_METHODS } from '@scaleflex/widget-utils/lib/constants';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import getJsonParsedValue from '@scaleflex/widget-utils/lib/getJsonParsedValue';
+import getDecodedUriComponent from '@scaleflex/widget-utils/lib/getDecodedUriComponent';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import { resetSearchAndFiltersMode, searchOrListViewFiles, selectActiveViewItem, selectIsAssetsView, selectIsSearchMode, viewChanged } from './views.slice';
+import { fetchFiles, sliceName as filesSliceName, deleteFiles, filesLoadingSet, fetchFileByUuid, fileUpdated } from './files.slice';
+import { downloadOneFile } from '../thunks/downloads.thunks';
+import { activateAssetsView } from '../components/AssetsView/AssetsView.thunks';
+import { MODE_ID } from '../utils/SearchSuggestions';
+import { selectionsCleared } from './selections.slice';
+import decodeB64ToStr from '../utils/decodeB64ToStr';
+var slicePropName = 'search';
+var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+var FETCH_TYPES = {
+  LIST: 'LIST',
+  SEARCH: 'SEARCH'
+};
+var initialState = {
+  files: [],
+  folders: [],
+  defaultQuery: '',
+  query: '',
+  method: SEARCH_METHODS.QUICK,
+  fetchType: FETCH_TYPES.LIST,
+  isQuickFetching: true,
+  isExtendFetching: true,
+  isSending: false,
+  isAiSearch: false,
+  extendError: null,
+  quickError: null,
+  similar: {
+    originalFile: {},
+    active: false
+  },
+  stats: {
+    filesCount: 0,
+    filesCountMethod: null,
+    filesSize: 0
+  },
+  exactMatch: {
+    entities: {},
+    uuids: [],
+    offset: 0,
+    noMoreFiles: false
+  },
+  extended: {
+    entities: {},
+    uuids: [],
+    offset: 0,
+    noMoreFiles: false
+  },
+  suggestions: {
+    filters: [],
+    tags: [],
+    attributesKeys: [],
+    attributesKeysLoading: false,
+    attributesKeysLoadingFinished: false,
+    // Finished state necessary to mark that request was already sent. Otherwise there are issues with empty keys & tags
+    attributesTags: [],
+    attributesTagsLoading: false,
+    attributesTagsLoadingFinished: false
+  }
+};
+var SEARCH_PARAM_KEYS = {
+  QUERY: 'query',
+  TAGS: 'tags',
+  FILTERS: 'filters',
+  SIMILAR: 'similar',
+  AI: 'ai'
+};
+var setSearchParamsInUrl = createThunk(function (_, thunkApi) {
+  var _thunkApi$extra$filer = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    replaceUrlQueryParams = _thunkApi$extra$filer.replaceUrlQueryParams;
+  var state = thunkApi.getState();
+  var searchSuggestionsTags = selectSearchSuggestionsTags(state);
+  var searchSuggestionsFilters = selectSearchSuggestionsFilters(state);
+  var searchQuery = selectSearchQuery(state);
+  var similarSearchOriginalFile = selectSimilarSearchOriginalFile(state);
+  var isAiSearch = selectIsAiSearch(state);
+  var newSearch = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, SEARCH_PARAM_KEYS.QUERY, searchQuery), SEARCH_PARAM_KEYS.FILTERS, (searchSuggestionsFilters === null || searchSuggestionsFilters === void 0 ? void 0 : searchSuggestionsFilters.length) > 0 ? encodeURIComponent(JSON.stringify(searchSuggestionsFilters.map(function (filter) {
+    return [filter.key, filter.value];
+  }))) : undefined), SEARCH_PARAM_KEYS.TAGS, (searchSuggestionsTags === null || searchSuggestionsTags === void 0 ? void 0 : searchSuggestionsTags.length) > 0 ? searchSuggestionsTags.map(function (tag) {
+    return tag.input;
+  }) : undefined), SEARCH_PARAM_KEYS.SIMILAR, similarSearchOriginalFile !== null && similarSearchOriginalFile !== void 0 && similarSearchOriginalFile.uuid ? btoa(similarSearchOriginalFile.uuid) : undefined), SEARCH_PARAM_KEYS.AI, isAiSearch);
+  replaceUrlQueryParams({
+    params: newSearch,
+    keyPrefix: FMAW_URL_QUERY_PARAMS.SEARCH_PREFIX,
+    keysToDelete: [FMAW_URL_QUERY_PARAMS.SEARCH_PREFIX]
+  });
+});
+export var updateSearchQuery = createThunk(function (_ref, thunkApi) {
+  var query = _ref.query,
+    defaultQuery = _ref.defaultQuery,
+    _ref$noUrlUpdate = _ref.noUrlUpdate,
+    noUrlUpdate = _ref$noUrlUpdate === void 0 ? false : _ref$noUrlUpdate,
+    _ref$noInformer = _ref.noInformer,
+    noInformer = _ref$noInformer === void 0 ? false : _ref$noInformer;
+  var _thunkApi$extra$filer2 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    info = _thunkApi$extra$filer2.info,
+    i18n = _thunkApi$extra$filer2.i18n,
+    opts = _thunkApi$extra$filer2.opts;
+  var disableFiltersAndSearch = opts.disableFiltersAndSearch,
+    search = opts.search;
+  if (disableFiltersAndSearch && typeof (search === null || search === void 0 ? void 0 : search.query) !== 'undefined') {
+    if (!noInformer) {
+      info(i18n('explorerFiltersAndSearchDisabledWarning'), 'warning');
+    }
+    return;
+  }
+  thunkApi.dispatch(searchQueryUpdated({
+    query: query,
+    defaultQuery: defaultQuery
+  }));
+  if (!noUrlUpdate) {
+    thunkApi.dispatch(setSearchParamsInUrl());
+  }
+});
+export var searchByTag = createThunk(function (_ref2, thunkApi) {
+  var _tag$label;
+  var tag = _ref2.tag;
+  var tagLabel = (_tag$label = tag.label) !== null && _tag$label !== void 0 ? _tag$label : tag;
+  return thunkApi.dispatch(updateSearchSuggestions({
+    tags: [_objectSpread(_objectSpread({}, tag), {}, {
+      category: MODE_ID.TAG,
+      input: "\"#".concat(tagLabel, "\""),
+      name: tagLabel
+    })]
+  }));
+});
+export var submitSearch = createThunk(async function () {
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    searchQuery = _ref3.searchQuery,
+    rest = _objectWithoutProperties(_ref3, _excluded);
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState;
+  var state = getState();
+  var isNotSearchableViews = !selectActiveViewItem(state);
+  if (isNotSearchableViews) {
+    dispatch(filesLoadingSet(false)); // for making sure that no loading will be shown from files as we will use the loading from search
+    return dispatch(activateAssetsView({
+      keepFiltersAndSearch: true
+    }));
+  }
+
+  // exact and extended search
+  var searchArgs = _objectSpread(_objectSpread({}, rest), {}, {
+    searchQuery: searchQuery,
+    offset: 0
+  });
+  if (searchQuery) {
+    dispatch(updateSearchQuery({
+      query: searchQuery,
+      noInformer: true
+    }));
+  }
+  var _await$Promise$all = await Promise.all([dispatch(fetchQuickSearch(searchArgs)), dispatch(fetchExtendedFiles(searchArgs))]),
+    _await$Promise$all2 = _slicedToArray(_await$Promise$all, 2),
+    quickResult = _await$Promise$all2[0],
+    extendResult = _await$Promise$all2[1];
+  return {
+    quickResult: quickResult,
+    extendResult: extendResult
+  };
+});
+export var fetchQuickSearch = createThunk(async function (_ref4, thunkApi) {
+  var searchQuery = _ref4.searchQuery,
+    offset = _ref4.offset,
+    replaceOldFiles = _ref4.replaceOldFiles,
+    skipPendingDispatch = _ref4.skipPendingDispatch,
+    rest = _objectWithoutProperties(_ref4, _excluded2);
+  if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  return thunkApi.dispatch(triggerSearch(_objectSpread({
+    dispatchFn: thunkApi.dispatch,
+    searchQuery: searchQuery,
+    id: 'searchFilesQuick',
+    offset: offset !== null && offset !== void 0 ? offset : selectExactSearchOffset(thunkApi.getState()),
+    withStats: false,
+    replaceOldFiles: replaceOldFiles
+  }, rest)));
+}, {
+  actionType: "".concat(sliceName, "/quickSearch")
+});
+export var fetchExtendedFiles = createThunk(async function (_ref5, thunkApi) {
+  var searchQuery = _ref5.searchQuery,
+    offset = _ref5.offset,
+    replaceOldFiles = _ref5.replaceOldFiles,
+    skipPendingDispatch = _ref5.skipPendingDispatch,
+    rest = _objectWithoutProperties(_ref5, _excluded3);
+  if (skipPendingDispatch) {
+    thunkApi.skipPendingDispatch();
+  }
+  return thunkApi.dispatch(triggerSearch(_objectSpread({
+    dispatchFn: thunkApi.dispatch,
+    searchQuery: searchQuery,
+    id: 'searchFilesExtended',
+    offset: offset !== null && offset !== void 0 ? offset : selectExtendedSearchOffset(thunkApi.getState()),
+    limit: 2000,
+    moreQueries: {
+      method: SEARCH_METHODS.EXTENDED
+    },
+    replaceOldFiles: replaceOldFiles
+  }, rest)));
+}, {
+  actionType: "".concat(sliceName, "/fetchExtended")
+});
+var triggerSearch = function triggerSearch(_ref6) {
+  var searchQuery = _ref6.searchQuery,
+    id = _ref6.id,
+    moreQueries = _ref6.moreQueries,
+    offset = _ref6.offset,
+    limit = _ref6.limit,
+    _ref6$withStats = _ref6.withStats,
+    withStats = _ref6$withStats === void 0 ? true : _ref6$withStats,
+    _ref6$skipDispatch = _ref6.skipDispatch,
+    skipDispatch = _ref6$skipDispatch === void 0 ? true : _ref6$skipDispatch,
+    rest = _objectWithoutProperties(_ref6, _excluded4);
+  return fetchFiles(_objectSpread({
+    id: id,
+    queries: moreQueries,
+    offset: offset,
+    limit: limit,
+    recursive: true,
+    withStats: withStats,
+    debugSearch: localStorage.getItem('debug_search'),
+    skipDispatch: skipDispatch
+  }, rest));
+};
+
+// Used in infinite scrolling for search
+export var fetchNextQuickSearch = createThunk(function (_, thunkApi) {
+  var defaultSearchQuery = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER).opts.defaultSearchQuery;
+  var searchQuery = selectSearchQuery(thunkApi.getState());
+  return thunkApi.dispatch(fetchQuickSearch({
+    searchQuery: searchQuery || defaultSearchQuery,
+    replaceOldFiles: false,
+    skipPendingDispatch: true
+  }));
+});
+
+// Used in infinite scrolling for search
+export var fetchNextExtendedSearch = createThunk(function (_, thunkApi) {
+  var defaultSearchQuery = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER).opts.defaultSearchQuery;
+  var searchQuery = selectSearchQuery(thunkApi.getState());
+  return thunkApi.dispatch(fetchExtendedFiles({
+    searchQuery: searchQuery || defaultSearchQuery,
+    replaceOldFiles: false,
+    skipPendingDispatch: true
+  }));
+});
+export var getAttributesKeys = createThunk(async function (_, thunkApi) {
+  var extra = thunkApi.extra;
+  var _await$extra$apiClien = await extra.apiClient.get('attributes/keys'),
+    attributes = _await$extra$apiClien.attributes;
+  return attributes;
+}, {
+  actionType: "".concat(sliceName, "/getAttributesKeys")
+});
+export var getAttributesTags = createThunk(async function (_, thunkApi) {
+  var extra = thunkApi.extra;
+  var _await$extra$apiClien2 = await extra.apiClient.get('attributes/tags'),
+    attributes = _await$extra$apiClien2.attributes;
+  return attributes;
+}, {
+  actionType: "".concat(sliceName, "/getAttributesTags")
+});
+export var updateSearchSuggestions = createThunk(function (_ref7, thunkApi) {
+  var filters = _ref7.filters,
+    tags = _ref7.tags,
+    _ref7$dismissApiCall = _ref7.dismissApiCall,
+    dismissApiCall = _ref7$dismissApiCall === void 0 ? false : _ref7$dismissApiCall,
+    _ref7$noUrlUpdate = _ref7.noUrlUpdate,
+    noUrlUpdate = _ref7$noUrlUpdate === void 0 ? false : _ref7$noUrlUpdate;
+  var _thunkApi$extra$filer3 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER).opts,
+    disableFiltersAndSearch = _thunkApi$extra$filer3.disableFiltersAndSearch,
+    search = _thunkApi$extra$filer3.search;
+  if (disableFiltersAndSearch && search !== null && search !== void 0 && search.filters && search !== null && search !== void 0 && search.tags) {
+    return;
+  }
+  thunkApi.dispatch(searchSuggestionsUpdated({
+    filters: disableFiltersAndSearch && search.filters || filters,
+    tags: disableFiltersAndSearch && search.tags || tags
+  }));
+  if (!dismissApiCall) {
+    thunkApi.dispatch(searchOrListViewFiles({
+      withStats: true
+    }));
+  }
+  if (!noUrlUpdate) {
+    thunkApi.dispatch(setSearchParamsInUrl());
+  }
+});
+export var applyDefaultSearchQuery = createThunk(function (_, thunkApi) {
+  var dispatch = thunkApi.dispatch;
+  var _thunkApi$extra$filer4 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER).opts,
+    defaultSearchQuery = _thunkApi$extra$filer4.defaultSearchQuery,
+    onDefaultSearchQueryApplied = _thunkApi$extra$filer4.onDefaultSearchQueryApplied;
+  var trimmedValue = (defaultSearchQuery || '').trim();
+  dispatch(updateSearchQuery({
+    query: trimmedValue
+  }));
+  dispatch(submitSearch());
+  if (typeof onDefaultSearchQueryApplied === 'function') {
+    onDefaultSearchQueryApplied();
+  }
+});
+export var listSearchedAssetsAsCSV = createThunk(async function () {
+  var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref8$includeMeta = _ref8.includeMeta,
+    includeMeta = _ref8$includeMeta === void 0 ? 1 : _ref8$includeMeta;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState;
+  var state = getState();
+  var searchQuery = selectSearchQuery(state);
+  dispatch(downloadOneFile({
+    downloadedFileName: "".concat(searchQuery || 'Filtered results', ".csv"),
+    dismissUsageRights: true,
+    request: dispatch(fetchFiles({
+      offset: 0,
+      recursive: Boolean(searchQuery),
+      queries: {
+        method: SEARCH_METHODS.EXTENDED,
+        include_meta: includeMeta
+      },
+      limit: 2000,
+      format: 'csv',
+      withStats: false,
+      returnBlob: true,
+      skipDispatch: true,
+      xhrOptions: {
+        headers: {
+          'Content-Type': 'text/csv'
+        },
+        responseType: 'blob'
+      },
+      applyActiveViewItemCheck: false
+    }))
+  }));
+});
+
+// extracts the file/files uuids/objects from the extra reducer action (payload/meta)
+var getFilesFromExtraReducerAction = function getFilesFromExtraReducerAction(filesWrapper) {
+  var moreProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var files = _typeof(filesWrapper) === 'object' && !Array.isArray(filesWrapper) ? filesWrapper.uuid || filesWrapper.fileUuid || filesWrapper.uuids || filesWrapper.filesUuids || filesWrapper.files : filesWrapper;
+  var isMultipleFiles = Array.isArray(files);
+  if (!isMultipleFiles) {
+    files = _objectSpread({
+      uuid: files
+    }, _typeof(moreProps) === 'object' && moreProps); // filesWrapper should be
+  }
+  return isMultipleFiles ? files : [files];
+};
+var getTagAttributeFromTagInput = function getTagAttributeFromTagInput(tagInput) {
+  return {
+    category: MODE_ID.TAG,
+    input: tagInput,
+    name: tagInput.replace(/[#"]/g, '')
+  };
+};
+var loadFiltersAndSearchFromUrl = createThunk(async function (_ref9, thunkApi) {
+  var _searchQueryObject$SE;
+  var searchQueryObject = _ref9.searchQueryObject,
+    triggerApi = _ref9.triggerApi;
+  var searchFilters = searchQueryObject[SEARCH_PARAM_KEYS.FILTERS];
+  var parsedSearchFilters = Array.isArray(searchFilters) && typeof searchFilters[0] === 'string' ? getJsonParsedValue(getDecodedUriComponent(searchFilters[0])) : searchFilters;
+  var similarSearch = searchQueryObject[SEARCH_PARAM_KEYS.SIMILAR];
+  var aiSearch = searchQueryObject[SEARCH_PARAM_KEYS.AI];
+  var query = searchQueryObject[SEARCH_PARAM_KEYS.QUERY];
+  var mappedSearch = {
+    query: Array.isArray(query) && query[0] || query || '',
+    similar: !similarSearch && {
+      originalFile: {},
+      active: false
+    },
+    isAiSearch: aiSearch,
+    suggestions: _objectSpread(_objectSpread({}, selectSearchSuggestions(thunkApi.getState())), {}, {
+      tags: ((_searchQueryObject$SE = searchQueryObject[SEARCH_PARAM_KEYS.TAGS]) === null || _searchQueryObject$SE === void 0 ? void 0 : _searchQueryObject$SE.map(getTagAttributeFromTagInput)) || [],
+      filters: parsedSearchFilters ? (parsedSearchFilters === null || parsedSearchFilters === void 0 ? void 0 : parsedSearchFilters.map(function (_ref10) {
+        var _ref11 = _slicedToArray(_ref10, 2),
+          key = _ref11[0],
+          value = _ref11[1];
+        return {
+          key: key,
+          value: value
+        };
+      })) || [] : []
+    })
+  };
+  thunkApi.dispatch(searchStateUpdated(mappedSearch));
+  if (triggerApi) {
+    thunkApi.dispatch(searchOrListViewFiles({
+      withStats: true
+    }));
+  }
+  thunkApi.dispatch(setSearchParamsInUrl());
+});
+export var loadSearchFromOutside = createThunk(function () {
+  var _ref12 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref12$fromUrl = _ref12.fromUrl,
+    fromUrl = _ref12$fromUrl === void 0 ? false : _ref12$fromUrl,
+    _ref12$triggerApi = _ref12.triggerApi,
+    triggerApi = _ref12$triggerApi === void 0 ? false : _ref12$triggerApi;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var _thunkApi$extra$filer5 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    opts = _thunkApi$extra$filer5.opts,
+    getQueryParamsAsObject = _thunkApi$extra$filer5.getQueryParamsAsObject;
+  var disableFiltersAndSearch = opts.disableFiltersAndSearch,
+    search = opts.search;
+  var newSearch = disableFiltersAndSearch && search || !fromUrl ? search : _objectSpread(_objectSpread({}, search), getQueryParamsAsObject({
+    keyPrefix: FMAW_URL_QUERY_PARAMS.SEARCH_PREFIX,
+    returnValueOnly: true
+  }));
+  if (newSearch) {
+    var similarSearch = newSearch[SEARCH_PARAM_KEYS.SIMILAR];
+    if (similarSearch) {
+      var fileUuid = decodeB64ToStr(similarSearch[0]);
+      return thunkApi.dispatch(searchSimilarFiles({
+        fileUuid: fileUuid,
+        fromUrl: fromUrl
+      }));
+    }
+    thunkApi.dispatch(loadFiltersAndSearchFromUrl({
+      searchQueryObject: newSearch,
+      triggerApi: triggerApi
+    }));
+  }
+});
+export var searchFilesWithAiText = createThunk(async function (_ref13, thunkApi) {
+  var _thunkApi$extra$filer6;
+  var _ref13$searchQuery = _ref13.searchQuery,
+    searchQuery = _ref13$searchQuery === void 0 ? '' : _ref13$searchQuery;
+  var sourceLanguage = ((_thunkApi$extra$filer6 = thunkApi.extra.filerobot.opts) === null || _thunkApi$extra$filer6 === void 0 ? void 0 : _thunkApi$extra$filer6.language) || 'en';
+  var response = await thunkApi.extra.apiClient.post("ml/images/embedding/text?source_lang=".concat(sourceLanguage), {
+    data: {
+      text: searchQuery,
+      ref_key: 'uuid'
+    }
+  });
+  var files = (response === null || response === void 0 ? void 0 : response.files) || [];
+  return {
+    files: files,
+    stats: {
+      filesCount: files.length
+    }
+  };
+}, {
+  actionType: "".concat(sliceName, "/searchFilesWithAiText")
+});
+export var searchSimilarFiles = createThunk(async function (_ref14, thunkApi) {
+  var file = _ref14.file,
+    fileUuid = _ref14.fileUuid,
+    fromUrl = _ref14.fromUrl;
+  var originalFile = fileUuid ? {
+    uuid: fileUuid,
+    loading: true
+  } : file;
+  if (fileUuid) {
+    thunkApi.dispatch(searchSimilarToggled(true));
+    thunkApi.dispatch(fetchFileByUuid({
+      uuid: fileUuid
+    })).then(function (res) {
+      originalFile = res;
+      thunkApi.dispatch(fileUpdated(_objectSpread(_objectSpread({}, res), {}, {
+        loading: false
+      })));
+      thunkApi.dispatch(searchSimilarOriginalFileUpdated(res));
+    })["catch"](function (error) {
+      thunkApi.dispatch(searchSimilarOriginalFileUpdated({
+        uuid: fileUuid,
+        error: error
+      }));
+    });
+  }
+  thunkApi.dispatch(selectionsCleared());
+  thunkApi.dispatch(resetSearchAndFiltersMode());
+  var isAssetView = selectIsAssetsView(thunkApi.getState());
+  if (!isAssetView) {
+    thunkApi.dispatch(activateAssetsView({
+      keepFiltersAndSearch: true,
+      disableApiCall: true,
+      fromUrl: fromUrl
+    }));
+  }
+  thunkApi.dispatch(searchSimilarOriginalFileUpdated(originalFile));
+  thunkApi.dispatch(setSearchParamsInUrl());
+  var response = await thunkApi.extra.apiClient.post('ml/images/embedding/image', {
+    data: {
+      ref_key: 'uuid',
+      ref: originalFile.uuid
+    },
+    abortSignal: thunkApi.signal
+  });
+  var newFiles = [originalFile].concat(_toConsumableArray(response === null || response === void 0 ? void 0 : response.files));
+  return {
+    files: newFiles,
+    replaceOldFiles: true,
+    stats: {
+      filesCount: newFiles.length
+    },
+    overrideLoading: true
+  };
+}, {
+  actionType: "".concat(sliceName, "/searchSimilarFiles")
+});
+export var toggleAiSearch = createThunk(function (_, thunkApi) {
+  var state = thunkApi.getState();
+  var isAiSearch = selectIsAiSearch(state);
+  thunkApi.dispatch(aiSearchToggled(!isAiSearch));
+  thunkApi.dispatch(setSearchParamsInUrl());
+});
+var searchSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    searchQueryUpdated: function searchQueryUpdated(state, action) {
+      var _action$payload$query, _action$payload$defau;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        query: (_action$payload$query = action.payload.query) !== null && _action$payload$query !== void 0 ? _action$payload$query : state.query,
+        defaultQuery: (_action$payload$defau = action.payload.defaultQuery) !== null && _action$payload$defau !== void 0 ? _action$payload$defau : state.defaultQuery
+      });
+    },
+    exactAndExtendedFilesAdded: function exactAndExtendedFilesAdded(state, action) {
+      var _ref15 = action.payload || {},
+        _ref15$files = _ref15.files,
+        files = _ref15$files === void 0 ? [] : _ref15$files,
+        noMoreFiles = _ref15.noMoreFiles,
+        newOffset = _ref15.newOffset,
+        isExtendedSearch = _ref15.isExtendedSearch,
+        _ref15$replaceOldFile = _ref15.replaceOldFiles,
+        replaceOldFiles = _ref15$replaceOldFile === void 0 ? true : _ref15$replaceOldFile;
+      var newExactMatchFiles = _objectSpread({}, state.isQuickFetching && replaceOldFiles ? {} : state.exactMatch.entities);
+      var newExtendedFiles = _objectSpread({}, state.isExtendFetching && replaceOldFiles ? {} : state.extended.entities);
+      files.forEach(function (file) {
+        (file.relevance === 1 ? newExactMatchFiles : newExtendedFiles)[file.uuid] = file;
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        exactMatch: _objectSpread(_objectSpread({}, state.exactMatch), {}, {
+          entities: newExactMatchFiles,
+          uuids: Object.keys(newExactMatchFiles)
+        }, !isExtendedSearch && {
+          offset: newOffset,
+          noMoreFiles: noMoreFiles
+        }),
+        extended: _objectSpread(_objectSpread({}, state.extended), {}, {
+          entities: newExtendedFiles,
+          uuids: Object.keys(newExtendedFiles)
+        }, isExtendedSearch && {
+          offset: newOffset,
+          noMoreFiles: noMoreFiles
+        })
+      });
+    },
+    exactAndExtendedFilesUpdated: function exactAndExtendedFilesUpdated(state, action) {
+      var _action$payload = action.payload,
+        files = _action$payload.files,
+        mutualUpdates = _action$payload.mutualUpdates;
+      var newExactMatchFiles = state.exactMatch.entities;
+      var newExtendedFiles = state.extended.entities;
+      var getUpdatedFilesSection = function getUpdatedFilesSection(filesSection, fileUuid, file) {
+        return _objectSpread(_objectSpread({}, filesSection), {}, _defineProperty({}, fileUuid, _objectSpread(_objectSpread(_objectSpread({}, filesSection[fileUuid]), _typeof(file) === 'object' && file), mutualUpdates)));
+      };
+      var filesArray = Array.isArray(files) ? files : [files];
+      var isAnyFileFound = false;
+      filesArray.forEach(function (file) {
+        var fileUuid = _typeof(file) === 'object' ? file.uuid : file;
+        if (newExactMatchFiles[fileUuid]) {
+          newExactMatchFiles = getUpdatedFilesSection(newExactMatchFiles, fileUuid, file);
+          isAnyFileFound = true;
+        }
+        if (newExtendedFiles[fileUuid]) {
+          newExtendedFiles = getUpdatedFilesSection(newExtendedFiles, fileUuid, file);
+          isAnyFileFound = true;
+        }
+      });
+
+      // Don't update the state if no file was found
+      if (!isAnyFileFound) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        exactMatch: _objectSpread(_objectSpread({}, state.exactMatch), {}, {
+          entities: newExactMatchFiles
+        }),
+        extended: _objectSpread(_objectSpread({}, state.extended), {}, {
+          entities: newExtendedFiles
+        })
+      });
+    },
+    exactAndExtendedFilesRemoved: function exactAndExtendedFilesRemoved(state, action) {
+      var removedFileUuids = action.payload;
+      if (!removedFileUuids) {
+        return state;
+      }
+      if (Array.isArray(removedFileUuids) && removedFileUuids.length === 0) {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          exactMatch: initialState.exactMatch,
+          extended: initialState.extended,
+          stats: initialState.stats
+        });
+      }
+      var removeFileFromFilesSection = function removeFileFromFilesSection(filesSection, fileUuid) {
+        var newFilesSection = _objectSpread(_objectSpread({}, filesSection), {}, {
+          entities: _objectSpread({}, filesSection.entities),
+          uuids: filesSection.uuids.filter(function (uuid) {
+            return fileUuid !== uuid;
+          })
+        });
+        delete newFilesSection.entities[fileUuid];
+        return newFilesSection;
+      };
+      var exactMatch = state.exactMatch,
+        extended = state.extended;
+      removedFileUuids.forEach(function (fileUuid) {
+        if (exactMatch.entities[fileUuid]) {
+          exactMatch = removeFileFromFilesSection(exactMatch, fileUuid);
+        } else if (extended.entities[fileUuid]) {
+          extended = removeFileFromFilesSection(extended, fileUuid);
+        }
+      });
+
+      // Don't change the state as long as no changes in the object reference which means no files have been deleted.
+      if (exactMatch === state.exactMatch && extended === state.extended) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        exactMatch: exactMatch,
+        extended: extended,
+        stats: _objectSpread(_objectSpread({}, state.stats), {}, {
+          filesCount: Math.max(0, state.stats.filesCount - removedFileUuids.length)
+        })
+      });
+    },
+    suggestionsAttributeKeysUpdated: function suggestionsAttributeKeysUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesKeys: action.payload || initialState.suggestions.attributesKeys,
+          attributesKeysLoading: false
+        })
+      });
+    },
+    suggestionsAttributeTagsUpdated: function suggestionsAttributeTagsUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesTags: action.payload || initialState.suggestions.attributesKeys,
+          attributesTagsLoading: false
+        })
+      });
+    },
+    searchSuggestionsUpdated: function searchSuggestionsUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          filters: action.payload.filters || state.suggestions.filters,
+          tags: action.payload.tags || state.suggestions.tags
+        })
+      });
+    },
+    searchSending: function searchSending(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isSending: action.payload
+      });
+    },
+    searchStateUpdated: function searchStateUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    },
+    aiSearchToggled: function aiSearchToggled(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isAiSearch: action.payload
+      });
+    },
+    searchSimilarOriginalFileUpdated: function searchSimilarOriginalFileUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        similar: _objectSpread(_objectSpread({}, state.similar), {}, {
+          originalFile: action.payload,
+          active: true
+        })
+      });
+    },
+    searchSimilarToggled: function searchSimilarToggled(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        similar: _objectSpread(_objectSpread({}, state.similar), {}, {
+          active: action.payload
+        })
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(viewChanged.type, function (state, action) {
+      if (!action.payload.keepFiltersAndSearch) {
+        return searchSlice.caseReducers.searchStateUpdated(state, {
+          payload: {
+            query: '',
+            defaultQuery: '',
+            similar: {
+              originalFile: {},
+              active: false
+            },
+            isAiSearch: false,
+            suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+              tags: [],
+              filters: []
+            })
+          }
+        });
+      }
+    }).addCase(fetchExtendedFiles.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isExtendFetching: true,
+        extendError: null
+      });
+    }).addCase(fetchExtendedFiles.fulfilled, function (state, action) {
+      return _objectSpread(_objectSpread({}, searchSlice.caseReducers.exactAndExtendedFilesAdded(state, {
+        payload: _objectSpread(_objectSpread({}, action.payload), {}, {
+          isExtendedSearch: true
+        })
+      })), {}, {
+        isExtendFetching: false,
+        extendError: null
+      });
+    }).addCase(fetchExtendedFiles.rejected, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isExtendFetching: false,
+        extendError: getActionErrorState(state, action, true)
+      });
+    }).addCase(fetchQuickSearch.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isQuickFetching: true,
+        quickError: null
+      });
+    }).addCase(fetchQuickSearch.fulfilled, function (state, action) {
+      return _objectSpread(_objectSpread({}, searchSlice.caseReducers.exactAndExtendedFilesAdded(state, action)), {}, {
+        isQuickFetching: false,
+        quickError: null,
+        method: SEARCH_METHODS.QUICK
+      });
+    }).addCase(fetchQuickSearch.rejected, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        isQuickFetching: false,
+        quickError: getActionErrorState(state, action, true)
+      });
+    }).addCase(deleteFiles.fulfilled, function (state, action) {
+      return searchSlice.caseReducers.exactAndExtendedFilesRemoved(state, action);
+    }).addCase(getAttributesKeys.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesKeysLoading: true
+        }),
+        error: null
+      });
+    }).addCase(getAttributesKeys.fulfilled, function (state, action) {
+      return searchSlice.caseReducers.suggestionsAttributeKeysUpdated(state, action);
+    }).addCase(getAttributesKeys.rejected, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesKeysLoading: false
+        }),
+        error: getActionErrorState(state, action, true)
+      });
+    }).addCase(getAttributesKeys["final"], function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesKeysLoadingFinished: true
+        })
+      });
+    }).addCase(getAttributesTags.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesTagsLoading: true
+        }),
+        error: null
+      });
+    }).addCase(getAttributesTags.fulfilled, function (state, action) {
+      return searchSlice.caseReducers.suggestionsAttributeTagsUpdated(state, action);
+    }).addCase(getAttributesTags.rejected, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesTagsLoading: false
+        }),
+        error: getActionErrorState(state, action, true)
+      });
+    }).addCase(getAttributesTags["final"], function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        suggestions: _objectSpread(_objectSpread({}, state.suggestions), {}, {
+          attributesTagsLoadingFinished: true
+        })
+      });
+    }).addMatcher(isAnyOf(fetchFiles.fulfilled, fetchQuickSearch.fulfilled, fetchExtendedFiles.fulfilled), function (state, action) {
+      var _action$payload2;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        fetchType: (_action$payload2 = action.payload) === null || _action$payload2 === void 0 ? void 0 : _action$payload2.fetchType
+      });
+    })
+    // We are using filesSliceName as the actions triggered are mainly using its slice name, as it's the main one.
+    .addMatcher(function (_ref16) {
+      var type = _ref16.type;
+      return type.startsWith(filesSliceName) && Boolean(type.match(/\/updateFile(s?).*\/pending/));
+    }, function (state, action) {
+      return searchSlice.caseReducers.exactAndExtendedFilesUpdated(state, {
+        payload: {
+          files: getFilesFromExtraReducerAction(action.meta.arg),
+          mutualUpdates: {
+            loading: true,
+            error: null
+          }
+        }
+      });
+    })
+    // We are using filesSliceName as the actions triggered are mainly using its slice name, as it's the main one.
+    .addMatcher(function (_ref17) {
+      var type = _ref17.type;
+      return type.startsWith(filesSliceName) && Boolean(type.match(/\/updateFile(s?).*\/fulfilled/));
+    }, function (state, action) {
+      return searchSlice.caseReducers.exactAndExtendedFilesUpdated(state, {
+        payload: {
+          files: getFilesFromExtraReducerAction(action.payload, action.payload),
+          mutualUpdates: {
+            loading: false,
+            error: null
+          }
+        }
+      });
+    })
+    // We are using filesSliceName as the actions triggered are mainly using its slice name, as it's the main one.
+    .addMatcher(function (_ref18) {
+      var type = _ref18.type;
+      return type.startsWith(filesSliceName) && Boolean(type.match(/\/updateFile(s?).*\/rejected/));
+    }, function (state, action) {
+      return searchSlice.caseReducers.exactAndExtendedFilesUpdated(state, {
+        payload: {
+          files: getFilesFromExtraReducerAction(action.meta.arg),
+          mutualUpdates: {
+            loading: false,
+            error: getActionErrorState(state, action, true)
+          }
+        }
+      });
+    });
+  }
+});
+var _searchSlice$actions = searchSlice.actions,
+  searchQueryUpdated = _searchSlice$actions.searchQueryUpdated,
+  exactAndExtendedFilesAdded = _searchSlice$actions.exactAndExtendedFilesAdded,
+  exactAndExtendedFilesUpdated = _searchSlice$actions.exactAndExtendedFilesUpdated,
+  exactAndExtendedFilesRemoved = _searchSlice$actions.exactAndExtendedFilesRemoved,
+  searchSuggestionsUpdated = _searchSlice$actions.searchSuggestionsUpdated,
+  searchSending = _searchSlice$actions.searchSending,
+  searchStateUpdated = _searchSlice$actions.searchStateUpdated,
+  aiSearchToggled = _searchSlice$actions.aiSearchToggled,
+  searchSimilarOriginalFileUpdated = _searchSlice$actions.searchSimilarOriginalFileUpdated,
+  searchSimilarToggled = _searchSlice$actions.searchSimilarToggled;
+export { searchQueryUpdated, exactAndExtendedFilesAdded, exactAndExtendedFilesUpdated, exactAndExtendedFilesRemoved, searchSuggestionsUpdated, searchSending, searchStateUpdated, aiSearchToggled, searchSimilarOriginalFileUpdated, searchSimilarToggled };
+export var selectSearchState = function selectSearchState(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 || initialState;
+};
+export var selectSearchQuery = function selectSearchQuery(state) {
+  return selectSearchState(state).query;
+};
+export var selectExactSearchFiles = function selectExactSearchFiles(state) {
+  return selectSearchState(state).exactMatch.entities;
+};
+export var selectExactSearchOffset = function selectExactSearchOffset(state) {
+  return selectSearchState(state).exactMatch.offset;
+};
+export var selectIsNoMoreExactSearch = function selectIsNoMoreExactSearch(state) {
+  return selectSearchState(state).exactMatch.noMoreFiles;
+};
+export var selectExtendedSearchFiles = function selectExtendedSearchFiles(state) {
+  return selectSearchState(state).extended.entities;
+};
+export var selectExtendedSearchOffset = function selectExtendedSearchOffset(state) {
+  return selectSearchState(state).extended.offset;
+};
+export var selectIsNoMoreExtendedSearch = function selectIsNoMoreExtendedSearch(state) {
+  return selectSearchState(state).extended.noMoreFiles;
+};
+export var selectExactSearchUuids = function selectExactSearchUuids(state) {
+  return selectSearchState(state).exactMatch.uuids;
+};
+export var selectExtendedSearchUuids = function selectExtendedSearchUuids(state) {
+  return selectSearchState(state).extended.uuids;
+};
+export var selectExactSearchFileByUuid = function selectExactSearchFileByUuid(state, fileUuid) {
+  return selectExactSearchFiles(state)[fileUuid];
+};
+export var selectExtendedSearchFileByUuid = function selectExtendedSearchFileByUuid(state, fileUuid) {
+  return selectExtendedSearchFiles(state)[fileUuid];
+};
+export var selectExactSearchFilesByUuids = createSelector([selectExactSearchFiles, function (_state, fileUuids) {
+  return fileUuids;
+}], function (files, fileUuids) {
+  return fileUuids.map(function (fileUuid) {
+    return files[fileUuid];
+  });
+});
+export var selectExtendedSearchFilesByUuids = createSelector([selectExtendedSearchFiles, function (_state, fileUuids) {
+  return fileUuids;
+}], function (files, fileUuids) {
+  return fileUuids.map(function (fileUuid) {
+    return files[fileUuid];
+  });
+});
+export var selectExactSearchFilesArray = function selectExactSearchFilesArray(state) {
+  return Object.values(selectExactSearchFiles(state));
+};
+export var selectExtendedSearchFilesArray = function selectExtendedSearchFilesArray(state) {
+  return Object.values(selectExtendedSearchFiles(state));
+};
+export var selectAllSearchFiles = createSelector([selectExactSearchFiles, selectExtendedSearchFiles], function (exactFiles, extendedFiles) {
+  return _objectSpread(_objectSpread({}, exactFiles), extendedFiles);
+});
+export var selectAllSearchFilesArray = createSelector(selectAllSearchFiles, function (allSearchFiles) {
+  return Object.values(allSearchFiles);
+});
+export var selectAllSearchFilesUuids = createSelector(selectExactSearchUuids, selectExtendedSearchUuids, function (exactSearchUuids, extendedSearchUuids) {
+  return [].concat(_toConsumableArray(exactSearchUuids), _toConsumableArray(extendedSearchUuids));
+});
+export var selectIsQuickFetching = function selectIsQuickFetching(state) {
+  return selectSearchState(state).isQuickFetching;
+};
+export var selectIsExtendFetching = function selectIsExtendFetching(state) {
+  return selectSearchState(state).isExtendFetching;
+};
+export var selectIsSendingSearch = function selectIsSendingSearch(state) {
+  return selectSearchState(state).isSending;
+};
+export var selectSearchSuggestions = function selectSearchSuggestions(state) {
+  return selectSearchState(state).suggestions;
+};
+export var selectSearchSuggestionsFilters = function selectSearchSuggestionsFilters(state) {
+  return selectSearchState(state).suggestions.filters;
+};
+export var selectSearchSuggestionsTags = function selectSearchSuggestionsTags(state) {
+  return selectSearchState(state).suggestions.tags;
+};
+export var selectDefaultSearchQuery = function selectDefaultSearchQuery(state) {
+  return selectSearchState(state).defaultQuery;
+};
+export var selectSearchSuggestionsAttributesKeys = function selectSearchSuggestionsAttributesKeys(state) {
+  return selectSearchState(state).suggestions.attributesKeys;
+};
+export var selectSearchSuggestionsAttributesKeysLoading = function selectSearchSuggestionsAttributesKeysLoading(state) {
+  return selectSearchState(state).suggestions.attributesKeysLoading;
+};
+export var selectSearchSuggestionsAttributesKeysLoadingFinished = function selectSearchSuggestionsAttributesKeysLoadingFinished(state) {
+  return selectSearchState(state).suggestions.attributesKeysLoadingFinished;
+};
+export var selectSearchSuggestionsAttributesTags = function selectSearchSuggestionsAttributesTags(state) {
+  return selectSearchState(state).suggestions.attributesTags;
+};
+export var selectSearchSuggestionsAttributesTagsLoading = function selectSearchSuggestionsAttributesTagsLoading(state) {
+  return selectSearchState(state).suggestions.attributesTagsLoading;
+};
+export var selectIsSearchFetchType = function selectIsSearchFetchType(state) {
+  return selectIsSearchMode(state) && selectSearchState(state).fetchType === FETCH_TYPES.SEARCH;
+};
+export var selectSearchSuggestionsAttributesTagsLoadingFinished = function selectSearchSuggestionsAttributesTagsLoadingFinished(state) {
+  return selectSearchState(state).suggestions.attributesTagsLoadingFinished;
+};
+export var selectIsAiSearch = function selectIsAiSearch(state) {
+  return selectSearchState(state).isAiSearch;
+};
+export var selectSimilarSearchOriginalFile = function selectSimilarSearchOriginalFile(state) {
+  return selectSearchState(state).similar.originalFile;
+};
+export var selectIsSimilarSearchActive = function selectIsSimilarSearchActive(state) {
+  return selectSearchState(state).similar.active;
+};
+export default searchSlice.reducer;