@scaleflex/widget-utils 4.4.0 → 4.5.0

package/lib/isDragDropSupported.js

@@ -0,0 +1,20 @@
+/**
+ * Checks if the browser supports Drag & Drop (not supported on mobile devices, for example).
+ * @property {HTMLElement} htmlElement
+ * @returns {boolean}
+ */
+export default function isDragDropSupported(htmlElement) {
+  var element = htmlElement || document.createElement('div');
+  if (element !== document) {
+    if (!('draggable' in element) || !('ondragstart' in element && 'ondrop' in element)) {
+      return false;
+    }
+  }
+  if (!('FormData' in window)) {
+    return false;
+  }
+  if (!('FileReader' in window)) {
+    return false;
+  }
+  return true;
+}

package/lib/isEmptyObject.js

@@ -0,0 +1,4 @@
+var isEmptyObject = function isEmptyObject(value) {
+  return Object.keys(value).length === 0 && value.constructor === Object;
+};
+export default isEmptyObject;

package/lib/isEps.js

@@ -0,0 +1,8 @@
+import getFileType from './getFileType';
+import mimeTypes from './mimeTypes';
+export default function isEps(file) {
+  if (!file) {
+    return false;
+  }
+  return getFileType(file).toLowerCase() === mimeTypes.eps;
+}

package/lib/isFile.js

@@ -0,0 +1,5 @@
+import isFolder from './isFolder';
+var isFile = function isFile(item) {
+  return !isFolder(item);
+};
+export default isFile;

package/lib/isFileSupportedByCloudimage.js

@@ -0,0 +1,14 @@
+import cloudimageSupportedInputMimiTypes from './cloudimageSupportedInputMimeTypes';
+import getFileType from './getFileType';
+
+/**
+ * Check if the selected item type is supported input for cloudimage
+ *
+ * @param {object} item
+ * @returns {Boolean}
+ */
+
+var isFileSupportedByCloudimage = function isFileSupportedByCloudimage(file) {
+  return cloudimageSupportedInputMimiTypes.includes(getFileType(file));
+};
+export default isFileSupportedByCloudimage;

package/lib/isFolder.js

@@ -0,0 +1,4 @@
+var isFolder = function isFolder(item) {
+  return (item === null || item === void 0 ? void 0 : item.isFolder) || (item === null || item === void 0 ? void 0 : item.type) === 'folder' || Boolean(item.path);
+};
+export default isFolder;

package/lib/isFontFile.js

@@ -0,0 +1,9 @@
+import mimeTypes from './mimeTypes';
+import getFileType from './getFileType';
+var isFontFile = function isFontFile() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!file) return false;
+  var fileType = getFileType(file).toLowerCase();
+  return fileType.toLowerCase().includes('font') || fileType === mimeTypes.otf || fileType === mimeTypes.ttf || fileType === mimeTypes.xttf || fileType === mimeTypes.sfnt;
+};
+export default isFontFile;

package/lib/isFunction.js

@@ -0,0 +1,4 @@
+var isFunction = function isFunction(func) {
+  return typeof func === 'function';
+};
+export default isFunction;

package/lib/isImage.js

@@ -0,0 +1,11 @@
+import getFileType from './getFileType';
+export default function isImage() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!file) {
+    return false;
+  }
+
+  // More determined logic as some mimeTypes like photoshop has (image/vnd.photoshop...)
+  // which shouldn't be treated as image in that case.
+  return /^image\/(jpeg|jpg|png|gif|apng|avif|heif|heic|svg\+xml|svg|webp|x-icon|bmp|x-ms-bmp|tiff|vnd\.microsoft\.icon)$/.test(getFileType(file).toLowerCase());
+}

package/lib/isJpg.js

@@ -0,0 +1,8 @@
+import getFileType from './getFileType';
+import mimeTypes from './mimeTypes';
+export default function isJpg(file) {
+  if (!file) {
+    return false;
+  }
+  return getFileType(file).toLowerCase() === mimeTypes.jpg;
+}

package/lib/isMobileDevice.js

@@ -0,0 +1,12 @@
+/**
+ * Checks if current device reports itself as “mobile”.
+ * Very simple, not very reliable.
+ *
+ * @returns {boolean}
+ */
+export default function isMobileDevice() {
+  if (typeof window !== 'undefined' && window.navigator && window.navigator.userAgent && window.navigator.userAgent.match(/Mobi/)) {
+    return true;
+  }
+  return false;
+}

package/lib/isNetworkError.js

@@ -0,0 +1,7 @@
+function isNetworkError(xhr) {
+  if (!xhr) {
+    return false;
+  }
+  return xhr.readyState !== 0 && xhr.readyState !== 4 || xhr.status === 0;
+}
+export default isNetworkError;

package/lib/isNumber.js

