@scaleflex/widget-explorer 0.0.1

package/lib/utils/constants.js

@@ -0,0 +1,14 @@
+export var ORIENTATION_KEY_TO_LABEL_I18N_KEYS = {
+  LD: 'mutualizedOrientationsLandscapeLabel',
+  PO: 'mutualizedOrientationsPortraitLabel',
+  PT: 'mutualizedOrientationsPortraitLabel',
+  SQ: 'mutualizedOrientationsSquareLabel',
+  PA: 'mutualizedOrientationsPanoramaLabel'
+};
+export var FILTER_STATIC_DATA = {
+  EMPTY: 'empty',
+  NOT_EMPTY: 'non-empty'
+};
+export var ANIMATED_IMG_ACCEPT_HEADER = {
+  Accept: 'image/gif,image/webp,image/agif,image/awebp,image/avif,*/*;q=1'
+};

package/lib/utils/convertItemsToFilesFoldersUuids.js

@@ -0,0 +1,12 @@
+import isFolder from '@scaleflex/widget-utils/lib/isFolder';
+var convertItemsToFilesFoldersUuids = function convertItemsToFilesFoldersUuids() {
+  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return (items || []).reduce(function (accum, item) {
+    (isFolder(item) ? accum.foldersUuids : accum.filesUuids).push(item.uuid);
+    return accum;
+  }, {
+    filesUuids: [],
+    foldersUuids: []
+  });
+};
+export default convertItemsToFilesFoldersUuids;

package/lib/utils/convertItemstoFoldersParentUuids.js

@@ -0,0 +1,12 @@
+import isFolder from '@scaleflex/widget-utils/lib/isFolder';
+var convertItemsToFilesFoldersParentUuids = function convertItemsToFilesFoldersParentUuids() {
+  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return (items || []).reduce(function (accum, item) {
+    (isFolder(item) ? accum.foldersUuids : accum.filesUuids).push(item.parentUuid);
+    return accum;
+  }, {
+    filesUuids: [],
+    foldersUuids: []
+  });
+};
+export default convertItemsToFilesFoldersParentUuids;

package/lib/utils/createPromise.js

@@ -0,0 +1,9 @@
+var createPromise = function createPromise() {
+  var o = {};
+  o.promise = new Promise(function (resolve, reject) {
+    o.resolve = resolve;
+    o.reject = reject;
+  });
+  return o;
+};
+export default createPromise;

package/lib/utils/createSuperFocus.js

@@ -0,0 +1,43 @@
+import debounce from 'lodash.debounce';
+import FOCUSABLE_ELEMENTS from '@scaleflex/widget-utils/lib/FOCUSABLE_ELEMENTS';
+import getActiveOverlayEl from './getActiveOverlayEl';
+
+/*
+  Focuses on some element in the currently topmost overlay.
+
+  1. If there are some [data-filerobot-super-focusable] elements rendered already - focuses on the first superfocusable element, and leaves focus up to the control of a user (until currently focused element disappears from the screen [which can happen when overlay changes, or, e.g., when we click on a folder in googledrive]).
+  2. If there are no [data-filerobot-super-focusable] elements yet (or ever) - focuses on the first focusable element, but switches focus if superfocusable elements appear on next render.
+*/
+export default function createSuperFocus() {
+  var lastFocusWasOnSuperFocusableEl = false;
+  var superFocus = function superFocus(explorerEl, activeOverlayType) {
+    var overlayEl = getActiveOverlayEl(explorerEl, activeOverlayType);
+    var isFocusInOverlay = overlayEl.contains(document.activeElement);
+    // If focus is already in the topmost overlay, AND on last update we focused on the superfocusable element - then leave focus up to the user.
+    // [Practical check] without this line, typing in the search input in googledrive overlay won't work.
+    if (isFocusInOverlay && lastFocusWasOnSuperFocusableEl) return;
+    var superFocusableEl = overlayEl.querySelector('[data-filerobot-super-focusable]');
+    // If we are already in the topmost overlay, AND there are no super focusable elements yet, - leave focus up to the user.
+    // [Practical check] without this line, if you are in an empty folder in google drive, and something's uploading in the bg, - focus will be jumping to Done all the time.
+    if (isFocusInOverlay && !superFocusableEl) return;
+    if (superFocusableEl) {
+      superFocusableEl.focus({
+        preventScroll: true
+      });
+      lastFocusWasOnSuperFocusableEl = true;
+    } else {
+      var firstEl = overlayEl.querySelector(FOCUSABLE_ELEMENTS);
+      firstEl && firstEl.focus({
+        preventScroll: true
+      });
+      lastFocusWasOnSuperFocusableEl = false;
+    }
+  };
+
+  // ___Why do we need to debounce?
+  //    1. To deal with animations: overlay changes via animations, which results in the DOM updating AFTER plugin.update() already executed.
+  //    [Practical check] without debounce, if we open the Url overlay, and click 'Done', Explorer won't get focused again.
+  //    [Practical check] if we delay 250ms instead of 260ms - IE11 won't get focused in same situation.
+  //    2. Performance: there can be many state update()s in a second, and this function is called every time.
+  return debounce(superFocus, 260);
+}

