@scaleflex/widget-utils 4.8.6 → 4.8.11

package/lib/Translator.js

@@ -0,0 +1,200 @@
+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 _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 _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), 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 has from './hasProperty';
+// import { sendMissingTranslationToBackend } from './i18n.client'
+import TranslationMissingKeysConsoleHelper from './TranslationMissingKeysConsoleHelper';
+
+/**
+ * Translates strings with interpolation & pluralization support.
+ * Extensible with custom dictionaries and pluralization functions.
+ *
+ * Borrows heavily from and inspired by Polyglot https://github.com/airbnb/polyglot.js,
+ * basically a stripped-down version of it. Differences: pluralization functions are not hardcoded
+ * and can be easily added among with dictionaries, nested objects are used for pluralization
+ * as opposed to `||||` delimeter
+ *
+ * Usage example: `translator.translate('files_chosen', {smart_count: 3})`
+ */
+
+var sentKeys = {};
+var missingKeysConsoleHelper = new TranslationMissingKeysConsoleHelper();
+var Translator = /*#__PURE__*/function () {
+  /**
+   * @param {object|Array<object>} locales - locale or list of locales.
+   */
+  function Translator(locales) {
+    var _this = this;
+    _classCallCheck(this, Translator);
+    this.locale = {
+      strings: {},
+      pluralize: function pluralize(n) {
+        if (n === 1) {
+          return 0;
+        }
+        return 1;
+      }
+    };
+    if (Array.isArray(locales)) {
+      locales.forEach(function (locale) {
+        return _this._apply(locale);
+      });
+    } else {
+      this._apply(locales);
+    }
+  }
+  return _createClass(Translator, [{
+    key: "_apply",
+    value: function _apply(locale) {
+      if (!locale || !locale.strings) {
+        return;
+      }
+      var prevLocale = this.locale;
+      var keysHaveTranslations = Object.keys(locale.strings).filter(function (k) {
+        return locale.strings[k];
+      });
+      var preparedLocaleStrings = {};
+      keysHaveTranslations.forEach(function (k) {
+        preparedLocaleStrings[k] = locale.strings[k];
+      });
+      this.locale = _extends({}, prevLocale, {
+        strings: _extends({}, prevLocale.strings, preparedLocaleStrings)
+      });
+      this.locale.pluralize = locale.pluralize || prevLocale.pluralize;
+    }
+
+    /**
+     * Takes a string with placeholder variables like `%{smart_count} file selected`
+     * and replaces it with values from options `{smart_count: 5}`
+     *
+     * @license https://github.com/airbnb/polyglot.js/blob/master/LICENSE
+     * taken from https://github.com/airbnb/polyglot.js/blob/master/lib/polyglot.js#L299
+     *
+     * @param {string} phrase that needs interpolation, with placeholders
+     * @param {object} options with values that will be used to replace placeholders
+     * @returns {string} interpolated
+     */
+  }, {
+    key: "interpolate",
+    value: function interpolate(phrase, options) {
+      var split = String.prototype.split;
+      var interpolated = [phrase];
+      for (var arg in options) {
+        if (arg !== '_' && has(options, arg)) {
+          var replacement = options[arg];
+          // We create a new `RegExp` each time instead of using a more-efficient
+          // string replace so that the same argument can be replaced multiple times
+          // in the same phrase.
+          interpolated = insertReplacement(interpolated, new RegExp('%\\{' + arg + '\\}', 'g'), replacement);
+        }
+      }
+      return interpolated;
+      function insertReplacement(source, rx, replacement) {
+        var newParts = [];
+        source.forEach(function (chunk) {
+          // When the source contains multiple placeholders for interpolation,
+          // we should ignore chunks that are not strings, because those
+          // can be JSX objects and will be otherwise incorrectly turned into strings.
+          // Without this condition we’d get this: [object Object] hello [object Object] my <button>
+          if (typeof chunk !== 'string') {
+            return newParts.push(chunk);
+          }
+          split.call(chunk, rx).forEach(function (raw, i, list) {
+            if (raw !== '') {
+              newParts.push(raw);
+            }
+
+            // Interlace with the `replacement` value
+            if (i < list.length - 1) {
+              newParts.push(replacement);
+            }
+          });
+        });
+        return newParts;
+      }
+    }
+
+    /**
+     * Public translate method
+     *
+     * @param {string} key
+     * @param {object} options with values that will be used later to replace placeholders in string
+     * @returns {string} translated (and interpolated)
+     */
+  }, {
+    key: "translate",
+    value: function translate(key, options) {
+      var _this$translateArray;
+      return (_this$translateArray = this.translateArray(key, options)) === null || _this$translateArray === void 0 ? void 0 : _this$translateArray.join('');
+    }
+
+    /**
+     * Get a translation and return the translated and interpolated parts as an array.
+     *
+     * @param {string} key
+     * @param {object} options with values that will be used to replace placeholders or default string value if key doesn't have value
+     *                        - string => used as default value
+     *                        - object => uses the `default` property as the translation default value and others for placeholder.
+     * @returns {Array} The translated and interpolated parts, in order.
+     */
+  }, {
+    key: "translateArray",
+    value: function translateArray(key, options) {
+      if (!Translator.BACKEND_TRANSLATIONS) {
+        return [];
+      }
+      // JSON.parse() for handling the plural case that's being received from backend as string.
+      try {
+        var _this$locale$strings$, _this$locale$strings$2, _options$default;
+        var value = (_this$locale$strings$ = this.locale.strings[key]) !== null && _this$locale$strings$ !== void 0 && (_this$locale$strings$2 = _this$locale$strings$.startsWith) !== null && _this$locale$strings$2 !== void 0 && _this$locale$strings$2.call(_this$locale$strings$, '{"') ? JSON.parse(this.locale.strings[key]) : this.locale.strings[key];
+        var valueOrDefault = !value && typeof options === 'string' ? options : (_options$default = options === null || options === void 0 ? void 0 : options["default"]) !== null && _options$default !== void 0 ? _options$default : value || '';
+        var hasPluralForms = _typeof(value) === 'object';
+
+        // For sending to the backend the missing translation keys
+        if (key && Translator.BACKEND_TRANSLATIONS && !Translator.BACKEND_TRANSLATIONS[key] && !sentKeys[key]) {
+          var valueOrDefaultWithStrPlural = hasPluralForms ? JSON.stringify(valueOrDefault) : valueOrDefault;
+
+          /**
+           * Auto translations disabled. Should be used manual creation instead of that.
+           * As a helper could be used "Missing keys Console Helper" -- https://scaleflexhq.atlassian.net/wiki/spaces/FIL/pages/594444447/Hub+Widget+projects+translations#Missing-keys-Console-Helper
+           */
+          // if (!Translator.IS_DEV) {
+          //   sendMissingTranslationToBackend({
+          //     key,
+          //     fallBackLang: 'en',
+          //     lang: 'en',
+          //     default: valueOrDefaultWithStrPlural
+          //   })
+          // }
+
+          missingKeysConsoleHelper.handleMissingKey(key, valueOrDefaultWithStrPlural);
+          sentKeys[key] = true;
+          Translator.BACKEND_TRANSLATIONS = _objectSpread(_objectSpread({}, Translator.BACKEND_TRANSLATIONS), {}, _defineProperty({}, key, valueOrDefault));
+        }
+        if (hasPluralForms) {
+          if (options && _typeof(options) === 'object' && typeof options.smart_count !== 'undefined') {
+            var plural = this.locale.pluralize(options.smart_count);
+            return this.interpolate(value[plural], options);
+          } else {
+            throw new Error('Attempted to use a string with plural forms, but no value was given for %{smart_count}');
+          }
+        }
+        return this.interpolate(value, options);
+      } catch (err) {}
+    }
+  }]);
+}();
+// For saving the backend translations retrieved from core.
+_defineProperty(Translator, "BACKEND_TRANSLATIONS", null);
+// For saving the current environment of the project, determined from core.
+_defineProperty(Translator, "IS_DEV", true);
+// For knowing the current used language incase some missing key is faced then send to the backend in right lang.
+_defineProperty(Translator, "LANGUAGE", 'en');
+export { Translator as default };

