@scaleflex/widget-utils 0.0.1

package/lib/metadata/getMetadataEmptyAssets.js

@@ -0,0 +1,28 @@
+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 isAssetHasMetadataValue = function isAssetHasMetadataValue(value) {
+  return Array.isArray(value) && value.length || _typeof(value) === 'object' && Object.keys(value || {}).length || typeof value === 'string' && value.length;
+};
+var getEmptyAssets = function getEmptyAssets(requiredMetadataFields, assets) {
+  return assets.filter(function (_ref) {
+    var _ref$meta = _ref.meta,
+      meta = _ref$meta === void 0 ? {} : _ref$meta;
+    return requiredMetadataFields.some(function (_ref2) {
+      var key = _ref2.key;
+      return !isAssetHasMetadataValue(meta[key]);
+    });
+  });
+};
+var getMetadataEmptyAssets = function getMetadataEmptyAssets(requiredMetadataFields, assets) {
+  return requiredMetadataFields.reduce(function (acc, curr) {
+    var assetsHaveEmptyMetadata = assets.filter(function (_ref3) {
+      var _ref3$meta = _ref3.meta,
+        meta = _ref3$meta === void 0 ? {} : _ref3$meta;
+      return !isAssetHasMetadataValue(meta[curr.key]);
+    });
+    if (assetsHaveEmptyMetadata.length) {
+      acc[curr.key] = assetsHaveEmptyMetadata;
+    }
+    return acc;
+  }, {});
+};
+export { getEmptyAssets, isAssetHasMetadataValue, getMetadataEmptyAssets };

package/lib/metadata/getMetadataFieldGeoPointValue.js

@@ -0,0 +1,42 @@
+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 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 { REMOVE_PARENTHESES_REGEX } from '@scaleflex/widget-common/lib/MetaData/MetaDataFieldTypes/MetadataGeoPointField/constants';
+var getMetadataFieldGeoPointValue = function getMetadataFieldGeoPointValue(value) {
+  var showDistanceField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (!value) return _objectSpread({
+    latitude: '',
+    longitude: ''
+  }, showDistanceField && {
+    distance: ''
+  });
+  var _value$split = value.split('..'),
+    _value$split2 = _slicedToArray(_value$split, 2),
+    geoPart = _value$split2[0],
+    _value$split2$ = _value$split2[1],
+    distance = _value$split2$ === void 0 ? '' : _value$split2$;
+  var _geoPart$replace$spli = geoPart.replace(REMOVE_PARENTHESES_REGEX, '').split(','),
+    _geoPart$replace$spli2 = _slicedToArray(_geoPart$replace$spli, 2),
+    _geoPart$replace$spli3 = _geoPart$replace$spli2[0],
+    latitude = _geoPart$replace$spli3 === void 0 ? '' : _geoPart$replace$spli3,
+    _geoPart$replace$spli4 = _geoPart$replace$spli2[1],
+    longitude = _geoPart$replace$spli4 === void 0 ? '' : _geoPart$replace$spli4;
+  return showDistanceField ? {
+    latitude: latitude,
+    longitude: longitude,
+    distance: distance
+  } : {
+    latitude: latitude,
+    longitude: longitude
+  };
+};
+export default getMetadataFieldGeoPointValue;

package/lib/metadata/getMetadataFieldVariantValue.js