package/lib/utils/decodeB64ToStr.js

@@ -0,0 +1,11 @@
+var decodeB64ToStr = function decodeB64ToStr() {
+  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  if (!str) {
+    return;
+  }
+  try {
+    return atob(str);
+  } catch (e) {}
+  return str;
+};
+export default decodeB64ToStr;

package/lib/utils/filters.js

@@ -0,0 +1,333 @@
+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); }
+var _excluded = ["key"];
+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); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { FILTER_CONDITIONS } from '@scaleflex/widget-utils/lib/constants';
+import { getDateFieldQuery, getFieldValueQuery, getTextFieldQuery } from '@scaleflex/widget-utils/lib/fieldsQueriesGetters';
+import { getMetadataMultiSelectQuery } from '@scaleflex/widget-utils/lib/getMetadataMultiSelectQuery';
+import getDateRange from '@scaleflex/widget-utils/lib/Timeframes/getDateRange';
+import isFunction from '@scaleflex/widget-utils/lib/isFunction';
+import isNumber from '@scaleflex/widget-utils/lib/isNumber';
+import literalDateFromDateObj from '@scaleflex/widget-utils/lib/literalDateFromDateObj';
+import { DEFAULT_FILTER_OPERATOR, FIELD_TYPE_ORDER, FILTER_SECTION_KEYS, METADATA_FIELDS_TYPES, SELECT_FIELDS_TYPES } from '../components/Filters/Filters.constants';
+import { FILTER_STATIC_DATA } from './constants';
+export var isBooleanField = function isBooleanField(field) {
+  return field.type === METADATA_FIELDS_TYPES.BOOLEAN || typeof field.value === 'boolean';
+};
+export var getUpdatedBooleanMetadataFields = function getUpdatedBooleanMetadataFields(_ref) {
+  var metadata = _ref.metadata,
+    field = _ref.field,
+    checked = _ref.checked,
+    metadataFieldIndex = _ref.metadataFieldIndex;
+  var nextMetadata = _toConsumableArray(metadata);
+  var updatedField = _objectSpread(_objectSpread({}, field), {}, {
+    value: checked,
+    condition: FILTER_CONDITIONS.IS
+  });
+  if (checked) {
+    nextMetadata.push(updatedField);
+  } else {
+    nextMetadata.splice(metadataFieldIndex, 1);
+  }
+  return nextMetadata;
+};
+export var getUpdatedDateMetadataFields = function getUpdatedDateMetadataFields(_ref2) {
+  var metadata = _ref2.metadata,
+    field = _ref2.field,
+    value = _ref2.value;
+  var nextMetadata = _toConsumableArray(metadata);
+  var updatedField = _objectSpread(_objectSpread({}, field), {}, {
+    value: value,
+    condition: FILTER_CONDITIONS.IS
+  });
+  nextMetadata.push(updatedField);
+  return nextMetadata;
+};
+export var sortFieldsByType = function sortFieldsByType(fields) {
+  return fields.sort(function (a, b) {
+    return (FIELD_TYPE_ORDER[a.type] || 99) - (FIELD_TYPE_ORDER[b.type] || 99);
+  });
+};
+export var findOptionByApiValue = function findOptionByApiValue(possibleValues, nextApiValue) {
+  var _possibleValues$find;
+  return (_possibleValues$find = possibleValues.find(function (_ref3) {
+    var apiValue = _ref3.api_value;
+    return apiValue === nextApiValue;
+  })) !== null && _possibleValues$find !== void 0 ? _possibleValues$find : {};
+};
+export var getMultiSelectFieldValue = function getMultiSelectFieldValue(_ref4) {
+  var metadataFieldFilter = _ref4.metadataFieldFilter,
+    value = _ref4.value;
+  var _metadataFieldFilter$ = metadataFieldFilter.value,
+    apiValues = _metadataFieldFilter$ === void 0 ? [] : _metadataFieldFilter$;
+  var existApiValue = apiValues.some(function (apiValue) {
+    return apiValue === value;
+  });
+  return existApiValue ? apiValues.filter(function (apiValue) {
+    return apiValue !== value;
+  }) : [].concat(_toConsumableArray(apiValues), [value]);
+};
+export var isDateField = function isDateField(field) {
+  return field.type === METADATA_FIELDS_TYPES.DATE;
+};
+export var isSelectField = function isSelectField(field) {
+  return SELECT_FIELDS_TYPES.includes(field.type);
+};
+export var isMultiSelectField = function isMultiSelectField(field) {
+  return field.type === METADATA_FIELDS_TYPES.MULTI_SELECT;
+};
+export var isSingleSelectField = function isSingleSelectField(field) {
+  return field.type === METADATA_FIELDS_TYPES.SELECT_ONE;
+};
+export var isNumericField = function isNumericField(field) {
+  return field.type === METADATA_FIELDS_TYPES.NUMERIC || typeof field.value === 'number';
+};
+export var isTextField = function isTextField(field) {
+  return [METADATA_FIELDS_TYPES.TEXT_AREA, METADATA_FIELDS_TYPES.TEXT].includes(field.type);
+};
+export var isTextAreaField = function isTextAreaField(field) {
+  return field.type === METADATA_FIELDS_TYPES.TEXT_AREA;
+};
+export var isTagsField = function isTagsField(field) {
+  return field.type === METADATA_FIELDS_TYPES.TAGS;
+};
+export var isUriField = function isUriField(field) {
+  return field.type === METADATA_FIELDS_TYPES.URI;
+};
+export var isGeoPointField = function isGeoPointField(field) {
+  return field.type === METADATA_FIELDS_TYPES.GEO_POINT;
+};
+export var findMetadataFieldByKey = function findMetadataFieldByKey(metadata, key) {
+  return metadata.find(function (_ref5) {
+    var fieldKey = _ref5.key;
+    return fieldKey === key;
+  });
+};
+export var findMetadataFieldIndex = function findMetadataFieldIndex(metadata, key) {
+  return metadata.findIndex(function (_ref6) {
+    var fieldKey = _ref6.key;
+    return fieldKey === key;
+  });
+};
+export var isValidNumber = function isValidNumber(value) {
+  return value === '' || value === '0' || !isNaN(Number(value));
+};
+export var isBigOptions = function isBigOptions(options, bigOptionsThreshold) {
+  return options.length > bigOptionsThreshold;
+};
+export var isContainsNotCondition = function isContainsNotCondition(condition) {
+  return condition === FILTER_CONDITIONS.CONTAINS_NOT;
+};
+export var isCheckedOption = function isCheckedOption(_ref7) {
+  var value = _ref7.value,
+    metadataFieldFilter = _ref7.metadataFieldFilter,
+    field = _ref7.field;
+  if (!(metadataFieldFilter !== null && metadataFieldFilter !== void 0 && metadataFieldFilter.value)) return false;
+  return isBooleanField(field) ? metadataFieldFilter.value === value : metadataFieldFilter.value.includes(value);
+};
+export var getUpdatedSelectMetadataFields = function getUpdatedSelectMetadataFields(_ref8) {
+  var apiValue = _ref8.apiValue,
+    metadataFilters = _ref8.metadataFilters,
+    field = _ref8.field,
+    metadataFieldIndex = _ref8.metadataFieldIndex,
+    metadataFieldFilter = _ref8.metadataFieldFilter;
+  var nextMetadata = _toConsumableArray(metadataFilters);
+  var updatedField = _objectSpread({}, field);
+  var nextValue = getMultiSelectFieldValue({
+    value: apiValue,
+    metadataFieldFilter: metadataFieldFilter
+  });
+  updatedField = _objectSpread(_objectSpread({}, updatedField), {}, {
+    value: nextValue,
+    condition: FILTER_CONDITIONS.IS
+  });
+  if (metadataFieldIndex !== -1) {
+    nextMetadata[metadataFieldIndex] = updatedField;
+  } else {
+    nextMetadata.push(updatedField);
+  }
+  return nextMetadata.filter(function (_ref9) {
+    var value = _ref9.value,
+      type = _ref9.type;
+    return !isSelectField({
+      type: type
+    }) || !!(value !== null && value !== void 0 && value.length);
+  });
+};
+export var isStaticSelectOption = function isStaticSelectOption() {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var metadataStaticOptions = Object.values(FILTER_STATIC_DATA);
+  return value.some(function (item) {
+    return metadataStaticOptions.includes(item);
+  });
+};
+export var getOldMetadataDateFilterValFromArray = function getOldMetadataDateFilterValFromArray(val) {
+  var value = (Array.isArray(val) ? val[1] || val[0] : val) || '';
+  return typeof value !== 'string' ? value.toString() : value;
+};
+export var adaptSelectFieldValue = function adaptSelectFieldValue(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return [value];
+};
+
+// appliedMetadata => { operator: ':', value: [] }
+export var adaptMetadataFilter = function adaptMetadataFilter(appliedMetadata) {
+  var querySet = [];
+  var metadataFilters = (appliedMetadata === null || appliedMetadata === void 0 ? void 0 : appliedMetadata.value) || appliedMetadata || [];
+  metadataFilters.forEach(function (metadataFilter) {
+    var sanitizedMetadataFilter = isSelectField(metadataFilter) ? _objectSpread(_objectSpread({}, metadataFilter), {}, {
+      value: adaptSelectFieldValue(metadataFilter.value)
+    }) : metadataFilter;
+    var value = sanitizedMetadataFilter.value;
+    if (isSingleSelectField(sanitizedMetadataFilter)) {
+      querySet.push(getFieldValueQuery(sanitizedMetadataFilter, value.join(',')));
+    } else if (isMultiSelectField(sanitizedMetadataFilter)) {
+      querySet.push(getMetadataMultiSelectQuery(sanitizedMetadataFilter));
+    } else if (isDateField(sanitizedMetadataFilter)) {
+      querySet.push(getDateFieldQuery(sanitizedMetadataFilter));
+    } else if (isTagsField(sanitizedMetadataFilter)) {
+      /**
+       * We are adding double quotes around the tags' values, to make sure if the tag's text contains space to be considered,
+       * as requested in this task: https://scaleflexhq.atlassian.net/browse/FRA-5997
+       */
+      querySet.push(getFieldValueQuery(sanitizedMetadataFilter, "\"".concat(value.join('","'), "\"")));
+    } else if (isTextField(sanitizedMetadataFilter)) {
+      querySet.push(getTextFieldQuery(sanitizedMetadataFilter));
+    } else {
+      querySet.push(getFieldValueQuery(sanitizedMetadataFilter, value));
+    }
+  });
+  return querySet;
+};
+
+// We are using this mapping to keep supporting the filter param names as they are from config/url.
+var getMapDateFilterObj = function getMapDateFilterObj(_ref10) {
+  var formatDate = _ref10.formatDate,
+    _ref10$considerFuture = _ref10.considerFutureDates,
+    considerFutureDates = _ref10$considerFuture === void 0 ? false : _ref10$considerFuture;
+  return {
+    mapValue: function mapValue() {
+      var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        value = _ref11.value;
+      if (!value && value !== 0 || Array.isArray(value)) {
+        var newValue = _toConsumableArray(value);
+        if (isNumber(value[0])) {
+          newValue[0] = getDateRange(value[0], formatDate, considerFutureDates && value[0] > -1);
+        }
+        if (isNumber(value[1])) {
+          newValue[1] = getDateRange(value[1], formatDate, considerFutureDates && value[1] > -1);
+        }
+        return newValue;
+      }
+      return isNumber(value) ? getDateRange(value, formatDate, considerFutureDates && value > -1) : value;
+    },
+    // Kept as an example but not needed for now.
+    // mapOperator: ({ value } = {}) => {
+    //   const isPastDate = value > 1 && value < 7
+    //   return isPastDate ? '>' : ':'
+    // },
+    valuesSeparator: '..'
+  };
+};
+export var FILTER_FE_KEY_TO_BE_MAPPINGS = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FILTER_SECTION_KEYS.MIME_TYPES, {
+  key: 'mimetype'
+}), FILTER_SECTION_KEYS.FILE_TYPES, {
+  key: 'type'
+}), FILTER_SECTION_KEYS.SIZE, {
+  valuesSeparator: '..',
+  acceptFalsyValues: true
+}), FILTER_SECTION_KEYS.IMAGE_MAIN_COLORS, {
+  key: 'main_color'
+}), FILTER_SECTION_KEYS.IMAGE_FACES, {
+  key: 'faces',
+  valuesSeparator: '..'
+}), FILTER_SECTION_KEYS.IMAGE_DOMINANT_COLORS, {
+  key: 'color'
+}), FILTER_SECTION_KEYS.IMAGE_ORIENTATIONS, {
+  key: 'orientation'
+}), FILTER_SECTION_KEYS.IMAGE_RESOLUTIONS, {
+  key: 'resolution'
+}), FILTER_SECTION_KEYS.DATE, getMapDateFilterObj({
+  formatDate: function formatDate(date) {
+    return date.toISOString();
+  }
+})), FILTER_SECTION_KEYS.LICENSE_EXPIRY, _objectSpread(_objectSpread({}, getMapDateFilterObj({
+  formatDate: literalDateFromDateObj,
+  considerFutureDates: true
+})), {}, {
+  acceptFalsyValues: true
+}));
+
+// Used when need to adapt filters from BE format to FE
+export var FILTER_BE_KEY_TO_FE_MAPPINGS = Object.keys(FILTER_FE_KEY_TO_BE_MAPPINGS).reduce(function (accum, frontendKey) {
+  var _FILTER_FE_KEY_TO_BE_2 = FILTER_FE_KEY_TO_BE_MAPPINGS[frontendKey],
+    key = _FILTER_FE_KEY_TO_BE_2.key,
+    backendMappingDetails = _objectWithoutProperties(_FILTER_FE_KEY_TO_BE_2, _excluded);
+  accum[key || frontendKey] = _objectSpread(_objectSpread({}, backendMappingDetails), {}, {
+    frontendKey: frontendKey
+  });
+  return accum;
+}, {});
+var getJoinedValues = function getJoinedValues(values, acceptFalsyValues, separator) {
+  if (acceptFalsyValues) {
+    return values.join(separator);
+  }
+  return values.filter(function (val) {
+    return val || val === 0;
+  }).join(separator);
+};
+export var adaptFiltersToBackendNotation = function adaptFiltersToBackendNotation() {
+  var filters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var shouldApplyEncoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var adaptedFilters = [];
+  var _FILTER_SECTION_KEYS$ = FILTER_SECTION_KEYS.METADATA,
+    metadataFilters = filters[_FILTER_SECTION_KEYS$],
+    otherFilters = _objectWithoutProperties(filters, [_FILTER_SECTION_KEYS$].map(_toPropertyKey));
+  if (typeof metadataFilters !== 'undefined') {
+    adaptedFilters.push.apply(adaptedFilters, _toConsumableArray(adaptMetadataFilter(metadataFilters)));
+  }
+  var currentFilterKeys = Object.keys(otherFilters);
+  if (currentFilterKeys.length > 0) {
+    var adaptedOtherFilters = currentFilterKeys.map(function (internalFilterKey) {
+      var currentFilter = otherFilters[internalFilterKey];
+      var filterBackendMappings = FILTER_FE_KEY_TO_BE_MAPPINGS[internalFilterKey];
+      var _ref12 = filterBackendMappings || {},
+        _ref12$key = _ref12.key,
+        key = _ref12$key === void 0 ? (currentFilter === null || currentFilter === void 0 ? void 0 : currentFilter.key) || (currentFilter === null || currentFilter === void 0 ? void 0 : currentFilter.internalKey) || internalFilterKey : _ref12$key,
+        _ref12$valuesSeparato = _ref12.valuesSeparator,
+        valuesSeparator = _ref12$valuesSeparato === void 0 ? '","' : _ref12$valuesSeparato,
+        removableSymbolsRegex = _ref12.removableSymbolsRegex,
+        mapValue = _ref12.mapValue,
+        mapOperator = _ref12.mapOperator,
+        _ref12$acceptFalsyVal = _ref12.acceptFalsyValues,
+        acceptFalsyValues = _ref12$acceptFalsyVal === void 0 ? false : _ref12$acceptFalsyVal;
+      var filterOperator = isFunction(mapOperator) ? mapOperator(currentFilter) : (currentFilter === null || currentFilter === void 0 ? void 0 : currentFilter.operator) || DEFAULT_FILTER_OPERATOR;
+      var filterValue = isFunction(mapValue) ? mapValue(currentFilter) : (currentFilter === null || currentFilter === void 0 ? void 0 : currentFilter.value) || currentFilter;
+      var adaptedFilterValue = Array.isArray(filterValue) ? getJoinedValues(filterValue, acceptFalsyValues, valuesSeparator) : filterValue;
+      if (removableSymbolsRegex) {
+        adaptedFilterValue = adaptedFilterValue.replaceAll(removableSymbolsRegex, '');
+      }
+      if (shouldApplyEncoding) {
+        adaptedFilterValue = encodeURIComponent(adaptedFilterValue).replaceAll(
+        // Reverse (decode) the values separator encoding for better readability while checking the network requests if needed as no benefit behind encoding them.
+        encodeURIComponent(valuesSeparator), valuesSeparator);
+      }
+      var wrappedFilterValue = "\"".concat(adaptedFilterValue, "\"");
+      return "".concat(key).concat(filterOperator).concat(wrappedFilterValue);
+    });
+    adaptedFilters.push.apply(adaptedFilters, _toConsumableArray(adaptedOtherFilters));
+  }
+  return adaptedFilters;
+};