package/lib/getLinkWithNewParams.js

@@ -0,0 +1,13 @@
+export default (function (link, imageParams) {
+  var separator = link !== null && link !== void 0 && link.includes('?') ? '&' : '?';
+  var params = Object.keys(imageParams).filter(function (key) {
+    return imageParams[key] !== 'auto';
+  }).filter(function (key) {
+    return imageParams[key];
+  }).map(function (key) {
+    return "".concat(key, "=").concat(imageParams[key]);
+  }).join('&');
+  return Object.keys(imageParams).some(function (key) {
+    return imageParams[key] && imageParams[key] !== 'auto';
+  }) ? "".concat(link).concat(separator).concat(params) : link;
+});

package/lib/getMetadataMultiSelectQuery.js

@@ -0,0 +1,66 @@
+import { isStaticSelectOption } from '@scaleflex/widget-explorer/lib/utils/filters';
+import { FILTER_CONDITIONS } from './constants';
+import { getFieldValueQuery } from './fieldsQueriesGetters';
+var createStaticValueIsQuery = function createStaticValueIsQuery(key, value) {
+  return "".concat(key, ":").concat(value.join(','));
+};
+var createIsQuery = function createIsQuery(key, value) {
+  if (isStaticSelectOption(value)) {
+    return createStaticValueIsQuery(key, value);
+  }
+  return "".concat(key, ":=").concat(value.join(','));
+};
+var createIsNotQuery = function createIsNotQuery(key, value) {
+  return value.map(function (item) {
+    return "".concat(key, ":-").concat(item);
+  }).join(' ');
+};
+var createContainsQuery = function createContainsQuery(metadataFilter, value) {
+  return getFieldValueQuery(metadataFilter, value);
+};
+var createContainsNotQuery = function createContainsNotQuery(_ref) {
+  var metadataFilter = _ref.metadataFilter,
+    key = _ref.key,
+    value = _ref.value,
+    extraValue = _ref.extraValue;
+  var valueQuery = getFieldValueQuery(metadataFilter, value);
+  var extraValueQuery = extraValue.map(function (item) {
+    return "".concat(key, ":-").concat(item);
+  }).join(' ');
+  return "".concat(valueQuery, " ").concat(extraValueQuery).trim();
+};
+
+/**
+ * Generates a multi-select field query based on the metadata filter.
+*  Docs: https://scaleflexhq.atlassian.net/wiki/spaces/FIL/pages/466452497
+ *
+ * @param {Object} metadataFilter - The metadata filter object.
+ * @returns {string} - The resulting query string.
+ */
+
+export var getMetadataMultiSelectQuery = function getMetadataMultiSelectQuery(metadataFilter) {
+  var key = metadataFilter.key,
+    _metadataFilter$value = metadataFilter.value,
+    value = _metadataFilter$value === void 0 ? [] : _metadataFilter$value,
+    _metadataFilter$condi = metadataFilter.condition,
+    condition = _metadataFilter$condi === void 0 ? FILTER_CONDITIONS.IS : _metadataFilter$condi,
+    _metadataFilter$extra = metadataFilter.extraValue,
+    extraValue = _metadataFilter$extra === void 0 ? [] : _metadataFilter$extra;
+  switch (condition) {
+    case FILTER_CONDITIONS.IS:
+      return createIsQuery(key, value);
+    case FILTER_CONDITIONS.IS_NOT:
+      return createIsNotQuery(key, value);
+    case FILTER_CONDITIONS.CONTAINS:
+      return createContainsQuery(metadataFilter, value.join(','));
+    case FILTER_CONDITIONS.CONTAINS_NOT:
+      return createContainsNotQuery({
+        metadataFilter: metadataFilter,
+        key: key,
+        value: value.join(','),
+        extraValue: extraValue
+      });
+    default:
+      return '';
+  }
+};