@@ -0,0 +1,31 @@
+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); }
+import getJsonParsedValue from '@scaleflex/widget-utils/lib/getJsonParsedValue';
+var checkFieldVariantValue = function checkFieldVariantValue(value, possibleValues) {
+  var _possibleValues$filte, _possibleValues$find;
+  return Array.isArray(value) ? possibleValues === null || possibleValues === void 0 ? void 0 : (_possibleValues$filte = possibleValues.filter(function (element) {
+    return value.includes(element === null || element === void 0 ? void 0 : element.internal_unique_value);
+  })) === null || _possibleValues$filte === void 0 ? void 0 : _possibleValues$filte.map(function (selectedVal) {
+    return selectedVal === null || selectedVal === void 0 ? void 0 : selectedVal.label;
+  }) : possibleValues === null || possibleValues === void 0 ? void 0 : (_possibleValues$find = possibleValues.find(function (possibleValue) {
+    return (possibleValue === null || possibleValue === void 0 ? void 0 : possibleValue.internal_unique_value) === value;
+  })) === null || _possibleValues$find === void 0 ? void 0 : _possibleValues$find.label;
+};
+var getMetadataFieldVariantValue = function getMetadataFieldVariantValue(_ref) {
+  var value = _ref.value,
+    possibleValues = _ref.possibleValues,
+    regionalVariantsGroupUuid = _ref.regionalVariantsGroupUuid,
+    _ref$metaRegionalFilt = _ref.metaRegionalFilters,
+    metaRegionalFilters = _ref$metaRegionalFilt === void 0 ? {} : _ref$metaRegionalFilt,
+    _ref$joinArrayValues = _ref.joinArrayValues,
+    joinArrayValues = _ref$joinArrayValues === void 0 ? false : _ref$joinArrayValues;
+  var parsedValue = getJsonParsedValue(value);
+  if (regionalVariantsGroupUuid) {
+    return parsedValue[metaRegionalFilters === null || metaRegionalFilters === void 0 ? void 0 : metaRegionalFilters[regionalVariantsGroupUuid]] || (_typeof(parsedValue) === 'object' ? '' : parsedValue);
+  }
+  if (possibleValues && possibleValues.length > 0) {
+    var fieldVariantValue = checkFieldVariantValue(value, possibleValues);
+    return joinArrayValues && Array.isArray(fieldVariantValue) ? fieldVariantValue.join(', ') : fieldVariantValue;
+  }
+  return (value === null || value === void 0 ? void 0 : value.constructor) === Object ? JSON.stringify(value) : value;
+};
+export default getMetadataFieldVariantValue;

package/lib/metadata/getMetadataGroups.js

@@ -0,0 +1,16 @@
+import { METADATA_MODEL_TYPE_IDS } from '@scaleflex/widget-utils/lib/constants';
+var getMetadataGroups = function getMetadataGroups(metadataModel) {
+  var metaModelType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : METADATA_MODEL_TYPE_IDS.FILES;
+  var isRootOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var model = (metadataModel || []).find(function (model) {
+    return model.applies_to === metaModelType;
+  }) || {};
+  var groups = ((model === null || model === void 0 ? void 0 : model.groups) || []).filter(function (group) {
+    return group && (group.fields || []).length > 0;
+  });
+  return isRootOnly ? groups.filter(function (_ref) {
+    var isRoot = _ref.isRoot;
+    return isRoot;
+  }) : groups;
+};
+export default getMetadataGroups;

package/lib/metadata/getRequiredMetadataFields.js

@@ -0,0 +1,13 @@
+var getRequiredMetadataFields = function getRequiredMetadataFields() {
+  var metadataGroups = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return metadataGroups.reduce(function (acc, curr) {
+    var fields = curr.fields || [];
+    fields.forEach(function (field) {
+      if (field.required) {
+        acc.push(field);
+      }
+    });
+    return acc;
+  }, []);
+};
+export default getRequiredMetadataFields;

package/lib/metadata/isM0LegacyMetaVersion.js

@@ -0,0 +1,5 @@
+import { METADATA_VERSIONS } from '../constants';
+var isM0LegacyMetaVersion = function isM0LegacyMetaVersion(metadataVersion) {
+  return metadataVersion === METADATA_VERSIONS.M0_LEGACY;
+};
+export default isM0LegacyMetaVersion;

package/lib/metadata/isM1EdgyMetaVersion.js

@@ -0,0 +1,5 @@
+import { METADATA_VERSIONS } from '../constants';
+var isM1EdgyMetaVersion = function isM1EdgyMetaVersion(metadataVersion) {
+  return metadataVersion === METADATA_VERSIONS.M1_EDGY;
+};
+export default isM1EdgyMetaVersion;

package/lib/metadata/mapMetaAttachmentsObjsToUuids.js