@@ -0,0 +1,4 @@
+var isNumber = function isNumber(value) {
+  return Number.isFinite(value);
+};
+export default isNumber;

package/lib/isObjectType.js

@@ -0,0 +1,5 @@
+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 isObjectType = function isObjectType(variable) {
+  return _typeof(variable) === 'object' && !Array.isArray(variable) && variable !== null;
+};
+export default isObjectType;

package/lib/isObjectURL.js

@@ -0,0 +1,10 @@
+/**
+ * Check if a URL string is an object URL from `URL.createObjectURL`.
+ *
+ * @param {string} url
+ * @returns {boolean}
+ */
+export default function isObjectURL() {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return url.indexOf('blob:') === 0;
+}

package/lib/isOpenedFromAdobe.js

@@ -0,0 +1,3 @@
+export default function isOpenedFromAdobe() {
+  return Boolean(window.cep);
+}

package/lib/isOtf.js

@@ -0,0 +1,10 @@
+import mimeTypes from './mimeTypes';
+import getFileType from './getFileType';
+var isOtf = function isOtf(file) {
+  if (!file) {
+    return false;
+  }
+  var fileType = getFileType(file).toLowerCase();
+  return fileType === mimeTypes.otf || file.name.includes('.otf');
+};
+export default isOtf;

package/lib/isPdf.js

@@ -0,0 +1,9 @@
+import getFileType from './getFileType';
+import mimeTypes from './mimeTypes';
+var PDF_MIME_TYPES = [mimeTypes.pdf, mimeTypes.postScript];
+export default function isPdf(file) {
+  if (!file) {
+    return false;
+  }
+  return PDF_MIME_TYPES.includes(getFileType(file).toLowerCase());
+}

package/lib/isPhotoshopFile.js

@@ -0,0 +1,8 @@
+import getFileType from './getFileType';
+import mimeTypes from './mimeTypes';
+export default function isPhotoshopFile(file) {
+  if (!file) {
+    return false;
+  }
+  return getFileType(file).toLowerCase() === mimeTypes.psd;
+}

package/lib/isPreviewSupported.js

@@ -0,0 +1,12 @@
+import isImage from './isImage';
+import isPdf from './isPdf';
+import isOpenedFromAdobe from './isOpenedFromAdobe';
+import isSupportedVideo from './isSupportedVideo';
+import isFontFile from './isFontFile';
+export default function isPreviewSupported(file) {
+  // Checking if we could show a preview for this item or not
+  if (isImage(file) || isPdf(file) && !isOpenedFromAdobe() || isSupportedVideo(file) && !isOpenedFromAdobe() || isFontFile(file)) {
+    return true;
+  }
+  return false;
+}

package/lib/isPromise.js

@@ -0,0 +1,5 @@
+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 isPromise = function isPromise(obj) {
+  return obj && (obj instanceof Promise || (_typeof(obj) === 'object' || typeof obj === 'function') && typeof obj.then === 'function' && typeof obj["catch"] === 'function');
+};
+export default isPromise;

package/lib/metadata/checkFieldValidation.js

@@ -0,0 +1,51 @@
+import getGeoPointValidationErrors from './getGeoPointValidationErrors';
+import isValidUri from '../isValidUri';
+
+/**
+ * Check is metadata field value valid
+ * @param {(string|number|array)} value
+ * @param {string} [fieldValidation]
+ * @param {boolean} [required]
+ * @returns {(boolean|string)} - If TRUE field is valid, if FALSE or message field is not valid.
+ * @param {boolean} [canEdit=true]
+ */
+function checkFieldValidation(_ref) {
+  var fieldValue = _ref.fieldValue,
+    fieldValidation = _ref.fieldValidation,
+    isFieldRequired = _ref.isFieldRequired,
+    _ref$editable = _ref.editable,
+    editable = _ref$editable === void 0 ? true : _ref$editable,
+    i18n = _ref.i18n,
+    fieldType = _ref.fieldType;
+  if (isFieldRequired && editable && (!fieldValue || Array.isArray(fieldValue) && !fieldValue.length)) {
+    return typeof i18n === 'function' ? i18n('mutualizedFieldRequired') : 'Field is required!';
+  }
+
+  /**
+   * When field is required but current user can't edit the field, we have to set that current value is valid to unlock other fields save.
+   */
+  if (isFieldRequired && !editable) {
+    return true;
+  }
+  if (fieldType === 'attachment-uri' && !isValidUri(fieldValue) && fieldValue) {
+    return false;
+  }
+  if (fieldType === 'geopoint' && Object.keys(getGeoPointValidationErrors({
+    geoPoint: fieldValue
+  })).length > 0 && fieldValue) {
+    return false;
+  }
+  if (!fieldValidation) {
+    // If no fieldValidation rules return TRUE (field valid)
+    return true;
+  }
+  if (typeof fieldValidation !== 'string') {
+    console.warn('Metadata field validation: support string only!', {
+      fieldValue: fieldValue,
+      fieldValidation: fieldValidation
+    });
+    return true;
+  }
+  return new RegExp(fieldValidation).test(fieldValue) ? true : "String \"".concat(fieldValue, "\" not match regexp ").concat(fieldValidation);
+}
+export default checkFieldValidation;