package/lib/getNonce.js

@@ -0,0 +1,26 @@
+var cachedNonce = null;
+
+/**
+ * Resolves a CSP nonce for dynamically injected <style> and <script> elements.
+ *
+ * Resolution order:
+ *  1. An explicit nonce passed via the widget config (`coreProps.nonce`).
+ *  2. Auto-detected from `<meta property="csp-nonce" content="…">` in the host page.
+ *
+ * The auto-detected value is cached after the first lookup.
+ *
+ * @param {string} [explicitNonce] - Nonce provided explicitly through config.
+ * @returns {string|undefined} The resolved nonce, or undefined when none is available.
+ */
+var getNonce = function getNonce(explicitNonce) {
+  if (explicitNonce) return explicitNonce;
+  if (cachedNonce !== null) return cachedNonce || undefined;
+  if (typeof document !== 'undefined') {
+    var meta = document.querySelector('meta[property="csp-nonce"]');
+    cachedNonce = meta ? meta.getAttribute('content') : '';
+  } else {
+    cachedNonce = '';
+  }
+  return cachedNonce || undefined;
+};
+export default getNonce;

package/lib/getNormalizedItems.js

@@ -0,0 +1,55 @@
+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); }
+/**
+ * Retrieves the value of a nested property from an object using a string key.
+ *
+ * @param {string} key - The string key representing the nested property.
+ * @param {object} item - The object from which to retrieve the nested property.
+ * @return {*} - The value of the nested property.
+ */
+export var getItemKey = function getItemKey(key, item) {
+  if (key.includes('.')) {
+    var properties = key.split('.');
+    return properties.reduce(function (property, prop) {
+      return property[prop];
+    }, item);
+  } else {
+    return item[key];
+  }
+};
+
+/**
+ * Generates a normalized version of the given items array.
+ *
+ * @param {Array} items - The array of items to be normalized.
+ * @param {Object} options - options for the function, consists of the following.
+    * @param {Object} extraProps - (optional) Additional properties to add to each normalized item.
+    * @param {string} key - (optional) The key to use as the unique identifier for each item.
+    * @param {string} returnedKey - (optional) the key used in the function's returned's object.
+ * @return {Object} An object containing the normalized slices and an array of UUIDs.
+ */
+var getNormalizedItems = function getNormalizedItems(items, options) {
+  var _ref = options || {},
+    _ref$extraProps = _ref.extraProps,
+    extraProps = _ref$extraProps === void 0 ? {} : _ref$extraProps,
+    _ref$key = _ref.key,
+    key = _ref$key === void 0 ? 'uuid' : _ref$key,
+    _ref$returnedKey = _ref.returnedKey,
+    returnedKey = _ref$returnedKey === void 0 ? 'uuids' : _ref$returnedKey;
+  var normalizedSlices = {};
+  var normalizedItemsUuids = [];
+  items.forEach(function (item) {
+    var itemKey = getItemKey(key, item);
+    var normalizedItem = _objectSpread(_objectSpread({}, item), extraProps);
+    normalizedSlices[itemKey] = normalizedItem;
+    normalizedItemsUuids.push(itemKey);
+  });
+  return _defineProperty({
+    normalizedSlices: normalizedSlices
+  }, returnedKey, normalizedItemsUuids);
+};
+export default getNormalizedItems;