@@ -0,0 +1,21 @@
+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); }
+import getMetaAttachmentFields from './getMetaAttachmentFields';
+var mapMetaAttachmentsObjsToUuids = function mapMetaAttachmentsObjsToUuids(_ref) {
+  var meta = _ref.meta,
+    _ref$customMetadataGr = _ref.customMetadataGroups,
+    customMetadataGroups = _ref$customMetadataGr === void 0 ? [] : _ref$customMetadataGr;
+  var attachmentsAssetsFields = getMetaAttachmentFields(customMetadataGroups);
+  attachmentsAssetsFields.forEach(function (_ref2) {
+    var key = _ref2.key;
+    var attachmentAssetsValue = meta[key] || [];
+    var attachmentAssetsArray = attachmentAssetsValue.map(function (item) {
+      if (_typeof(item) === 'object') {
+        return item.uuid;
+      }
+      return item;
+    });
+    meta[key] = attachmentAssetsArray;
+  });
+  return meta;
+};
+export default mapMetaAttachmentsObjsToUuids;

package/lib/metadata/updateValidationErrors.js

@@ -0,0 +1,59 @@
+import checkFieldValidation from './checkFieldValidation';
+
+/**
+ * @param {object} errors
+ * @param {string} key
+ * @param {string} [regionalVariantFieldKey]
+ * @param {any} fieldValue
+ * @param {regexp} [fieldValidation]
+ * @param {boolean} [isFieldRequired]
+ * @param {(boolean|string[])} [canEdit=true]
+ */
+function updateValidationErrors(_ref) {
+  var errors = _ref.errors,
+    key = _ref.key,
+    regionalVariantFieldKey = _ref.regionalVariantFieldKey,
+    fieldValue = _ref.fieldValue,
+    fieldValidation = _ref.fieldValidation,
+    isFieldRequired = _ref.isFieldRequired,
+    _ref$canEdit = _ref.canEdit,
+    canEdit = _ref$canEdit === void 0 ? true : _ref$canEdit,
+    i18n = _ref.i18n,
+    fieldType = _ref.fieldType;
+  var errorsClone = JSON.parse(JSON.stringify(errors || {}));
+  var editable = canEdit === true || regionalVariantFieldKey && Array.isArray(canEdit) && canEdit.indexOf(regionalVariantFieldKey) > -1;
+  var isValid = checkFieldValidation({
+    fieldValue: fieldValue,
+    fieldValidation: fieldValidation,
+    isFieldRequired: isFieldRequired,
+    editable: editable,
+    i18n: i18n,
+    fieldType: fieldType
+  });
+  if (isValid === true) {
+    // Valid, remove error
+    if (regionalVariantFieldKey) {
+      if (errorsClone[key] && Object.prototype.hasOwnProperty.call(errorsClone[key], regionalVariantFieldKey)) {
+        delete errorsClone[key][regionalVariantFieldKey];
+        if (!Object.keys(errorsClone[key]).length) {
+          // Object empty, need to remove
+          delete errorsClone[key];
+        }
+      }
+    } else {
+      if (Object.prototype.hasOwnProperty.call(errorsClone, key)) {
+        delete errorsClone[key];
+      }
+    }
+  } else {
+    // Not valid, add error
+    if (regionalVariantFieldKey) {
+      errorsClone[key] = errorsClone[key] || {};
+      errorsClone[key][regionalVariantFieldKey] = isValid || true;
+    } else {
+      errorsClone[key] = isValid || true;
+    }
+  }
+  return errorsClone;
+}
+export default updateValidationErrors;

package/lib/metadata/validateItemMetadata.js

