@scaleflex/widget-explorer 4.4.0 → 4.5.1

package/lib/slices/labels.slice.js

@@ -0,0 +1,652 @@
+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 _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 { VIEW_IDS, PLUGINS_IDS, FMAW_URL_QUERY_PARAMS } from '@scaleflex/widget-utils/lib/constants';
+import escapeRegExp from '@scaleflex/widget-utils/lib/escapeRegExp';
+import getActionErrorState from '@scaleflex/widget-utils/lib/getActionErrorState';
+import { filesRemoved, searchFilesService } from './files.slice';
+import { downloadOneFile, downloadItems } from '../thunks/downloads.thunks';
+import { selectIsLabelsView, changeView, searchOrListViewFiles, changeViewFetchFilesCachedQueries } from './views.slice';
+import { SORT_ORDER, SORT_BY } from '../components/common/Sort/Sort.constants';
+import { selectionsCleared } from './selections.slice';
+import { currentFolderUpdated } from './folders.slice';
+import { applyBulkFilesPropertiesChanges, updateBulkFilesLabels } from './metadata.slice';
+import { fileWindowUpdated } from './panels.slice';
+import { exactAndExtendedFilesRemoved } from './search.slice';
+
+// TODO: We are hardcoding file slice name as it causes initialization error
+var filesSliceName = 'Explorer/files';
+var slicePropName = 'labels';
+var sliceName = "".concat(PLUGINS_IDS.EXPLORER, "/").concat(slicePropName);
+var ATTACH_LABELS_TO_FILES_LIMIT = 250;
+var BULK_EDIT_LABELS_TYPES = {
+  ADD: 'labels.add',
+  DELETE: 'labels.del'
+};
+var initialState = {
+  uuids: [],
+  entities: {},
+  activeLabelUuid: null,
+  searchTerm: '',
+  selectedUuids: [],
+  sortOrder: SORT_ORDER.ASC,
+  sortedBy: SORT_BY.NAME,
+  loading: true,
+  showTree: true,
+  error: null
+};
+var checkIfReachedTheLimit = function checkIfReachedTheLimit(filesUuids) {
+  return filesUuids.length >= ATTACH_LABELS_TO_FILES_LIMIT;
+};
+var prepareBulkAttachedLabels = function prepareBulkAttachedLabels(type, labelsSids) {
+  return labelsSids.map(function (labelSid) {
+    return {
+      type: type,
+      value: labelSid
+    };
+  });
+};
+
+// Used only in enabling/opening/activating labels view, and possible to open a specific label after loading the view through its param.
+export var activateLabelsView = createThunk(async function () {
+  var _labels, _selectSortedLabelsUu;
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$itemToOpen = _ref.itemToOpen,
+    labelUuidOrSidToActivate = _ref$itemToOpen === void 0 ? null : _ref$itemToOpen,
+    _ref$skipViewDispatch = _ref.skipViewDispatch,
+    skipViewDispatch = _ref$skipViewDispatch === void 0 ? false : _ref$skipViewDispatch,
+    _ref$skipFetch = _ref.skipFetch,
+    skipFetch = _ref$skipFetch === void 0 ? false : _ref$skipFetch,
+    _ref$keepFiltersAndSe = _ref.keepFiltersAndSearch,
+    keepFiltersAndSearch = _ref$keepFiltersAndSe === void 0 ? false : _ref$keepFiltersAndSe,
+    _ref$fromUrl = _ref.fromUrl,
+    fromUrl = _ref$fromUrl === void 0 ? false : _ref$fromUrl;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    getState = thunkApi.getState,
+    signal = thunkApi.signal,
+    extra = thunkApi.extra;
+  var _extra$filerobot = extra.filerobot,
+    i18n = _extra$filerobot.i18n,
+    info = _extra$filerobot.info;
+  if (!skipViewDispatch) dispatch(changeView({
+    view: VIEW_IDS.LABELS,
+    keepFiltersAndSearch: keepFiltersAndSearch,
+    fromUrl: fromUrl
+  }));
+  dispatch(currentFolderUpdated({}));
+  dispatch(filesRemoved());
+  dispatch(exactAndExtendedFilesRemoved([]));
+  var labels;
+  if (!skipFetch) {
+    labels = await dispatch(fetchLabels({
+      abortSignal: signal
+    })).throwRejection();
+  }
+  var state = getState();
+  var foundLabel = labelUuidOrSidToActivate && (selectLabelByUuid(state, labelUuidOrSidToActivate) || ((_labels = labels) === null || _labels === void 0 ? void 0 : _labels.length) > 0 && labels.find(function () {
+    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      sid = _ref2.sid;
+    return sid === labelUuidOrSidToActivate;
+  }));
+  if (labelUuidOrSidToActivate && !foundLabel) {
+    info(i18n('labelsDefaultLabelError'), 'error', 3000);
+    dispatch(labelsStateUpdated({
+      error: {
+        message: i18n('labelsDefaultLabelError'),
+        details: i18n('labelsDefaultLabelErrorDescription')
+      }
+    }));
+    return;
+  }
+  var labelUuid = (foundLabel === null || foundLabel === void 0 ? void 0 : foundLabel.uuid) || ((_selectSortedLabelsUu = selectSortedLabelsUuids(state)) === null || _selectSortedLabelsUu === void 0 ? void 0 : _selectSortedLabelsUu[0]);
+  return labelUuid ? dispatch(activateLabel({
+    uuid: labelUuid,
+    fromUrl: fromUrl
+  })) : null;
+});
+export var toggleLabelsTree = createThunk(function (showTree, thunkApi) {
+  var newValue = showTree !== null && showTree !== void 0 ? showTree : !selectIsLabelsTreeOpened(thunkApi.getState());
+  thunkApi.dispatch(labelsStateUpdated({
+    showTree: newValue
+  }));
+  thunkApi.extra.filerobot.emit('labels-tree-trigger', newValue);
+  return newValue;
+});
+export var fetchLabelFiles = createThunk(async function () {
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    labelSid = _ref3.labelSid,
+    offset = _ref3.offset,
+    _ref3$replaceOldFiles = _ref3.replaceOldFiles,
+    replaceOldFiles = _ref3$replaceOldFiles === void 0 ? false : _ref3$replaceOldFiles,
+    sortBy = _ref3.sortBy,
+    sortOrder = _ref3.sortOrder,
+    _ref3$skipPending = _ref3.skipPending,
+    skipPending = _ref3$skipPending === void 0 ? true : _ref3$skipPending,
+    _ref3$abortSignal = _ref3.abortSignal,
+    abortSignal = _ref3$abortSignal === void 0 ? null : _ref3$abortSignal;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var state = thunkApi.getState();
+  var sid = labelSid || selectActiveLabelSid(state);
+  var result = await thunkApi.dispatch(searchOrListViewFiles({
+    cachedViewQueries: {
+      labels: sid.replace('#', ''),
+      recursive: true
+    },
+    offset: offset,
+    sorting: sortBy && sortOrder && [sortBy, sortOrder],
+    skipPendingDispatch: skipPending,
+    replaceOldFiles: replaceOldFiles,
+    abortSignal: abortSignal,
+    withStats: false
+  }));
+  return result;
+}, {
+  actionType: "".concat(sliceName, "/fetchLabelFiles")
+});
+export var activateFirstLabel = createThunk(function (_, thunkApi) {
+  var _labels$;
+  var labels = selectLabelsArray(thunkApi.getState());
+  return thunkApi.dispatch(activateLabel({
+    uuid: (_labels$ = labels[0]) === null || _labels$ === void 0 ? void 0 : _labels$.uuid
+  }));
+});
+export var activateLabel = createThunk(function (_ref4, thunkApi) {
+  var labelUuid = _ref4.uuid,
+    labelSid = _ref4.sid,
+    _ref4$abortSignal = _ref4.abortSignal,
+    abortSignal = _ref4$abortSignal === void 0 ? null : _ref4$abortSignal,
+    fromUrl = _ref4.fromUrl;
+  var state = thunkApi.getState();
+  if (!labelUuid) {
+    return;
+  }
+  if (!fromUrl) {
+    // Close file details panel when activate label, unless it's from url then don't close it as we might open file window from url in labels view
+    thunkApi.dispatch(fileWindowUpdated(null));
+  }
+  var isLabelsViewNotActivated = !selectIsLabelsView(state);
+  if (isLabelsViewNotActivated) {
+    thunkApi.dispatch(activateLabelsView({
+      itemToOpen: labelUuid
+    }));
+  } else {
+    var _thunkApi$extra$filer;
+    var _ref5 = labelSid ? {
+        sid: labelSid
+      } : selectLabelByUuid(state, labelUuid) || {},
+      _ref5$sid = _ref5.sid,
+      sid = _ref5$sid === void 0 ? '' : _ref5$sid;
+    if (!sid) {
+      return;
+    }
+    thunkApi.dispatch(labelActivated({
+      labelUuid: labelUuid,
+      selectedUuids: []
+    }));
+    // We are not awaiting for the request to finish, as we don't want to wait for it to finish to activate the label
+    (_thunkApi$extra$filer = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER)) === null || _thunkApi$extra$filer === void 0 ? void 0 : _thunkApi$extra$filer.updateViewQueryInUrl({
+      viewItem: sid
+    });
+    return thunkApi.dispatch(fetchLabelFiles({
+      labelSid: sid,
+      offset: 0,
+      skipPending: false,
+      abortSignal: abortSignal
+    }));
+  }
+});
+export var downloadLabelAssets = createThunk(async function (labelUuid, thunkApi) {
+  var _selectLabelByUuid;
+  var labelSid = (_selectLabelByUuid = selectLabelByUuid(thunkApi.getState(), labelUuid)) === null || _selectLabelByUuid === void 0 ? void 0 : _selectLabelByUuid.sid;
+  var _await$searchFilesSer = await searchFilesService({
+      filters: {
+        labels: [labelSid]
+      },
+      recursive: true
+    }, thunkApi),
+    _await$searchFilesSer2 = _await$searchFilesSer.files,
+    files = _await$searchFilesSer2 === void 0 ? [] : _await$searchFilesSer2;
+  return thunkApi.dispatch(files.length === 1 ? downloadOneFile({
+    file: files[0]
+  }) : downloadItems({
+    items: files
+  }));
+});
+export var fetchLabels = createThunk(async function () {
+  var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    avoidLabelsUpdate = _ref6.avoidLabelsUpdate;
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  if (avoidLabelsUpdate) {
+    thunkApi.skipDispatch();
+  }
+  var _await$thunkApi$extra = await thunkApi.extra.apiClient.get('labels', {
+      id: 'listLabels',
+      abortSignal: thunkApi.signal
+    }),
+    labels = _await$thunkApi$extra.labels;
+  return labels || [];
+}, {
+  actionType: "".concat(sliceName, "/fetchLabels")
+});
+export var createLabel = createThunk(async function (_ref7, thunkApi) {
+  var _ref7$label = _ref7.label,
+    label = _ref7$label === void 0 ? {} : _ref7$label,
+    _ref7$selectionUuids = _ref7.selectionUuids,
+    selectionUuids = _ref7$selectionUuids === void 0 ? [] : _ref7$selectionUuids;
+  /**
+  * !TODO: Once we have the whole new label object returned in the backend request's response, we should return the addedLabel const...
+  * then add a case for it in extraReducer to append that label to labels entities for enabling auto updating with no additional requests
+  * (FRA-2623)
+  */
+  var _await$thunkApi$extra2 = await thunkApi.extra.apiClient.post('labels', {
+      data: {
+        label: label
+      },
+      abortSignal: thunkApi.signal
+    }),
+    _await$thunkApi$extra3 = _await$thunkApi$extra2.label,
+    addedLabel = _await$thunkApi$extra3 === void 0 ? {} : _await$thunkApi$extra3;
+  var updatedLabels = await thunkApi.dispatch(fetchLabels({
+    avoidLabelsUpdate: true
+  }));
+  var newLabelUuid = addedLabel.uuid;
+  var newActiveLabel = (updatedLabels || []).find(function (label) {
+    return label.uuid === newLabelUuid;
+  }) || addedLabel;
+
+  // If we have files selection we need to add new label to those files and redirect to active label view
+  if (selectionUuids.length > 0 && newActiveLabel) {
+    await thunkApi.dispatch(attachFilesLabels({
+      filesUuids: selectionUuids,
+      labelsSids: [newActiveLabel.sid]
+    }));
+  }
+  return [newActiveLabel];
+}, {
+  actionType: "".concat(sliceName, "/createLabel")
+});
+export var updateLabelByUuid = createThunk(async function () {
+  var label = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var labelUuid = label.uuid;
+  /**
+  * !TODO: Once we have the whole label object returned in the backend request's response,
+  * then we shold un-comment the updatedLabel const & remove dispatched fetchLabels
+  * (FRA-2623)
+  */
+  // const { label: updatedLabel } = await thunkApi.extra.apiClient.put(
+  await thunkApi.extra.apiClient.put("labels/".concat(labelUuid), {
+    data: {
+      label: label
+    },
+    abortSignal: thunkApi.signal
+  });
+  var labels = await thunkApi.dispatch(fetchLabels({
+    avoidLabelsUpdate: true
+  }));
+  var updatedLabel = (labels || []).find(function (label) {
+    return label.uuid === labelUuid;
+  });
+  return updatedLabel;
+}, {
+  actionType: "".concat(sliceName, "/updateLabelByUuid")
+});
+export var deleteLabels = createThunk(async function () {
+  var labelsUuids = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var thunkApi = arguments.length > 1 ? arguments[1] : undefined;
+  var dispatch = thunkApi.dispatch,
+    extra = thunkApi.extra,
+    getState = thunkApi.getState;
+  var response = await thunkApi.extra.apiClient["delete"]('labels', {
+    data: {
+      labels: labelsUuids
+    },
+    abortSignal: thunkApi.signal
+  });
+  var _thunkApi$extra$filer2 = thunkApi.extra.filerobot.getPlugin(PLUGINS_IDS.EXPLORER),
+    deleteUrlQueryParams = _thunkApi$extra$filer2.deleteUrlQueryParams;
+  var state = getState();
+  var labelsSids = labelsUuids.map(function (labelUuid) {
+    var _selectLabelByUuid2;
+    return (_selectLabelByUuid2 = selectLabelByUuid(state, labelUuid)) === null || _selectLabelByUuid2 === void 0 ? void 0 : _selectLabelByUuid2.sid;
+  });
+  dispatch(labelsRemoved(labelsUuids));
+
+  // Deactivate label if it was deleted + remove all previously active label files + remove URL query param
+  var activeLabelUuid = selectActiveLabelUuid(getState());
+  if (activeLabelUuid && labelsUuids.includes(activeLabelUuid)) {
+    dispatch(filesRemoved());
+    dispatch(exactAndExtendedFilesRemoved([]));
+    dispatch(labelActivated({
+      labelUuid: null,
+      selectedUuids: []
+    }));
+    deleteUrlQueryParams([FMAW_URL_QUERY_PARAMS.VIEW_ITEM, FMAW_URL_QUERY_PARAMS.VIEW_SUB_ITEM]);
+    changeViewFetchFilesCachedQueries(null);
+  }
+  extra.filerobot.emit('objects-removed', labelsSids, 'labels');
+  return response;
+});
+export var applyBulkAttachedLabels = createThunk(async function (_ref8, thunkApi) {
+  var type = _ref8.type,
+    filesUuids = _ref8.filesUuids,
+    labelsSids = _ref8.labelsSids;
+  var dispatch = thunkApi.dispatch;
+  var changes = prepareBulkAttachedLabels(type, labelsSids);
+  var bulkEditPayload = {
+    filesUuids: filesUuids
+  };
+  if (type === BULK_EDIT_LABELS_TYPES.ADD) {
+    bulkEditPayload.addedLabels = labelsSids;
+  } else {
+    bulkEditPayload.removedLabels = labelsSids;
+  }
+  await dispatch(applyBulkFilesPropertiesChanges({
+    filesUuids: filesUuids,
+    changes: changes
+  }));
+  dispatch(updateBulkFilesLabels({
+    filesUuids: filesUuids,
+    addedLabels: labelsSids
+  }));
+});
+export var attachFilesLabels = createThunk(async function (_ref9, thunkApi) {
+  var _ref9$filesUuids = _ref9.filesUuids,
+    filesUuids = _ref9$filesUuids === void 0 ? [] : _ref9$filesUuids,
+    _ref9$labelsSids = _ref9.labelsSids,
+    labelsSids = _ref9$labelsSids === void 0 ? [] : _ref9$labelsSids;
+  if (checkIfReachedTheLimit(filesUuids)) {
+    thunkApi.dispatch(applyBulkAttachedLabels({
+      type: BULK_EDIT_LABELS_TYPES.ADD,
+      filesUuids: filesUuids,
+      labelsSids: labelsSids
+    }));
+    thunkApi.dispatch(selectionsCleared());
+    return;
+  }
+  var isOneFileOnly = filesUuids.length === 1;
+  // attach labels in files request (first case for single file and second for multiple files)
+  var response = await thunkApi.extra.apiClient.post(isOneFileOnly ? "files/".concat(filesUuids[0], "/labels") : 'files/labels',
+  // else case => Attaching N labels to M files
+  {
+    data: _objectSpread({
+      labels: labelsSids
+    }, !isOneFileOnly && {
+      files_uuids: filesUuids
+    })
+  });
+  return response.files || [response.file];
+}, {
+  actionType: "".concat(filesSliceName, "/updateFilesByAttachLabels")
+});
+export var detachFilesLabels = createThunk(async function (_ref10, thunkApi) {
+  var _ref10$filesUuids = _ref10.filesUuids,
+    filesUuids = _ref10$filesUuids === void 0 ? [] : _ref10$filesUuids,
+    _ref10$labelsSids = _ref10.labelsSids,
+    labelsSids = _ref10$labelsSids === void 0 ? [] : _ref10$labelsSids,
+    toggleContextMenu = _ref10.toggleContextMenu;
+  if (checkIfReachedTheLimit(filesUuids)) {
+    thunkApi.dispatch(applyBulkAttachedLabels({
+      type: BULK_EDIT_LABELS_TYPES.DELETE,
+      filesUuids: filesUuids,
+      labelsSids: labelsSids
+    }));
+    thunkApi.dispatch(selectionsCleared());
+    return;
+  }
+  var isOneFileOnly = filesUuids.length === 1;
+  var response = await thunkApi.extra.apiClient["delete"](isOneFileOnly ? "files/".concat(filesUuids[0], "/labels") : 'files/labels',
+  // else case => // Detaching N labels from M files
+  {
+    data: _objectSpread({
+      labels: labelsSids
+    }, !isOneFileOnly && {
+      files_uuids: filesUuids
+    })
+  });
+  if (typeof toggleContextMenu === 'function') {
+    toggleContextMenu();
+  }
+  thunkApi.dispatch(selectionsCleared());
+  return {
+    removeFiles: true,
+    filesUuids: response.files ? response.files.map(function (_ref11) {
+      var uuid = _ref11.uuid;
+      return uuid;
+    }) : [response.file.uuid]
+  };
+}, {
+  actionType: "".concat(filesSliceName, "/updateFilesByDeAttachLabels")
+});
+var labelsSlice = createSlice({
+  name: sliceName,
+  initialState: initialState,
+  reducers: {
+    labelsAdded: function labelsAdded(state, action) {
+      var newLabels = _objectSpread({}, state.entities);
+      var newLabelsUuids = _toConsumableArray(state.uuids);
+      action.payload.forEach(function (label) {
+        newLabels[label.uuid] = label;
+        newLabelsUuids.push(label.uuid);
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: _toConsumableArray(new Set(newLabelsUuids)),
+        entities: newLabels,
+        loading: false,
+        error: null
+      });
+    },
+    labelUpdated: function labelUpdated(state, action) {
+      var newLabels = _objectSpread({}, state.entities);
+      newLabels[action.payload.uuid] = _objectSpread(_objectSpread({}, newLabels[action.payload.uuid]), action.payload);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        entities: newLabels
+      });
+    },
+    labelsRemoved: function labelsRemoved(state, action) {
+      var labelsUuids = action.payload;
+      var newLabels = _objectSpread({}, state.entities);
+      var newLabelsUuids = _toConsumableArray(state.uuids);
+      labelsUuids.forEach(function (labelUuid) {
+        newLabelsUuids.splice(newLabelsUuids.indexOf(labelUuid), 1);
+        delete newLabels[labelUuid];
+      });
+      return _objectSpread(_objectSpread({}, state), {}, {
+        uuids: newLabelsUuids,
+        entities: newLabels
+      });
+    },
+    labelsSearchTermUpdated: function labelsSearchTermUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        searchTerm: action.payload
+      });
+    },
+    labelsSortingUpdated: function labelsSortingUpdated(state, action) {
+      var _action$payload = action.payload,
+        _action$payload$sortB = _action$payload.sortBy,
+        sortBy = _action$payload$sortB === void 0 ? state.sortedBy : _action$payload$sortB,
+        _action$payload$order = _action$payload.order,
+        order = _action$payload$order === void 0 ? state.sortOrder : _action$payload$order;
+      return _objectSpread(_objectSpread({}, state), {}, {
+        sortedBy: sortBy,
+        sortOrder: order
+      });
+    },
+    labelActivated: function labelActivated(state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        activeLabelUuid: action.payload.labelUuid,
+        selectedUuids: action.payload.selectedUuids || []
+      });
+    },
+    labelsSelectionToggled: function labelsSelectionToggled(state, action) {
+      if (action.payload.uuids) {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedUuids: action.payload.uuids
+        });
+      }
+      var selectedLabels = _toConsumableArray(state.selectedUuids);
+      var selectedLabelUuid = action.payload.uuid;
+      var labelIndex = selectedLabels.indexOf(selectedLabelUuid);
+      var newSelections;
+      if (labelIndex > -1) {
+        selectedLabels.splice(labelIndex, 1);
+        newSelections = _toConsumableArray(selectedLabels);
+      } else {
+        newSelections = [].concat(_toConsumableArray(selectedLabels), [selectedLabelUuid]);
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        selectedUuids: newSelections
+      });
+    },
+    labelsStateUpdated: function labelsStateUpdated(state, action) {
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    }
+  },
+  extraReducers: function extraReducers(builder) {
+    builder.addCase(updateLabelByUuid.fulfilled, function (state, action) {
+      return labelsSlice.caseReducers.labelUpdated(state, action);
+    }).addCase(createLabel.fulfilled, function (state, action) {
+      return labelsSlice.caseReducers.labelsAdded(state, action);
+    }).addCase(fetchLabels.pending, function (state) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        loading: true
+      });
+    }).addCase(fetchLabels.fulfilled, function (state, action) {
+      return labelsSlice.caseReducers.labelsAdded(state, action);
+    }).addCase(fetchLabels.rejected, function (state, action) {
+      return getActionErrorState(state, action);
+    }).addCase(fetchLabelFiles.pending, function (state, action) {
+      return _objectSpread(_objectSpread({}, state), {}, {
+        error: null
+      });
+    });
+  }
+});
+var _labelsSlice$actions = labelsSlice.actions,
+  labelsViewActivated = _labelsSlice$actions.labelsViewActivated,
+  labelsAdded = _labelsSlice$actions.labelsAdded,
+  labelUpdated = _labelsSlice$actions.labelUpdated,
+  labelsRemoved = _labelsSlice$actions.labelsRemoved,
+  labelsSearchTermUpdated = _labelsSlice$actions.labelsSearchTermUpdated,
+  labelsSortingUpdated = _labelsSlice$actions.labelsSortingUpdated,
+  labelActivated = _labelsSlice$actions.labelActivated,
+  labelsSelectionToggled = _labelsSlice$actions.labelsSelectionToggled,
+  labelsStateUpdated = _labelsSlice$actions.labelsStateUpdated;
+export { labelsViewActivated, labelsAdded, labelUpdated, labelsRemoved, labelsSearchTermUpdated, labelsSortingUpdated, labelActivated, labelsSelectionToggled, labelsStateUpdated };
+export var selectLabelsState = function selectLabelsState(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 selectLabels = function selectLabels(state) {
+  return selectLabelsState(state).entities;
+};
+export var selectLabelsUuids = function selectLabelsUuids(state) {
+  return selectLabelsState(state).uuids;
+};
+export var selectLabelsArray = createSelector(selectLabels, function (labels) {
+  return Object.values(labels);
+});
+export var selectLabelByUuid = function selectLabelByUuid(state, uuid) {
+  return selectLabels(state)[uuid];
+};
+export var selectActiveLabelUuid = function selectActiveLabelUuid(state) {
+  return selectLabelsState(state).activeLabelUuid;
+};
+export var selectActiveLabel = function selectActiveLabel(state) {
+  return selectLabelByUuid(state, selectActiveLabelUuid(state));
+};
+export var selectActiveLabelSid = function selectActiveLabelSid(state) {
+  var _selectActiveLabel;
+  return (_selectActiveLabel = selectActiveLabel(state)) === null || _selectActiveLabel === void 0 ? void 0 : _selectActiveLabel.sid;
+};
+export var selectLabelsSearchTerm = function selectLabelsSearchTerm(state) {
+  return selectLabelsState(state).searchTerm;
+};
+export var selectIsLabelsLoading = function selectIsLabelsLoading(state) {
+  return selectIsLabelsView(state) && selectLabelsState(state).loading;
+};
+export var selectLabelsSorting = function selectLabelsSorting(state) {
+  return selectLabelsState(state).sorting;
+};
+export var selectLabelsSortBy = function selectLabelsSortBy(state) {
+  return selectLabelsState(state).sortedBy;
+};
+export var selectLabelsSortOrder = function selectLabelsSortOrder(state) {
+  return selectLabelsState(state).sortOrder;
+};
+export var selectLabelsSelectedUuids = function selectLabelsSelectedUuids(state) {
+  return selectLabelsState(state).selectedUuids;
+};
+export var selectIsLabelsTreeOpened = function selectIsLabelsTreeOpened(state) {
+  return selectLabelsState(state).showTree;
+};
+export var selectLabelsError = function selectLabelsError(state) {
+  return selectLabelsState(state).error;
+};
+export var selectLabelsSelected = createSelector([selectLabels, selectLabelsSelectedUuids], function (labels, selectedUuids) {
+  return selectedUuids.map(function (uuid) {
+    return labels[uuid];
+  });
+});
+export var selectIsLabelSelected = function selectIsLabelSelected(state, uuid) {
+  return selectLabelsSelectedUuids(state).includes(uuid);
+};
+export var selectFileLabels = createSelector([selectLabelsArray, function (_state, fileLabels) {
+  return Array.isArray(fileLabels) ? fileLabels : [];
+}], function (labels, fileLabels) {
+  return fileLabels.map(function (fileLabel) {
+    return labels.find(function (label) {
+      return fileLabel === label.sid;
+    });
+  });
+});
+var sortLabels = function sortLabels() {
+  var labels = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var currentLabelsUuids = arguments.length > 1 ? arguments[1] : undefined;
+  var sortBy = arguments.length > 2 ? arguments[2] : undefined;
+  var sortOrder = arguments.length > 3 ? arguments[3] : undefined;
+  if (sortBy) {
+    var isAscOrder = sortOrder === SORT_ORDER.ASC;
+    return _toConsumableArray(currentLabelsUuids).sort(function (aUuid, bUuid) {
+      var _x$sortBy, _y$sortBy;
+      var aLabel = labels[aUuid];
+      var bLabel = labels[bUuid];
+      var x = isAscOrder ? aLabel : bLabel;
+      var y = isAscOrder ? bLabel : aLabel;
+      var xValue = (_x$sortBy = x === null || x === void 0 ? void 0 : x[sortBy]) !== null && _x$sortBy !== void 0 ? _x$sortBy : '';
+      var yValue = (_y$sortBy = y === null || y === void 0 ? void 0 : y[sortBy]) !== null && _y$sortBy !== void 0 ? _y$sortBy : '';
+      if (!Number.isNaN(+xValue) && !Number.isNaN(+yValue)) return +xValue - +yValue;
+      if (!isNaN(new Date(xValue)) && !isNaN(new Date(yValue))) return yValue.toString().localeCompare(xValue);
+      return xValue.toString().localeCompare(yValue);
+    });
+  }
+  return currentLabelsUuids;
+};
+export var selectSortedLabelsUuids = createSelector([selectLabels, selectLabelsUuids, selectLabelsSortBy, selectLabelsSortOrder], sortLabels);
+export var selectLabelsBySearchTerm = createSelector([selectLabelsArray, function (_state, labelsSearchTerm) {
+  return labelsSearchTerm;
+}], function (labels, labelsSearchTerm) {
+  var filteredLabels = labelsSearchTerm ? labels.filter(function (label) {
+    return new RegExp(escapeRegExp(labelsSearchTerm), 'i').test(label.name);
+  }) : labels;
+  return filteredLabels;
+});
+export var selectSortedLabelsUuidsBySearchTerm = createSelector([selectLabelsBySearchTerm, selectLabels, selectLabelsSortBy, selectLabelsSortOrder], function (filteredLabels, labels, sortBy, sortOrder) {
+  return sortLabels(labels, filteredLabels.map(function (_ref12) {
+    var uuid = _ref12.uuid;
+    return uuid;
+  }), sortBy, sortOrder);
+});
+export default labelsSlice.reducer;