package/lib/getObjectsMutualProperties.js

@@ -0,0 +1,32 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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; }
+var _getObjectsMutualProperties = function getObjectsMutualProperties() {
+  var arrayOfObjects = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [{}];
+  return Array.isArray(arrayOfObjects) && (arrayOfObjects.length > 1 ? arrayOfObjects.reduce(function (prevObj, currObj) {
+    var commonObj = {};
+    Object.keys(prevObj).forEach(function (key) {
+      if (prevObj[key] && currObj[key]) {
+        if (prevObj[key] === currObj[key]) {
+          commonObj[key] = prevObj[key];
+        } else if (Array.isArray(prevObj[key]) && Array.isArray(currObj[key])) {
+          var mutualProps = _getObjectsMutualProperties([].concat(_toConsumableArray(prevObj[key]), _toConsumableArray(currObj[key])));
+          commonObj[key] = Object.keys(mutualProps).map(function (key) {
+            return _defineProperty({}, key, mutualProps[key]);
+          });
+        } else if (_typeof(prevObj[key]) === 'object' && _typeof(currObj[key]) === 'object') {
+          commonObj[key] = _getObjectsMutualProperties([prevObj[key], currObj[key]]);
+        }
+      }
+    });
+    return commonObj;
+  }) : arrayOfObjects[0] || {});
+};
+export default _getObjectsMutualProperties;

package/lib/getRandomNumber.js

@@ -0,0 +1,12 @@
+/**
+ * @returns {number} -- random number between min and max
+ *
+ * @param {number} min -- minimum number
+ * @param {number} max -- maximum number
+ */
+var getRandomNumber = function getRandomNumber(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min) + min);
+};
+export default getRandomNumber;