@@ -0,0 +1,70 @@
+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 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 getMetadataGroups from './getMetadataGroups';
+import updateValidationErrors from './updateValidationErrors';
+import { METADATA_MODEL_TYPE_IDS } from '../constants';
+import { checkFileOrFolderNameValidation } from '../checkFileOrFolderNameValidation';
+var validateItemMetadata = function validateItemMetadata(_ref) {
+  var metadata = _ref.metadata,
+    itemMeta = _ref.itemMeta,
+    itemMetadataErrors = _ref.itemMetadataErrors,
+    i18n = _ref.i18n,
+    fileName = _ref.fileName;
+  var model = metadata.model,
+    regionalGroups = metadata.regionalGroups,
+    _metadata$modelType = metadata.modelType,
+    modelType = _metadata$modelType === void 0 ? METADATA_MODEL_TYPE_IDS.FILES : _metadata$modelType;
+  var metaDataGroups = getMetadataGroups(model, modelType);
+  var errors = _objectSpread({}, itemMetadataErrors || {});
+  (metaDataGroups || []).forEach(function (group) {
+    (group.fields || []).forEach(function (fieldItem) {
+      var _regionalGroups$find;
+      var fieldRegionalVariants = regionalGroups === null || regionalGroups === void 0 ? void 0 : (_regionalGroups$find = regionalGroups.find(function (group) {
+        return group.uuid === (fieldItem === null || fieldItem === void 0 ? void 0 : fieldItem.regional_variants_group_uuid);
+      })) === null || _regionalGroups$find === void 0 ? void 0 : _regionalGroups$find.variants;
+      var commonProps = {
+        errors: errors,
+        key: fieldItem.key,
+        fieldValidation: fieldItem.validation,
+        canEdit: fieldItem.can_edit,
+        i18n: i18n
+      };
+      if (fieldRegionalVariants && Array.isArray(fieldRegionalVariants)) {
+        fieldRegionalVariants.forEach(function (_ref2, index) {
+          var _itemMeta$fieldItem$k;
+          var regionalVariantKey = _ref2.api_value;
+          // When field is required and has reg variants, for example ["en", "fr", "de"] we should check only first variant "en" and skip "fr" and "de"
+          var shouldCheckIsRequired = index === 0;
+          errors = updateValidationErrors(_objectSpread(_objectSpread({}, commonProps), {}, {
+            regionalVariantFieldKey: regionalVariantKey,
+            fieldValue: itemMeta === null || itemMeta === void 0 ? void 0 : (_itemMeta$fieldItem$k = itemMeta[fieldItem.key]) === null || _itemMeta$fieldItem$k === void 0 ? void 0 : _itemMeta$fieldItem$k[regionalVariantKey],
+            isFieldRequired: shouldCheckIsRequired ? fieldItem.required : false
+          }));
+        });
+      } else {
+        errors = updateValidationErrors(_objectSpread(_objectSpread({}, commonProps), {}, {
+          fieldValue: itemMeta === null || itemMeta === void 0 ? void 0 : itemMeta[fieldItem.key],
+          isFieldRequired: fieldItem.required,
+          fieldType: fieldItem.type
+        }));
+      }
+    });
+  });
+  var allErrors = errors;
+  if (fileName) {
+    if (checkFileOrFolderNameValidation(fileName)) {
+      allErrors = _objectSpread({
+        name: i18n('explorerFileRenameInvalidNameDesc')
+      }, allErrors);
+    }
+  }
+  return {
+    isValid: Object.keys(errors).length === 0,
+    errors: allErrors
+  };
+};
+export default validateItemMetadata;

package/lib/mimeTypes.js

@@ -0,0 +1,60 @@
+// ___Why not add the mime-types package?
+//    It's 19.7kB gzipped, and we only need mime types for well-known extensions (for file previews).
+// ___Where to take new extensions from?
+//    https://github.com/jshttp/mime-db/blob/master/db.json
+
+export default {
+  md: 'text/markdown',
+  markdown: 'text/markdown',
+  mp4: 'video/mp4',
+  mp3: 'audio/mp3',
+  svg: 'image/svg+xml',
+  jpg: 'image/jpeg',
+  png: 'image/png',
+  gif: 'image/gif',
+  heic: 'image/heic',
+  heif: 'image/heif',
+  tiff: 'image/tiff',
+  yaml: 'text/yaml',
+  yml: 'text/yaml',
+  csv: 'text/csv',
+  tsv: 'text/tab-separated-values',
+  tab: 'text/tab-separated-values',
+  avi: 'video/x-msvideo',
+  mks: 'video/x-matroska',
+  mkv: 'video/x-matroska',
+  mov: 'video/quicktime',
+  doc: 'application/msword',
+  docm: 'application/vnd.ms-word.document.macroenabled.12',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  dot: 'application/msword',
+  dotm: 'application/vnd.ms-word.template.macroenabled.12',
+  dotx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+  xla: 'application/vnd.ms-excel',
+  xlam: 'application/vnd.ms-excel.addin.macroenabled.12',
+  xlc: 'application/vnd.ms-excel',
+  xlf: 'application/x-xliff+xml',
+  xlm: 'application/vnd.ms-excel',
+  xls: 'application/vnd.ms-excel',
+  xlsb: 'application/vnd.ms-excel.sheet.binary.macroenabled.12',
+  xlsm: 'application/vnd.ms-excel.sheet.macroenabled.12',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  xlt: 'application/vnd.ms-excel',
+  xltm: 'application/vnd.ms-excel.template.macroenabled.12',
+  xltx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
+  xlw: 'application/vnd.ms-excel',
+  txt: 'text/plain',
+  text: 'text/plain',
+  conf: 'text/plain',
+  log: 'text/plain',
+  eps: 'image/x-eps',
+  pdf: 'application/pdf',
+  postScript: 'application/postscript',
+  psd: 'image/vnd.adobe.photoshop',
+  psb: 'image/vnd.adobe.photoshop',
+  ttf: 'font/ttf',
+  xttf: 'application/x-font-ttf',
+  sfnt: 'application/font-sfnt',
+  otf: 'application/vnd.ms-opentype',
+  fdt: 'text/xml+sfxtemplate'
+};