package/lib/utils/formatFolderPath.js

@@ -0,0 +1,10 @@
+export var formatFolderPath = function formatFolderPath(path) {
+  if (!path.includes('/')) {
+    return path;
+  }
+  var formattedPath = path.replace(/\//g, ' / ');
+  if (path.trim().startsWith('/')) {
+    return "Root ".concat(formattedPath.trim());
+  }
+  return formattedPath.trim();
+};

package/lib/utils/formatPinSubTitle.js

@@ -0,0 +1,17 @@
+/**
+ * Format sub title from formatted query string (filters + search) for save/edit pin modals
+ *
+ * @param {Array} query container width
+ * @param {Function} i18n -- The translation function for translating the shown confirmation message - eg. plugin.i18n
+ * @returns {String}
+ */
+
+var formatPinSubtitle = function formatPinSubtitle(query, i18n) {
+  return query.map(function (_ref) {
+    var filter = _ref.filter,
+      filtersSectionKey = _ref.filtersSectionKey,
+      label = _ref.label;
+    return "".concat(filter || i18n(filtersSectionKey), ": \"").concat(label, "\"");
+  }).join(',');
+};
+export default formatPinSubtitle;

package/lib/utils/getAcquirerTitle.js

@@ -0,0 +1,10 @@
+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 _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 { PLUGINS_IDS } from '@scaleflex/widget-utils/lib/constants';
+var getAcquirerTitle = function getAcquirerTitle(acquirerId) {
+  var acquirerMapping = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, PLUGINS_IDS.WEBCAM, 'explorerAddFilesPanelCameraLabel'), PLUGINS_IDS.SCREEN_CAPTURE, 'explorerAddFilesPanelScreenCastLabel'), PLUGINS_IDS.URL, 'explorerAddFilesPanelLinkLabel'), PLUGINS_IDS.PIXAFORGE, 'explorerAddFilesPanelFreeImagesAndIconsLabel');
+  return acquirerMapping[acquirerId];
+};
+export default getAcquirerTitle;

