@scaleflex/widget-utils 0.0.1

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/isPsd.js

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

package/lib/isScriptFile.js

@@ -0,0 +1,12 @@
+import getFileExtension from './getFileExtension';
+export default function isScriptFile() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!file) {
+    return false;
+  }
+  var scriptExtensions = ['js', 'py', 'sh', 'php', 'jsx', 'tsx'];
+  var fileType = getFileExtension(file).toLowerCase();
+  return scriptExtensions.some(function (ext) {
+    return fileType === ext;
+  });
+}

package/lib/isSupportedVideo.js

@@ -0,0 +1,8 @@
+import getFileType from './getFileType';
+export default function isSupportedVideo() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!file) {
+    return false;
+  }
+  return /^video\/(mp4|quicktime|3gpp|x-msvideo|webm|x-matroska)/.test(getFileType(file).toLowerCase());
+}

package/lib/isSvg.js

@@ -0,0 +1,5 @@
+import getFileType from './getFileType';
+var isSvg = function isSvg(file) {
+  return getFileType(file) === 'image/svg+xml';
+};
+export default isSvg;

package/lib/isTextFile.js

@@ -0,0 +1,8 @@
+import getFileType from './getFileType';
+export default function isTextFile() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!file) {
+    return false;
+  }
+  return /^text\/(plain|markdown|yaml|tab-separated-values)/.test(getFileType(file).toLowerCase());
+}

package/lib/isThumbnailCloudimgSupported.js

@@ -0,0 +1,13 @@
+import isAi from './isAi';
+import isEps from './isEps';
+import isFontFile from './isFontFile';
+import isImage from './isImage';
+import isPdf from './isPdf';
+import isPhotoshopFile from './isPhotoshopFile';
+export default function isThumbnailCloudimgSupported(file) {
+  // Checking if we could show a preview for this item or not
+  if (isImage(file) || isPdf(file) || isPhotoshopFile(file) || isEps(file) || isAi(file) || isFontFile(file)) {
+    return true;
+  }
+  return false;
+}

package/lib/isThumbnailLocallySupported.js

@@ -0,0 +1,9 @@
+import isImage from './isImage';
+import isPhotoshopFile from './isPhotoshopFile';
+export default function isThumbnailLocallySupported(file) {
+  // Checking if we could show a preview for this item or not
+  if (isImage(file) || isPhotoshopFile(file)) {
+    return true;
+  }
+  return false;
+}

package/lib/isTiff.js

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

package/lib/isTransparencySupported.js

@@ -0,0 +1,12 @@
+import isSvg from '@scaleflex/widget-utils/lib/isSvg';
+import isTiff from './isTiff';
+export default function isTransparencySupported(file) {
+  var _file$type, _file$type2, _file$type3;
+  if (!file) {
+    return false;
+  }
+  var isPng = (_file$type = file.type) === null || _file$type === void 0 ? void 0 : _file$type.includes('png');
+  var isGif = (_file$type2 = file.type) === null || _file$type2 === void 0 ? void 0 : _file$type2.includes('gif');
+  var isBmp = (_file$type3 = file.type) === null || _file$type3 === void 0 ? void 0 : _file$type3.includes('bmp');
+  return isPng || isGif || isBmp || isSvg(file) || isTiff(file);
+}

package/lib/isTtf.js

@@ -0,0 +1,11 @@
+import { TTF_FONT_MIME_TYPES } from './constants';
+import getFileType from './getFileType';
+var isTtf = function isTtf(file) {
+  var _file$name, _file$name$toLowerCas;
+  if (!file) {
+    return false;
+  }
+  var fileType = getFileType(file).toLowerCase();
+  return TTF_FONT_MIME_TYPES.includes(fileType) && ((_file$name = file.name) === null || _file$name === void 0 ? void 0 : (_file$name$toLowerCas = _file$name.toLowerCase()) === null || _file$name$toLowerCas === void 0 ? void 0 : _file$name$toLowerCas.includes('.ttf'));
+};
+export default isTtf;

