@scaleflex/widget-explorer 0.0.1

package/lib/slices/metadata.slice.js

@@ -0,0 +1,487 @@
+var _excluded = ["tag"],
+  _excluded2 = ["permissionModel"];
+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 _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 { createSelector, createSlice } from '@reduxjs/toolkit';
+import createThunk from '@scaleflex/widget-utils/lib/createThunk';
+import { METADATA_VERSIONS, PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+import isM1EdgyMetaVersion from '@scaleflex/widget-utils/lib/metadata/isM1EdgyMetaVersion';
+import isM0LegacyMetaVersion from '@scaleflex/widget-utils/lib/metadata/isM0LegacyMetaVersion';
+import getMetadataFieldVariantValue from '@scaleflex/widget-utils/lib/metadata/getMetadataFieldVariantValue';
+import deepMerge from '@scaleflex/widget-utils/lib/deepMerge';
+import { adaptMetadata, isMetaRegionalLanguagesGroupExists, regionalGroupsToArray, REGIONAL_VARIANT_TYPE } from '../components/metadata.adapter';
+import { sortFieldsByType } from '../utils/filters';
+import { selectIsSearchMode } from './views.slice';
+import { filesUpdated, selectCurrentFiles } from './files.slice';
+import { exactAndExtendedFilesUpdated } from './search.slice';
+var slicePropName = 'metadata';
+var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+var initialState = {
+  settings: {},
+  presets: [],
+  model: [],
+  regionalGroups: [],
+  forceFillingOnUpload: false,
+  regionalFilters: {},
+  // metadata regional variants filters
+  version: null,
+  showTags: false,
+  itemMetadataErrors: {},
+  isSubmitting: false,
+  activeRegionalLang: 'en',
+  languageGroup: [],
+  activeFacetedSearchMetadataFields: []
+};
+export var fetchMetaAndSettings = createThunk(async function (_ref, thunkApi) {
+  var _metadata$version, _fs$permission_model;
+  var updateMetaFromApi = _ref.updateMetaFromApi,
+    isTaggingEnabled = _ref.isTaggingEnabled;
+  var _await$thunkApi$extra = await thunkApi.extra.apiClient.get('settings', {
+      id: 'fetchSettings',
+      abortSignal: thunkApi.signal
+    }),
+    settings = _await$thunkApi$extra.settings,
+    metadata = _await$thunkApi$extra.metadata,
+    fs = _await$thunkApi$extra.fs,
+    presets = _await$thunkApi$extra.presets;
+  var changes = {
+    settings: settings !== null && settings !== void 0 ? settings : {},
+    version: (_metadata$version = metadata === null || metadata === void 0 ? void 0 : metadata.version) !== null && _metadata$version !== void 0 ? _metadata$version : null,
+    permissionModel: (_fs$permission_model = fs === null || fs === void 0 ? void 0 : fs.permission_model) !== null && _fs$permission_model !== void 0 ? _fs$permission_model : null,
+    presets: presets !== null && presets !== void 0 ? presets : []
+  };
+
+  // If we send metadata via configs, we don't need to update values from public settings API response
+  if (updateMetaFromApi) {
+    thunkApi.dispatch(metadataAdaptAndSet({
+      metadata: metadata,
+      isTaggingEnabled: isTaggingEnabled
+    }));
+  }
+  return changes;
+}, {
+  actionType: "".concat(sliceName, "/fetchMetaAndSettings")
+});
+export var applyBulkFilesPropertiesChanges = createThunk(async function (_ref2, thunkApi) {
+  var filesUuids = _ref2.filesUuids,
+    changes = _ref2.changes;
+  var signal = thunkApi.signal,
+    apiClient = thunkApi.extra.apiClient;
+  // prepare bulk request
+  var _await$apiClient$put = await apiClient.put('bulk/prepare', {
+      data: {
+        bulk: {
+          target: {
+            files_uuids: filesUuids
+          },
+          changes: changes
+        }
+      },
+      abortSignal: signal
+    }),
+    bulkUuid = _await$apiClient$put.bulk_uuid;
+
+  // Apply the bulk edit request.
+  var response = await apiClient.post("bulk/".concat(bulkUuid, "/apply"), {
+    abortSignal: signal
+  });
+  return response;
+});
+
+// if 1 meta field with {key & value} properties, then use updatedMetaField & activeMetadataValue.
+// otherwise, need to provide meta with multiple fields then use `overwrittenMeta`.
+export var updateBulkFilesMeta = createThunk(function (_ref3, thunkApi) {
+  var updatedMetaField = _ref3.updatedMetaField,
+    _ref3$overwrittenMeta = _ref3.overwrittenMeta,
+    overwrittenMeta = _ref3$overwrittenMeta === void 0 ? {} : _ref3$overwrittenMeta,
+    activeMetadataValue = _ref3.activeMetadataValue,
+    filesUuids = _ref3.filesUuids,
+    deepMergeMeta = _ref3.deepMergeMeta,
+    removeMeta = _ref3.removeMeta;
+  if (!filesUuids || !filesUuids.length) {
+    return;
+  }
+  var state = thunkApi.getState();
+  var currentFiles = selectCurrentFiles(state);
+  var updatedFiles = [];
+  var overwrittenMetaKeys = Object.keys(overwrittenMeta);
+  var updateFileMetaFn = function updateFileMetaFn(fileUuid, fileMeta) {
+    if (updatedMetaField) {
+      var metaFieldValue = updatedMetaField.value;
+      if (deepMergeMeta) {
+        var updatedMeta = _defineProperty({}, updatedMetaField.key, metaFieldValue);
+        var mergedValue = deepMerge(fileMeta, updatedMeta, {
+          considerArray: true,
+          removeFromArray: removeMeta,
+          dismissArrayIfSourceNotArray: removeMeta
+        });
+        fileMeta = mergedValue;
+      } else {
+        if (activeMetadataValue) {
+          fileMeta[updatedMetaField.key] = _objectSpread(_objectSpread({}, fileMeta[updatedMetaField.key]), {}, _defineProperty({}, activeMetadataValue, metaFieldValue));
+        } else fileMeta[updatedMetaField.key] = metaFieldValue;
+      }
+    } else {
+      overwrittenMetaKeys.forEach(function (key) {
+        fileMeta = _objectSpread(_objectSpread({}, fileMeta), {}, _defineProperty({}, key, typeof overwrittenMeta[key] === 'string' ? overwrittenMeta[key] : _objectSpread(_objectSpread({}, fileMeta[key]), overwrittenMeta[key])));
+      });
+    }
+    updatedFiles.push(_objectSpread(_objectSpread({}, currentFiles[fileUuid]), {}, {
+      meta: fileMeta
+    }));
+  };
+  filesUuids.forEach(function (fileUuid) {
+    var _currentFiles$fileUui;
+    var fileMeta = _objectSpread({}, (_currentFiles$fileUui = currentFiles[fileUuid]) === null || _currentFiles$fileUui === void 0 ? void 0 : _currentFiles$fileUui.meta);
+    updateFileMetaFn(fileUuid, fileMeta);
+  });
+  var isSearchMode = selectIsSearchMode(state);
+  thunkApi.dispatch(isSearchMode ? exactAndExtendedFilesUpdated({
+    files: updatedFiles
+  }) : filesUpdated(updatedFiles));
+  return updatedFiles;
+});
+export var updateBulkFilesTags = createThunk(function (_ref4, thunkApi) {
+  var addedTags = _ref4.addedTags,
+    removedTags = _ref4.removedTags,
+    currentLanguage = _ref4.currentLanguage,
+    filesUuids = _ref4.filesUuids;
+  if (!filesUuids || !filesUuids.length || !currentLanguage) {
+    return;
+  }
+  var state = thunkApi.getState();
+  var currentFiles = selectCurrentFiles(state);
+  var updatedFiles = [];
+  filesUuids.forEach(function (fileUuid) {
+    var _file$tags;
+    var file = currentFiles[fileUuid];
+    var currentFileTags = (_file$tags = file.tags) !== null && _file$tags !== void 0 ? _file$tags : {};
+    var fileTags = currentFileTags[currentLanguage] || [];
+    var adaptedFileTags = fileTags.filter(function (fileTag) {
+      return !removedTags.some(function (removedTag) {
+        return removedTag.label === fileTag.label;
+      });
+    });
+    var adaptedAddedTags = addedTags.filter(function (addedTag) {
+      return ![].concat(_toConsumableArray(fileTags), _toConsumableArray(removedTags)).some(function (_ref5) {
+        var label = _ref5.label;
+        return addedTag.label === label;
+      });
+    });
+    updatedFiles.push(_objectSpread(_objectSpread({}, file), {}, {
+      tags: _objectSpread(_objectSpread({}, currentFileTags), {}, _defineProperty({}, currentLanguage, [].concat(_toConsumableArray(adaptedFileTags), _toConsumableArray(adaptedAddedTags))))
+    }));
+  });
+  var isSearchMode = selectIsSearchMode(state);
+  thunkApi.dispatch(isSearchMode ? exactAndExtendedFilesUpdated({
+    files: updatedFiles
+  }) : filesUpdated(updatedFiles));
+  return updatedFiles;
+});
+export var updateBulkFilesLabels = createThunk(function () {
+  var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref6$addedLabels = _ref6.addedLabels,
+    addedLabels = _ref6$addedLabels === void 0 ? [] : _ref6$addedLabels,
+    _ref6$removedLabels = _ref6.removedLabels,
+    removedLabels = _ref6$removedLabels === void 0 ? [] : _ref6$removedLabels,
+    filesUuids = _ref6.filesUuids;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  if (!filesUuids || !filesUuids.length) {
+    return;
+  }
+  var state = thunkApi.getState();
+  var isSearchMode = selectIsSearchMode(state);
+  var currentFiles = selectCurrentFiles(state);
+  var updatedFiles = [];
+  filesUuids.forEach(function (fileUuid) {
+    var _file$labels;
+    var file = currentFiles[fileUuid];
+    var fileLabels = (_file$labels = file.labels) !== null && _file$labels !== void 0 ? _file$labels : [];
+    var adaptedFileLabels = fileLabels.filter(function (fileLabel) {
+      return !removedLabels.some(function (removedLabel) {
+        return removedLabel === fileLabel;
+      });
+    });
+    var adaptedAddedLabels = addedLabels.filter(function (addedLabel) {
+      return ![].concat(_toConsumableArray(fileLabels), _toConsumableArray(removedLabels)).some(function (label) {
+        return addedLabel === label;
+      });
+    });
+    updatedFiles.push(_objectSpread(_objectSpread({}, file), {}, {
+      labels: [].concat(_toConsumableArray(adaptedFileLabels), _toConsumableArray(adaptedAddedLabels))
+    }));
+  });
+  thunkApi.dispatch(isSearchMode ? exactAndExtendedFilesUpdated({
+    files: updatedFiles
+  }) : filesUpdated(updatedFiles));
+  return updatedFiles;
+});
+export var fetchMetadataTagsBySearchQuery = createThunk(async function (_ref7, thunkApi) {
+  var searchQuery = _ref7.searchQuery,
+    metadataFieldCKey = _ref7.metadataFieldCKey;
+  var metaKey = metadataFieldCKey ? "&meta_key=_".concat(metadataFieldCKey) : '';
+  var _await$thunkApi$extra2 = await thunkApi.extra.apiClient.get("metadata/autocomplete?q=".concat(searchQuery).concat(metaKey), {
+      id: 'generateTagsBySearchQuery',
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra3 = _await$thunkApi$extra2.tags,
+    tags = _await$thunkApi$extra3 === void 0 ? [] : _await$thunkApi$extra3;
+  if (Array.isArray(tags)) {
+    return tags.map(function (_ref8) {
+      var tag = _ref8.tag,
+        rest = _objectWithoutProperties(_ref8, _excluded);
+      return _objectSpread(_objectSpread({}, rest), {}, {
+        name: tag
+      });
+    });
+  }
+  return [];
+});
+
+// used only `cKey` or `apiKey`, first preference is cKey
+export var getMetadataFieldAndValue = createThunk(function (_ref9, thunkAPi) {
+  var fileMetadata = _ref9.fileMetadata,
+    cKey = _ref9.cKey,
+    apiKey = _ref9.apiKey,
+    regionalVariants = _ref9.regionalVariants;
+  if (!cKey && !apiKey || !fileMetadata || _typeof(fileMetadata) !== 'object' || Object.keys(fileMetadata).length === 0) {
+    return;
+  }
+  var metadataFields = selectMetadataFields(thunkAPi.getState(), false);
+  var field = metadataFields.find(function () {
+    var _ref10 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      fieldCKey = _ref10.ckey,
+      key = _ref10.key,
+      fieldApiKey = _ref10.apiKey;
+    return cKey && [fieldCKey, fieldApiKey].includes(cKey) || apiKey && [key, fieldApiKey].includes(apiKey);
+  });
+  if (!field) {
+    return;
+  }
+  var metaRegionalFilters = regionalVariants || selectMetadataRegionalFilters(thunkAPi.getState());
+  var fileMetaValue = fileMetadata[field.apiKey || field.key];
+  return {
+    field: field,
+    apiKey: field.apiKey,
+    value: fileMetaValue,
+    activeVariantValue: fileMetaValue && getMetadataFieldVariantValue({
+      value: fileMetaValue,
+      possibleValues: field.possible_values,
+      regionalVariantsGroupUuid: field.regional_variants_group_uuid,
+      metaRegionalFilters: metaRegionalFilters,
+      joinArrayValues: true
+    }),
+    regionalVariantsGroupUuid: field.regional_variants_group_uuid,
+    regionalVariantKey: metaRegionalFilters === null || metaRegionalFilters === void 0 ? void 0 : metaRegionalFilters[field.regional_variants_group_uuid]
+  };
+});
+var metadataSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    metadataUpdated: function metadataUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    },
+    metadataRegionalFiltersSet: function metadataRegionalFiltersSet(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        regionalFilters: action.payload
+      });
+    },
+    itemMetadataErrorsUpdated: function itemMetadataErrorsUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        itemMetadataErrors: action.payload
+      });
+    },
+    metadataAdaptAndSet: function metadataAdaptAndSet(state, _ref11) {
+      var _adaptedMetadata$stor, _adaptedMetadata$stor2, _adaptedMetadata$mode, _adaptedMetadata$stor3, _adaptedMetadata$stor4, _metadata$store, _metadata$version2;
+      var _ref11$payload = _ref11.payload,
+        metadata = _ref11$payload.metadata,
+        isTaggingEnabled = _ref11$payload.isTaggingEnabled;
+      var adaptedMetadata = adaptMetadata(metadata);
+      var regionalGroups = (_adaptedMetadata$stor = adaptedMetadata === null || adaptedMetadata === void 0 ? void 0 : (_adaptedMetadata$stor2 = adaptedMetadata.store) === null || _adaptedMetadata$stor2 === void 0 ? void 0 : _adaptedMetadata$stor2.regional_variants_groups) !== null && _adaptedMetadata$stor !== void 0 ? _adaptedMetadata$stor : [];
+      var regionalFilters = {};
+      regionalGroups.forEach(function (regionalGroup) {
+        var _regionalGroup$varian;
+        regionalFilters[regionalGroup.uuid] = (_regionalGroup$varian = regionalGroup.variants[0]) === null || _regionalGroup$varian === void 0 ? void 0 : _regionalGroup$varian.api_value;
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        model: (_adaptedMetadata$mode = adaptedMetadata === null || adaptedMetadata === void 0 ? void 0 : adaptedMetadata.model) !== null && _adaptedMetadata$mode !== void 0 ? _adaptedMetadata$mode : [],
+        forceFillingOnUpload: (_adaptedMetadata$stor3 = adaptedMetadata === null || adaptedMetadata === void 0 ? void 0 : (_adaptedMetadata$stor4 = adaptedMetadata.store) === null || _adaptedMetadata$stor4 === void 0 ? void 0 : _adaptedMetadata$stor4.force_filling_metadata_on_upload) !== null && _adaptedMetadata$stor3 !== void 0 ? _adaptedMetadata$stor3 : false,
+        // Here we use reg vars from response instead of adaptedMetadata, because it's important to have Languages rev var in DB, not generated in adaptor
+        showTags: isTaggingEnabled && isMetaRegionalLanguagesGroupExists(regionalGroupsToArray(metadata === null || metadata === void 0 ? void 0 : (_metadata$store = metadata.store) === null || _metadata$store === void 0 ? void 0 : _metadata$store.regional_variants_groups)),
+        regionalGroups: regionalGroups,
+        regionalFilters: regionalFilters,
+        version: (_metadata$version2 = metadata === null || metadata === void 0 ? void 0 : metadata.version) !== null && _metadata$version2 !== void 0 ? _metadata$version2 : null
+      });
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(fetchMetaAndSettings.fulfilled, function (state, _ref12) {
+      var _ref12$payload = _ref12.payload,
+        permissionModel = _ref12$payload.permissionModel,
+        payload = _objectWithoutProperties(_ref12$payload, _excluded2);
+      return _objectSpread(_objectSpread({}, state), payload);
+    });
+    // .addCase(
+    //   ({ type }) => type.startsWith(sliceName) && type.endsWith('/pending'),
+    //   (state, action) => ({ ...state, isSubmitting: true })
+    // )
+    // .addMatcher(
+    //   ({ type }) => type.startsWith(sliceName) && (type.endsWith('/final') || type.endsWith('/fulfilled')),
+    //   (state, action) => ({ ...state, isSubmitting: false })
+    // )
+  }
+});
+var _metadataSlice$action = metadataSlice.actions,
+  metadataUpdated = _metadataSlice$action.metadataUpdated,
+  metadataRegionalFiltersSet = _metadataSlice$action.metadataRegionalFiltersSet,
+  itemMetadataErrorsUpdated = _metadataSlice$action.itemMetadataErrorsUpdated,
+  metadataAdaptAndSet = _metadataSlice$action.metadataAdaptAndSet;
+export { metadataUpdated, metadataRegionalFiltersSet, itemMetadataErrorsUpdated, metadataAdaptAndSet };
+export var selectMetadata = function selectMetadata(state) {
+  var _state$PLUGINS_IDS$EX;
+  return ((_state$PLUGINS_IDS$EX = state[PLUGINS_IDS.EXPLORER]) === null || _state$PLUGINS_IDS$EX === void 0 ? void 0 : _state$PLUGINS_IDS$EX[slicePropName]) || initialState;
+};
+export var selectMetadataModel = function selectMetadataModel(state) {
+  return selectMetadata(state).model;
+};
+export var selectMetadataRegionalGroups = function selectMetadataRegionalGroups(state) {
+  return selectMetadata(state).regionalGroups;
+};
+export var selectMetadataForceFillingOnUpload = function selectMetadataForceFillingOnUpload(state) {
+  return selectMetadata(state).forceFillingOnUpload;
+};
+export var selectMetadataRegionalFilters = function selectMetadataRegionalFilters(state) {
+  return selectMetadata(state).regionalFilters;
+};
+export var selectMetadataVersion = function selectMetadataVersion(state) {
+  return selectMetadata(state).version || METADATA_VERSIONS.M0_LEGACY;
+};
+export var selectItemMetadataErrors = function selectItemMetadataErrors(state) {
+  return selectMetadata(state).itemMetadataErrors;
+};
+export var selectIsMetaSubmitting = function selectIsMetaSubmitting(state) {
+  return selectMetadata(state).isSubmitting;
+};
+export var selectShowTags = function selectShowTags(state) {
+  return selectMetadata(state).showTags;
+};
+export var selectIsM1EdgyMeta = function selectIsM1EdgyMeta(state) {
+  return isM1EdgyMetaVersion(selectMetadataVersion(state));
+};
+export var selectIsM0LegacyMeta = function selectIsM0LegacyMeta(state) {
+  return isM0LegacyMetaVersion(selectMetadataVersion(state));
+};
+export var selectLanguageGroup = function selectLanguageGroup(state) {
+  return selectMetadata(state).languageGroup;
+};
+export var selectPresets = function selectPresets(state) {
+  return selectMetadata(state).presets;
+};
+export var selectActiveFacetedSearchMetadataFields = function selectActiveFacetedSearchMetadataFields(state) {
+  return selectMetadata(state).activeFacetedSearchMetadataFields;
+};
+export var selectLanguageGroupUuid = function selectLanguageGroupUuid(state) {
+  var _selectMetadataRegion;
+  return (_selectMetadataRegion = selectMetadataRegionalGroups(state).find(function (_ref13) {
+    var type = _ref13.type;
+    return type === REGIONAL_VARIANT_TYPE.LANGUAGES;
+  })) === null || _selectMetadataRegion === void 0 ? void 0 : _selectMetadataRegion.uuid;
+};
+export var selectActiveRegionalLang = function selectActiveRegionalLang(state) {
+  return selectMetadataRegionalFilters(state)[selectLanguageGroupUuid(state)] || 'en';
+};
+export var selectMetadataFields = createSelector([selectMetadataModel, function (_state, filterRootFields) {
+  return filterRootFields;
+}], function (metadataModel) {
+  var filterRootFields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var _ref14 = (metadataModel || []).find(function (model) {
+      return model.applies_to === 'FILES';
+    }) || {},
+    _ref14$groups = _ref14.groups,
+    groups = _ref14$groups === void 0 ? [] : _ref14$groups;
+  var metadataGroups = groups.filter(function (_ref15) {
+    var _ref15$fields = _ref15.fields,
+      fields = _ref15$fields === void 0 ? [] : _ref15$fields,
+      isRoot = _ref15.isRoot;
+    return fields.length && (filterRootFields ? !isRoot : true);
+  });
+  var metadataFields = metadataGroups.map(function (group) {
+    return group.fields;
+  }).flat();
+  return metadataFields;
+});
+export var selectMetadataRootFieldsRegionalGroupUuids = createSelector([selectMetadataModel], function (metadataModel) {
+  var _ref16 = (metadataModel || []).find(function (model) {
+      return model.applies_to === 'FILES';
+    }) || {},
+    _ref16$groups = _ref16.groups,
+    groups = _ref16$groups === void 0 ? [] : _ref16$groups;
+  var fieldsRegionalUuidsByKey = {};
+  groups.forEach(function (_ref17) {
+    var _ref17$fields = _ref17.fields,
+      fields = _ref17$fields === void 0 ? [] : _ref17$fields,
+      isRoot = _ref17.isRoot;
+    if (isRoot && fields.length > 0) {
+      fields.forEach(function (field) {
+        fieldsRegionalUuidsByKey[field.key] = field.regional_variants_group_uuid;
+      });
+    }
+  });
+  return fieldsRegionalUuidsByKey;
+});
+export var selectMetadataRootFieldRegionalGroupUuidByKey = createSelector([selectMetadataRootFieldsRegionalGroupUuids, function (_state, apiKey) {
+  return apiKey;
+}], function () {
+  var fieldsRegionalUuidsByKey = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var apiKey = arguments.length > 1 ? arguments[1] : undefined;
+  return fieldsRegionalUuidsByKey === null || fieldsRegionalUuidsByKey === void 0 ? void 0 : fieldsRegionalUuidsByKey[apiKey];
+});
+export var selectSortedMetadataFields = createSelector([function (_state) {
+  var filterRootFields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  return selectMetadataFields(_state, filterRootFields);
+}], function (metadataFields) {
+  return sortFieldsByType(metadataFields);
+});
+export var selectFacetedSearchMetadataFields = createSelector([selectMetadataFields, selectActiveFacetedSearchMetadataFields], function (metadataFields, activeFacetedSearchMetadataFields) {
+  var filteredMetadataFields = metadataFields.filter(function (_ref18) {
+    var key = _ref18.key;
+    return activeFacetedSearchMetadataFields.includes(key);
+  });
+  return sortFieldsByType(filteredMetadataFields);
+});
+export var selectMetaMappedLicenseExpireDateField = createSelector(selectMetadataFields, function (metadataFields) {
+  return metadataFields.find(function () {
+    var _ref19 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      mapping = _ref19.mapping;
+    return mapping === 'license.s1:expiration_date';
+  });
+});
+export var selectMetadataFieldByKey = function selectMetadataFieldByKey(state, keyToFind) {
+  if (!keyToFind) {
+    return;
+  }
+  var metadataFields = selectMetadataFields(state);
+  return metadataFields.find(function () {
+    var _ref20 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      key = _ref20.key;
+    return key === keyToFind;
+  });
+};
+export var selectIsCdnPermalinkEnabled = function selectIsCdnPermalinkEnabled(state) {
+  var _selectMetadata, _selectMetadata$setti;
+  return (_selectMetadata = selectMetadata(state)) === null || _selectMetadata === void 0 ? void 0 : (_selectMetadata$setti = _selectMetadata.settings) === null || _selectMetadata$setti === void 0 ? void 0 : _selectMetadata$setti._cdn_permalink_enabled;
+};
+export default metadataSlice.reducer;