package/lib/utils/getActiveOverlayEl.js

@@ -0,0 +1,11 @@
+/**
+ * @returns {HTMLElement} - either explorer element, or the overlay that's most on top
+ */
+export default function getActiveOverlayEl(explorerEl, activeOverlayType) {
+  if (activeOverlayType) {
+    var overlayEl = explorerEl.querySelector("[data-filerobot-paneltype=\"".concat(activeOverlayType, "\"]"));
+    // if an overlay is already mounted
+    if (overlayEl) return overlayEl;
+  }
+  return explorerEl;
+}

package/lib/utils/getApiPathtype.js

@@ -0,0 +1,10 @@
+var getApiPathType = function getApiPathType(filesUuids, foldersUuids) {
+  if (foldersUuids.length === 0) {
+    return 'files';
+  } else if (filesUuids.length === 0) {
+    return 'folders';
+  } else {
+    return 'objects';
+  }
+};
+export default getApiPathType;

package/lib/utils/getClosestStr.js

@@ -0,0 +1,22 @@
+import levenshtein from 'js-levenshtein';
+export default function getClosestStr(str, options) {
+  if (str) {
+    var closestValue = (options || []).filter(function (option) {
+      return option && typeof option === 'string';
+    }).reduce(function (acum, currentOption) {
+      var value = currentOption || '';
+      var distance = levenshtein((str || '').toLowerCase(), value.toLowerCase());
+      if (!acum || distance < (acum === null || acum === void 0 ? void 0 : acum.distance)) {
+        return {
+          value: value,
+          distance: distance
+        };
+      }
+      return acum;
+    }, null);
+    if (closestValue !== null && closestValue !== void 0 && closestValue.value) {
+      return closestValue.value;
+    }
+  }
+  return null;
+}