package/lib/nanoid.js

@@ -0,0 +1,18 @@
+/* Borrowed from https://github.com/ai/nanoid/blob/3.0.2/non-secure/index.js
+* & https://github.com/reduxjs/redux-toolkit/blob/master/packages/toolkit/src/nanoid.ts
+* This alphabet uses `A-Za-z0-9_-` symbols. A genetic algorithm helped
+* optimize the gzip compression for this alphabet.
+*/
+var urlAlphabet = 'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW';
+var nanoid = function nanoid() {
+  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 21;
+  var id = '';
+  // A compact alternative for `for (var i = 0; i < step; i++)`.
+  var i = size;
+  while (i--) {
+    // `| 0` is more compact and faster than `Math.floor()`.
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+export default nanoid;

package/lib/openLink.js

@@ -0,0 +1,3 @@
+export default (function (url) {
+  window.open(url, '_blank');
+});

package/lib/openLinkInNewTab.js

@@ -0,0 +1,12 @@
+export var openLinkInNewTab = function openLinkInNewTab(href) {
+  if (href) {
+    var tmpLinkElement = document.createElement('a');
+    tmpLinkElement.href = href;
+    tmpLinkElement.setAttribute('target', '_blank');
+    tmpLinkElement.setAttribute('rel', 'noopener noreferrer');
+    tmpLinkElement.style = 'position: absolute; z-index: -1111;';
+    document.body.appendChild(tmpLinkElement);
+    tmpLinkElement.click();
+    document.body.removeChild(tmpLinkElement);
+  }
+};

package/lib/prettyETA.js

@@ -0,0 +1,15 @@
+import secondsToTime from './secondsToTime';
+export default function prettyETA(seconds) {
+  if (!seconds) return seconds;
+  var time = secondsToTime(seconds);
+
+  // Only display hours and minutes if they are greater than 0 but always
+  // display minutes if hours is being displayed
+  // Display a leading zero if the there is a preceding unit: 1m 05s, but 5s
+  var hoursStr = time.hours ? time.hours + 'h ' : '';
+  var minutesVal = time.hours ? ('0' + time.minutes).substr(-2) : time.minutes;
+  var minutesStr = minutesVal ? minutesVal + 'm' : '';
+  var secondsVal = minutesVal ? ('0' + time.seconds).substr(-2) : time.seconds;
+  var secondsStr = time.hours ? '' : minutesVal ? ' ' + secondsVal + 's' : secondsVal + 's';
+  return "".concat(hoursStr).concat(minutesStr).concat(secondsStr);
+}

package/lib/prettyFileSize.js

@@ -0,0 +1,7 @@
+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); }
+import prettierBytes from '@transloadit/prettier-bytes';
+var prettyFileSize = function prettyFileSize() {
+  var fileSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return fileSize && ((fileSize === null || fileSize === void 0 ? void 0 : fileSize.pretty) || (fileSize === null || fileSize === void 0 ? void 0 : fileSize.total_recursive_pretty) || prettierBytes(fileSize && _typeof(fileSize) === 'object' ? fileSize.bytes || fileSize.total_recursive_bytes : fileSize));
+};
+export default prettyFileSize;