package/lib/metadata/generateItemMetadataState.js

@@ -0,0 +1,63 @@
+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 generateMetadataDefaultState from '@scaleflex/widget-utils/lib/metadata/generateMetadataDefaultState';
+
+/**
+ * @param {object[]} metaDataGroups
+ * @param {object} item - File or folder
+ * @param {object[]} metaRegionalGroups
+ * @returns {object} - Item metadata state
+ */
+export function generateItemMetadataState(metaDataGroups, item, metaRegionalGroups) {
+  var defaultState = generateMetadataDefaultState(metaDataGroups, metaRegionalGroups);
+  var itemMetadataState = _objectSpread(_objectSpread({}, defaultState), JSON.parse(JSON.stringify(item.meta || {})));
+
+  /**
+   * Sometimes we have cases when field had simple value like string (ex: {title: "My title"}) and then
+   * field config was changed and now we have regional_variants. Now {title: {en: "Eng title", fr: "title"}}
+   */
+  (metaDataGroups || []).forEach(function (group) {
+    ((group || {}).fields || []).forEach(function (field) {
+      var _metaRegionalGroups$f;
+      var fieldRegionalVariants = metaRegionalGroups === null || metaRegionalGroups === void 0 ? void 0 : (_metaRegionalGroups$f = metaRegionalGroups.find(function (group) {
+        return group.uuid === (field === null || field === void 0 ? void 0 : field.regional_variants_group_uuid);
+      })) === null || _metaRegionalGroups$f === void 0 ? void 0 : _metaRegionalGroups$f.variants;
+      var fieldHasRegionalVars = (fieldRegionalVariants || []).length > 0;
+      var isStateValueObject = _typeof(itemMetadataState[field.key]) === 'object' && !Array.isArray(itemMetadataState[field.key]) && itemMetadataState[field.key] !== null;
+      if (fieldHasRegionalVars && !isStateValueObject || !fieldHasRegionalVars && isStateValueObject) {
+        itemMetadataState[field.key] = defaultState[field.key];
+      }
+      if ((field === null || field === void 0 ? void 0 : field.type) === 'tags' && fieldHasRegionalVars) {
+        // Fix bug https://sfx.li/6AGcWPsVyfZakK (also we need 2 fixed: BE and @scaleflex/ui)
+        itemMetadataState[field.key] = itemMetadataState[field.key] || {};
+        fieldRegionalVariants.forEach(function (regVar) {
+          var _itemMetadataState$fi;
+          var value = (_itemMetadataState$fi = itemMetadataState[field.key]) === null || _itemMetadataState$fi === void 0 ? void 0 : _itemMetadataState$fi[regVar === null || regVar === void 0 ? void 0 : regVar.api_value];
+          itemMetadataState[field.key][regVar === null || regVar === void 0 ? void 0 : regVar.api_value] = adaptStringifiedArray(value);
+        });
+      }
+    });
+  });
+  return itemMetadataState;
+}
+function adaptStringifiedArray(value) {
+  if (value) {
+    if (Array.isArray(value)) {
+      return value;
+    } else if (typeof value === 'string') {
+      try {
+        var arrayVal = JSON.parse(value);
+        if (arrayVal && Array.isArray(arrayVal)) {
+          return arrayVal;
+        }
+      } catch (error) {
+        console.warn("Meta tag field has not valid value, must be an array but we receive \"".concat(value, "\""));
+      }
+    }
+  }
+  return [];
+}

package/lib/metadata/generateMetadataDefaultState.js