package/lib/utils/getItemUuids.js

@@ -0,0 +1,12 @@
+var getItemUuids = function getItemUuids(items) {
+  if (Array.isArray(items)) {
+    return items.map(function (item) {
+      return item.uuid;
+    }) || [];
+  }
+  if (!(items !== null && items !== void 0 && items.uuid)) {
+    return [];
+  }
+  return [items === null || items === void 0 ? void 0 : items.uuid];
+};
+export default getItemUuids;

package/lib/utils/getLabelsTotalAssetsCount.js

@@ -0,0 +1,6 @@
+var getLabelsTotalAssetsCount = function getLabelsTotalAssetsCount(labels) {
+  return labels.reduce(function (total, label) {
+    return total + ((label === null || label === void 0 ? void 0 : label.assets_count) || 0);
+  }, 0);
+};
+export default getLabelsTotalAssetsCount;

package/lib/utils/getMoveAndDeleteData.js

@@ -0,0 +1,15 @@
+var getMoveAndDeleteData = function getMoveAndDeleteData(apiPathType, filesUuids, foldersUuids) {
+  var isFileOrObject = apiPathType === 'files' || apiPathType === 'objects';
+  var isFolderOrObject = apiPathType === 'folders' || apiPathType === 'objects';
+  var fileObject = isFileOrObject ? {
+    files_uuids: filesUuids
+  } : {};
+  var folderObject = isFolderOrObject ? {
+    folders_uuids: foldersUuids
+  } : {};
+  return {
+    fileObject: fileObject,
+    folderObject: folderObject
+  };
+};
+export default getMoveAndDeleteData;