package/lib/preventDefault.js

@@ -0,0 +1,4 @@
+var preventDefault = function preventDefault(event) {
+  event.preventDefault();
+};
+export default preventDefault;

package/lib/provideSvgStrWithCurrColor.js

@@ -0,0 +1,10 @@
+var provideSvgStrWithCurrColor = function provideSvgStrWithCurrColor(svgString) {
+  var preparedSvgString = svgString.replaceAll(/(<\?xml.*?>|<!--.*-->)[\r\n]?/gi, '');
+  var startOfSvgTagIndex = preparedSvgString.indexOf('<svg');
+  // we are checking start of the tag first for making sure we would catch the first end after the svg opening to avoid issues.
+  var endOfSvgTagIndex = startOfSvgTagIndex + preparedSvgString.substr(startOfSvgTagIndex).indexOf('>');
+  var svgTagWithPreparedColor = "".concat(preparedSvgString.substr(0, endOfSvgTagIndex).replace(/\s*(?:fill|stroke|color)[:=]\s*['"]?.*['"; }]/i, '').trim(), " color=\"currentColor\" fill=\"currentColor\"");
+  var restOfSvgElementPreparedColor = preparedSvgString.substr(endOfSvgTagIndex, preparedSvgString.length).replaceAll(/(\s*(?:fill|stroke|color)[:=]\s*['"]?)#?\b(?!\s*?none).+?([\r\n'";})])/gi, '$1currentColor$2').replaceAll(/(\n\t|\n|\t)/g, ' ');
+  return svgTagWithPreparedColor + restOfSvgElementPreparedColor;
+};
+export default provideSvgStrWithCurrColor;

package/lib/recursiveFnCall.js

@@ -0,0 +1,26 @@
+/**
+ * Run fn recursively with intervals until fn is defined.
+ */
+var recursiveFnCall = function recursiveFnCall() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$delay = _ref.delay,
+    delay = _ref$delay === void 0 ? 500 : _ref$delay,
+    getFn = _ref.getFn,
+    _ref$maxAttempts = _ref.maxAttempts,
+    maxAttempts = _ref$maxAttempts === void 0 ? 20 : _ref$maxAttempts;
+  var timeoutCount = 0;
+  var _recursiveTimeout = function recursiveTimeout() {
+    var _delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : delay;
+    setTimeout(function () {
+      timeoutCount++;
+      var fn = getFn();
+      if (typeof fn === 'function') {
+        fn();
+      } else if (timeoutCount <= maxAttempts) {
+        _recursiveTimeout();
+      }
+    }, _delay);
+  };
+  _recursiveTimeout(0);
+};
+export default recursiveFnCall;

package/lib/removeAllUrlParams.js

@@ -0,0 +1,4 @@
+var removeAllUrlParams = function removeAllUrlParams(url) {
+  return url.replace(/\?.*$/, '');
+};
+export default removeAllUrlParams;

package/lib/removeDuplicatesFromArray.js

@@ -0,0 +1,20 @@
+/**
+ * Removes duplicate objects from an array based on a specified unique property.
+ *
+ * This function iterates through the array and uses a Set to keep track of the unique values
+ * of the specified property. If a duplicate value is found, the object is filtered out.
+ *
+ * @param {Array<Object>} array - The array of objects to be filtered.
+ * @param {string} uniqueProperty - The property name to check for uniqueness.
+ * @returns {Array<Object>} A new array with duplicate objects removed.
+ */
+
+var removeDuplicatesFromArray = function removeDuplicatesFromArray(array, uniqueProperty) {
+  var seenSet = new Set();
+  return array.filter(function (item) {
+    var duplicate = seenSet.has(item[uniqueProperty]);
+    seenSet.add(item[uniqueProperty]);
+    return !duplicate;
+  });
+};
+export default removeDuplicatesFromArray;

package/lib/removeEmptyFolders.js

@@ -0,0 +1,8 @@
+var removeEmptyFolders = function removeEmptyFolders(folders) {
+  return folders.filter(function (_ref) {
+    var files = _ref.files,
+      folders = _ref.folders;
+    return (files === null || files === void 0 ? void 0 : files.length) > 0 || (folders === null || folders === void 0 ? void 0 : folders.length) > 0;
+  });
+};
+export default removeEmptyFolders;

package/lib/removeFileExtension.js

@@ -0,0 +1,4 @@
+export var removeFileExtension = function removeFileExtension() {
+  var fileName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return fileName.replace(/\.[^/.]+$/, '');
+};

package/lib/removeUrlParamsWithRegex.js

@@ -0,0 +1,14 @@
+var removeUrlParamsWithRegex = function removeUrlParamsWithRegex() {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (!Array.isArray(params) || params.length === 0) return url;
+  var updatedUrl = url;
+  params.forEach(function (param) {
+    var regex = new RegExp("[?&]".concat(param, "=[^&]*(&|$)"));
+    updatedUrl = updatedUrl.replace(regex, function (_, p1) {
+      return p1 === '&' ? '?' : '';
+    });
+  });
+  return updatedUrl.replace(/[?&]$/, '');
+};
+export default removeUrlParamsWithRegex;

package/lib/reorder.js

@@ -0,0 +1,15 @@
+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; }
+var reorder = function reorder(list, startIndex, endIndex) {
+  var result = Array.from(list);
+  var _result$splice = result.splice(startIndex, 1),
+    _result$splice2 = _slicedToArray(_result$splice, 1),
+    removed = _result$splice2[0];
+  result.splice(endIndex, 0, removed);
+  return result;
+};
+export default reorder;

package/lib/requestFile.js

@@ -0,0 +1,36 @@
+import RequestError from '@scaleflex/widget-utils/lib/RequestError';
+var requestFile = function requestFile(url, options) {
+  return new Promise(function (resolve, reject) {
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url);
+    xhr.responseType = 'blob';
+    if (options !== null && options !== void 0 && options.headers) {
+      Object.keys(options.headers).map(function (headerName) {
+        return xhr.setRequestHeader(headerName, options.headers[headerName]);
+      });
+    }
+    xhr.onload = function () {
+      if (xhr.status === 200) {
+        resolve(xhr.response);
+      } else {
+        reject(new Error("Request error (".concat(xhr.status, ")")));
+      }
+    };
+    xhr.onerror = function () {
+      return reject(new RequestError({
+        code: xhr.status,
+        message: 'Check your internet connection'
+      }));
+    };
+    if (options !== null && options !== void 0 && options.onProgress) {
+      xhr.onprogress = function (e) {
+        options.onProgress(e.loaded, e.total);
+      };
+    }
+    if (options !== null && options !== void 0 && options.cancel) {
+      options.cancel(xhr);
+    }
+    xhr.send();
+  });
+};
+export default requestFile;

package/lib/rgbToHex.js

@@ -0,0 +1,4 @@
+var rgbToHex = function rgbToHex(r, g, b) {
+  return '#' + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+};
+export default rgbToHex;

package/lib/secondsToTime.js

@@ -0,0 +1,10 @@
+export default function secondsToTime(rawSeconds) {
+  var hours = Math.floor(rawSeconds / 3600) % 24;
+  var minutes = Math.floor(rawSeconds / 60) % 60;
+  var seconds = Math.floor(rawSeconds % 60);
+  return {
+    hours: hours,
+    minutes: minutes,
+    seconds: seconds
+  };
+}

package/lib/serializeFunction.js

@@ -0,0 +1,4 @@
+var serializeFunction = function serializeFunction(fn) {
+  return fn.toString();
+};
+export default serializeFunction;

package/lib/settle.js

@@ -0,0 +1,19 @@
+export default function settle(promises) {
+  var resolutions = [];
+  var rejections = [];
+  function resolved(value) {
+    resolutions.push(value);
+  }
+  function rejected(error) {
+    rejections.push(error);
+  }
+  var wait = Promise.all(promises.map(function (promise) {
+    return promise.then(resolved, rejected);
+  }));
+  return wait.then(function () {
+    return {
+      successful: resolutions,
+      failed: rejections
+    };
+  });
+}