@@ -0,0 +1,30 @@
+/**
+ * @param {{fields: object}[]} metabaseGroups
+ * @param {object[]} metaRegionalGroups
+ * @returns {object}
+ */
+function generateMetadataDefaultState(metabaseGroups, metaRegionalGroups) {
+  var defaultMetadata = {};
+  (metabaseGroups || []).forEach(function (group) {
+    ((group || {}).fields || []).filter(function (field) {
+      return field.key;
+    }).forEach(function (field) {
+      var _metaRegionalGroups$f;
+      var value = typeof field.default_value !== 'undefined' ? field.default_value : ['tags', 'multi-select'].indexOf(field.type) > -1 ? [] : null;
+      var fieldRegionalVariants = metaRegionalGroups === null || metaRegionalGroups === void 0 ? void 0 : (_metaRegionalGroups$f = metaRegionalGroups.find(function (group) {
+        return group.uuid === (field === null || field === void 0 ? void 0 : field.regional_variants_group_uuid);
+      })) === null || _metaRegionalGroups$f === void 0 ? void 0 : _metaRegionalGroups$f.variants;
+      if (fieldRegionalVariants && Array.isArray(fieldRegionalVariants)) {
+        defaultMetadata[field.key] = defaultMetadata[field.key] || {};
+        fieldRegionalVariants.forEach(function (_ref) {
+          var regionalVariantKey = _ref.api_value;
+          defaultMetadata[field.key][regionalVariantKey] = value;
+        });
+      } else {
+        defaultMetadata[field.key] = value;
+      }
+    });
+  });
+  return defaultMetadata;
+}
+export default generateMetadataDefaultState;

package/lib/metadata/getFileCustomMetadataGroups.js

@@ -0,0 +1,23 @@
+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 { METADATA_MODEL_TYPE_IDS } from '../constants';
+var getFileCustomMetadataGroup = function getFileCustomMetadataGroup(metadataModel) {
+  var _metadataModel$filter;
+  var customMetadataGroups = [];
+  metadataModel === null || metadataModel === void 0 ? void 0 : (_metadataModel$filter = metadataModel.filter(function (_ref) {
+    var appliesTo = _ref.applies_to;
+    return appliesTo === METADATA_MODEL_TYPE_IDS.FILES;
+  })) === null || _metadataModel$filter === void 0 ? void 0 : _metadataModel$filter.forEach(function (_ref2) {
+    var _ref3;
+    var groups = _ref2.groups;
+    customMetadataGroups.push.apply(customMetadataGroups, _toConsumableArray((_ref3 = groups || []) === null || _ref3 === void 0 ? void 0 : _ref3.filter(function (group) {
+      return !group.isRoot;
+    })));
+  });
+  return customMetadataGroups;
+};
+export default getFileCustomMetadataGroup;

package/lib/metadata/getGeoPointValidationErrors.js

@@ -0,0 +1,32 @@
+import { MAX_LONGITUDE, MIN_LONGITUDE, MAX_LATITUDE, MIN_LATITUDE } from '@scaleflex/widget-common/lib/MetaData/MetaDataFieldTypes/MetadataGeoPointField/constants';
+import getMetadataFieldGeoPointValue from './getMetadataFieldGeoPointValue';
+var getGeoPointValidationErrors = function getGeoPointValidationErrors(_ref) {
+  var _ref$geoPoint = _ref.geoPoint,
+    geoPoint = _ref$geoPoint === void 0 ? '' : _ref$geoPoint,
+    _ref$showDistanceFiel = _ref.showDistanceField,
+    showDistanceField = _ref$showDistanceFiel === void 0 ? false : _ref$showDistanceFiel;
+  if (!geoPoint || typeof geoPoint !== 'string') return {};
+  var baseGeoPoint = geoPoint.replace('~', '');
+  var errors = {};
+  var _ref2 = getMetadataFieldGeoPointValue(baseGeoPoint, showDistanceField) || {},
+    longitude = _ref2.longitude,
+    latitude = _ref2.latitude,
+    distance = _ref2.distance;
+  if (!longitude && !latitude) {
+    return errors;
+  }
+  var longitudeNum = Number(longitude);
+  var latitudeNum = Number(latitude);
+  var isLongitudeValid = longitudeNum >= MIN_LONGITUDE && longitudeNum <= MAX_LONGITUDE;
+  var isLatitudeValid = latitudeNum >= MIN_LATITUDE && latitudeNum <= MAX_LATITUDE;
+  if (showDistanceField && !distance) errors.distance = 'metadataDistanceGeoPointFieldError';
+  if (!isLongitudeValid) errors.longitude = 'metadataLongitudeGeoPointLimitFieldError';
+  if (!isLatitudeValid) errors.latitude = 'metadataLatitudeGeoPointLimitFieldError';
+  if (!longitude || !latitude) {
+    if (!longitude) errors.longitude = 'metadataLongitudeGeoPointFieldError';
+    if (!latitude) errors.latitude = 'metadataLatitudeGeoPointFieldError';
+    return errors;
+  }
+  return errors;
+};
+export default getGeoPointValidationErrors;

package/lib/metadata/getMetaAttachmentFields.js

@@ -0,0 +1,9 @@
+var getMetaAttachmentFields = function getMetaAttachmentFields(customMetadataGroups) {
+  return customMetadataGroups.reduce(function (acc, curr) {
+    var filteredFields = curr.fields.filter(function (field) {
+      return field.type === 'attachments-assets';
+    });
+    return acc.concat(filteredFields);
+  }, []);
+};
+export default getMetaAttachmentFields;

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;