package/lib/utils/getParentFolderPath.js

@@ -0,0 +1,4 @@
+var getParentFolderPath = function getParentFolderPath(path) {
+  return path === null || path === void 0 ? void 0 : path.slice(0, path.lastIndexOf('/'));
+};
+export default getParentFolderPath;

package/lib/utils/getQueryStringFromUrl.js

@@ -0,0 +1,6 @@
+var getQueryStringFromUrl = function getQueryStringFromUrl(url) {
+  if (!url) return;
+  var queryMatch = url.match(/\?(.*)$/);
+  return queryMatch ? queryMatch[1] : '';
+};
+export default getQueryStringFromUrl;

package/lib/utils/getScrollableParent.js

@@ -0,0 +1,15 @@
+var _getScrollableParent = function getScrollableParent(elemNode) {
+  if (!elemNode || elemNode.nodeName === '#document' || elemNode.nodeName === 'HTML') {
+    var _ref, _document$scrollingEl;
+    return (_ref = (_document$scrollingEl = document.scrollingElement) !== null && _document$scrollingEl !== void 0 ? _document$scrollingEl : document.body) !== null && _ref !== void 0 ? _ref : window;
+  }
+  var _window$getComputedSt = window.getComputedStyle(elemNode),
+    overflowY = _window$getComputedSt.overflowY;
+  var noScrollValues = ['visible', 'hidden', 'initial'];
+  var isScrollable = !noScrollValues.includes(overflowY === null || overflowY === void 0 ? void 0 : overflowY.toLowerCase());
+  if (isScrollable && (elemNode.scrollHeight > elemNode.clientHeight || elemNode.dataset.scroller)) {
+    return elemNode;
+  }
+  return _getScrollableParent(elemNode.parentNode);
+};
+export default _getScrollableParent;