package/lib/isUploadableFile.js

@@ -0,0 +1,7 @@
+// as uploadStep is a property of the files being uploaded, also id is specificed in the files being uploaded
+// cause the files found on backend are using uuid instead of id.
+var isUploadableFile = function isUploadableFile() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return file ? Boolean(file.uploadStep || file.id) : false;
+};
+export default isUploadableFile;

package/lib/isUrl.js

@@ -0,0 +1,5 @@
+var isUrl = function isUrl() {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return url.startsWith('http://') || url.startsWith('https://');
+};
+export default isUrl;

package/lib/isValidUri.js

@@ -0,0 +1,18 @@
+var VALID_PROTOCOLS = ['http', 'https', 'ftp'];
+var isValidUri = function isValidUri() {
+  var uri = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  if (typeof uri !== 'string') {
+    return false;
+  }
+
+  // to prevent javascript: for some security reasons
+  if (uri.trim().toLowerCase().startsWith('javascript:')) {
+    return false;
+  }
+  var isProtocol = VALID_PROTOCOLS.some(function (protocol) {
+    return uri === null || uri === void 0 ? void 0 : uri.startsWith(protocol);
+  });
+  var uriRex = isProtocol ? /^(http|https|ftp):\/\/[^\s.]+\.[^\s]+$/ : /^(www\.[^:/]+\.[^/]+|[^:/]+:[^/]+)$/;
+  return uriRex.test(uri);
+};
+export default isValidUri;

package/lib/isVideo.js

@@ -0,0 +1,8 @@
+import getFileType from './getFileType';
+export default function isVideo() {
+  var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!file) {
+    return false;
+  }
+  return /^video\/(mp4|m4p|m4v|quicktime|3gpp|x-msvideo|webm|x-matroska|x-ms-wmv|x-ms-asf|MP2T|x-flv|ogg)/.test(getFileType(file).toLowerCase());
+}

package/lib/isVideoResourceIntensive.js

@@ -0,0 +1,9 @@
+export var isVideoResourceIntensive = function isVideoResourceIntensive(file) {
+  return file.info.img_w > 720 ||
+  // width greater than 720px
+  file.info.img_h > 720 ||
+  // height greater than 720px
+  file.info.video_duration > 5 * 60 ||
+  // video duration greater than 5 minutes
+  file.size > 100 * 1024 * 1024;
+}; // size greater than 100 MB

package/lib/literalDateFromDateObj.js

@@ -0,0 +1,6 @@
+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 literalDateFromDateObj = function literalDateFromDateObj(date) {
+  var _date$toISOString;
+  return _typeof(date) === 'object' ? (_date$toISOString = date.toISOString()) === null || _date$toISOString === void 0 ? void 0 : _date$toISOString.split('T')[0] : '';
+};
+export default literalDateFromDateObj;

package/lib/logErrorIfDevEnv.js

@@ -0,0 +1,7 @@
+var logErrorIfDevEnv = function logErrorIfDevEnv(error) {
+  var isDev = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (error && (isDev || process.env.NODE_ENV === 'development')) {
+    console.error("[Development env. error]: ".concat(error.stack || error.message || (error === null || error === void 0 ? void 0 : error.toString()) || error));
+  }
+};
+export default logErrorIfDevEnv;

package/lib/lowercaseFirstLetter.js

@@ -0,0 +1,4 @@
+export default (function () {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return value.charAt(0).toLowerCase() + value.slice(1);
+});

package/lib/mapArrayByStep.js

@@ -0,0 +1,12 @@
+var mapArrayByStep = function mapArrayByStep() {
+  var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var callback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
+  var mapped = [];
+  for (var i = startIndex; i < array.length; i += step) {
+    mapped.push(callback(array[i]));
+  }
+  return mapped;
+};
+export default mapArrayByStep;

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;