package/lib/getSocketHost.js

@@ -0,0 +1,7 @@
+export default function getSocketHost(url) {
+  // get the host domain
+  var regex = /^(?:https?:\/\/|\/\/)?(?:[^@\n]+@)?(?:www\.)?([^\n]+)/i;
+  var host = regex.exec(url)[1];
+  var socketProtocol = /^http:\/\//i.test(url) ? 'ws' : 'wss';
+  return "".concat(socketProtocol, "://").concat(host);
+}

package/lib/getSpeed.js

@@ -0,0 +1,8 @@
+export default function getSpeed() {
+  var fileProgress = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var totalFinished = fileProgress.bytesFinished || fileProgress.percentage;
+  var endTime = new Date().getTime();
+  var timeDuration = (endTime - fileProgress.startedAt) / 1000;
+  var uploadSpeedInBps = totalFinished / timeDuration;
+  return uploadSpeedInBps;
+}

package/lib/getTime.js

@@ -0,0 +1,18 @@
+/**
+ * Returns a timestamp in the format of `hours:minutes Am or PM`
+ */
+
+export default function getTime() {
+  var showAmPm = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var i18n = arguments.length > 1 ? arguments[1] : undefined;
+  var date = new Date();
+  var hours = date.getHours();
+  var minutes = date.getMinutes();
+  var ampm = hours >= 12 ? (i18n === null || i18n === void 0 ? void 0 : i18n('mutualizedTimePeriodPm')) || 'PM' : (i18n === null || i18n === void 0 ? void 0 : i18n('mutualizedTimePeriodAm')) || 'AM';
+  hours = hours % 12;
+  hours = hours || 12; // the hour '0' should be '12'
+  hours = hours < 10 ? '0' + hours : hours;
+  minutes = minutes < 10 ? '0' + minutes : minutes;
+  var strTime = hours + ':' + minutes + (showAmPm ? ' ' + ampm : '');
+  return strTime;
+}

package/lib/getTimeStamp.js

@@ -0,0 +1,18 @@
+/**
+ * Returns a timestamp in the format of `hours:minutes:seconds`
+ */
+export default function getTimeStamp() {
+  var noSeconds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var date = new Date();
+  var hours = pad(date.getHours().toString());
+  var minutes = pad(date.getMinutes().toString());
+  var seconds = pad(date.getSeconds().toString());
+  return hours + ':' + minutes + (noSeconds ? ':' + seconds : '');
+}
+
+/**
+ * Adds zero to strings shorter than two characters
+ */
+function pad(str) {
+  return str.length !== 2 ? 0 + str : str;
+}

package/lib/handleError.js

@@ -0,0 +1,13 @@
+var handleError = function handleError(error, infoFn) {
+  var _ref;
+  if (!error || !infoFn) {
+    return;
+  }
+  var message = error.message,
+    details = error.details;
+  infoFn({
+    message: (_ref = message !== null && message !== void 0 ? message : error.status) !== null && _ref !== void 0 ? _ref : error.toString(),
+    details: details
+  }, 'error', 5000);
+};
+export default handleError;

package/lib/handlePressEnter.js

@@ -0,0 +1,9 @@
+var handlePressEnter = function handlePressEnter() {
+  var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var callback = arguments.length > 1 ? arguments[1] : undefined;
+  if ((event.key === 'Enter' || event.keyCode === 13) && typeof callback === 'function') {
+    event.preventDefault();
+    callback();
+  }
+};
+export default handlePressEnter;

package/lib/handlePromise.js

@@ -0,0 +1,39 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import isPromise from './isPromise';
+
+/**
+ * Wraps the promise passed with try/catch block and fires the callback provided depending on success/failture.
+ *
+ * @param (promise: promise) - promise to be processed
+ * @param (successCallback: function) - callback function to be implemented incase of success
+ * @param (errorCallback: function) - callback function to be implemented incase of error caught
+    - assuming default clbk function would be info(error: error instance, type: error, timeout: 5000)
+ * @param (finishCallback: function) - callback function to be implemented after finishing in both cases success/fail.
+ */
+var handlePromise = function handlePromise(promise) {
+  var successCallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
+    return null;
+  };
+  var errorCallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
+    return null;
+  };
+  var finishCallback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {
+    return null;
+  };
+  if (isPromise(promise)) {
+    // To throw the rejection of the promise to be able to use (.catch)
+    if (typeof promise.throwRejection === 'function') {
+      promise.throwRejection();
+    }
+    var newPromise = promise.then(successCallback)["catch"](function (error) {
+      if (typeof errorCallback === 'function') {
+        errorCallback(error, 'error', 5000);
+      }
+    })["finally"](finishCallback);
+
+    // To copy the properties of the original promise eg. if it's thunk function we will have (abort, requestId...etc.)
+    _extends(newPromise, promise);
+    return newPromise;
+  }
+};
+export default handlePromise;