package/lib/utils/getStringValueExistedInObj.js

@@ -0,0 +1,9 @@
+var getStringValueExistedInObj = function getStringValueExistedInObj() {
+  var _Object$values;
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var object = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return value ? typeof value === 'string' && (object[value.toUpperCase()] || object[value.toLowerCase()]) ||
+  // most probably won't work with 0 or '' as a value as they are considered false in the condition if needed update the condition
+  typeof object[value] !== 'undefined' && object[value] || ((_Object$values = Object.values(object || {})) === null || _Object$values === void 0 ? void 0 : _Object$values.includes(value)) && value : '';
+};
+export default getStringValueExistedInObj;

package/lib/utils/isEmbeddableAsset.js

@@ -0,0 +1,6 @@
+import isImage from '@scaleflex/widget-utils/lib/isImage';
+import isVideo from '@scaleflex/widget-utils/lib/isVideo';
+var isEmbeddableAsset = function isEmbeddableAsset(asset) {
+  return isVideo(asset) || isImage(asset);
+};
+export default isEmbeddableAsset;

package/lib/utils/isFileVersion.js

@@ -0,0 +1,9 @@
+var isFileVersion = function isFileVersion(_ref) {
+  var newVersion = _ref.newVersion,
+    originalFile = _ref.originalFile;
+  if ((newVersion === null || newVersion === void 0 ? void 0 : newVersion.uuid.slice(0, -4)) === (originalFile === null || originalFile === void 0 ? void 0 : originalFile.uuid.slice(0, -4))) {
+    return true;
+  }
+  return false;
+};
+export default isFileVersion;