package/lib/hasProperty.js

@@ -0,0 +1,3 @@
+export default function has(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}

package/lib/hexToRgb.js

@@ -0,0 +1,15 @@
+// Imported from https://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb
+var hexToRgb = function hexToRgb(hex) {
+  // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+  var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+  hex = hex.replace(shorthandRegex, function (m, r, g, b) {
+    return r + r + g + g + b + b;
+  });
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : {};
+};
+export default hexToRgb;

package/lib/htmlSanitizer.js

@@ -0,0 +1,6 @@
+import DOMPurify from 'dompurify';
+var htmlSanitizer = function htmlSanitizer() {
+  var html = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return DOMPurify.sanitize(html);
+};
+export default htmlSanitizer;

package/lib/humanReadableDate.js

@@ -0,0 +1,45 @@
+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); }
+/**
+ * @param {Date} date
+ * @param {object} [translations] - Object with translations. Notice: it's used for Hub.
+ * @returns {string} - For example: "18 hours ago"
+ */
+var humanReadableDate = function humanReadableDate(date, translationsList) {
+  var translations = _objectSpread({
+    ago: 'ago',
+    second: 'second',
+    seconds: 'seconds',
+    minute: 'minute',
+    minutes: 'minutes',
+    hour: 'hour',
+    hours: 'hours',
+    day: 'day',
+    days: 'days',
+    month: 'month',
+    months: 'months',
+    year: 'year',
+    years: 'years'
+  }, translationsList || {});
+  var timeAgo = function timeAgo(interval, periodMultiple, periodSingle) {
+    return "".concat(Math.floor(interval), " ").concat(Math.floor(interval) > 1 ? periodMultiple : periodSingle, " ").concat(translations.ago);
+  };
+  var seconds = Math.floor((new Date() - new Date(date)) / 1000);
+  var interval = seconds / 31536000;
+  if (interval > 1) return timeAgo(interval, translations.years, translations.year);
+  interval = seconds / 2592000;
+  if (interval > 1) return timeAgo(interval, translations.months, translations.month);
+  interval = seconds / 86400;
+  if (interval > 1) return timeAgo(interval, translations.days, translations.day);
+  interval = seconds / 3600;
+  if (interval > 1) return timeAgo(interval, translations.hours, translations.hour);
+  interval = seconds / 60;
+  if (interval > 1) return timeAgo(interval, translations.minutes, translations.minute);
+  interval = seconds;
+  return timeAgo(interval, translations.seconds, translations.second);
+};
+export default humanReadableDate;

package/lib/humanReadableDateWithTranslations.js

@@ -0,0 +1,29 @@
+import capitalizeFirstLetter from './capitalizeFirstLetter';
+import humanReadableDate from './humanReadableDate';
+
+/**
+ * Wrapper over function humanReadableDate but with translations
+ */
+var humanReadableDateWithTranslations = function humanReadableDateWithTranslations(date, i18n) {
+  var t = function t(str) {
+    return i18n("timeAgo".concat(str.split(' ').filter(Boolean).map(function (item) {
+      return capitalizeFirstLetter(item.trim());
+    }).join('')), str) || str;
+  };
+  return humanReadableDate(date, {
+    ago: t('ago'),
+    second: t('second'),
+    seconds: t('seconds'),
+    minute: t('minute'),
+    minutes: t('minutes'),
+    hour: t('hour'),
+    hours: t('hours'),
+    day: t('day'),
+    days: t('days'),
+    month: t('month'),
+    months: t('months'),
+    year: t('year'),
+    years: t('years')
+  });
+};
+export default humanReadableDateWithTranslations;