@scaleflex/widget-utils 4.4.0 → 4.5.1

package/lib/RateLimitedQueue.js

@@ -0,0 +1,197 @@
+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 _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 _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); }
+/**
+ * Array.prototype.findIndex ponyfill for old browsers.
+ */
+function findIndex(array, predicate) {
+  for (var i = 0; i < array.length; i++) {
+    if (predicate(array[i])) return i;
+  }
+  return -1;
+}
+function createCancelError() {
+  return new Error('Cancelled');
+}
+var RateLimitedQueue = /*#__PURE__*/function () {
+  function RateLimitedQueue(limit) {
+    _classCallCheck(this, RateLimitedQueue);
+    if (typeof limit !== 'number' || limit === 0) {
+      this.limit = Infinity;
+    } else {
+      this.limit = limit;
+    }
+    this.activeRequests = 0;
+    // eslint-disable-next-line no-unused-expressions
+    this.pauseTimer;
+    this.queuedHandlers = [];
+    this.paused = false;
+  }
+  return _createClass(RateLimitedQueue, [{
+    key: "_call",
+    value: function _call(fn) {
+      var _this = this;
+      this.activeRequests += 1;
+      var _done = false;
+      var cancelActive;
+      try {
+        cancelActive = fn();
+      } catch (err) {
+        this.activeRequests -= 1;
+        throw err;
+      }
+      return {
+        abort: function abort() {
+          if (_done) return;
+          _done = true;
+          _this.activeRequests -= 1;
+          cancelActive();
+          _this._queueNext();
+        },
+        done: function done() {
+          if (_done) return;
+          _done = true;
+          _this.activeRequests -= 1;
+          _this._queueNext();
+        }
+      };
+    }
+  }, {
+    key: "_queueNext",
+    value: function _queueNext() {
+      var _this2 = this;
+      // Do it soon but not immediately, this allows clearing out the entire queue synchronously
+      // one by one without continuously _advancing_ it (and starting new tasks before immediately
+      // aborting them)
+      Promise.resolve().then(function () {
+        _this2._next();
+      });
+    }
+  }, {
+    key: "_next",
+    value: function _next() {
+      if (this.paused || this.activeRequests >= this.limit) {
+        return;
+      }
+      if (this.queuedHandlers.length === 0) {
+        return;
+      }
+
+      // Dispatch the next request, and update the abort/done handlers
+      // so that cancelling it does the Right Thing (and doesn't just try
+      // to dequeue an already-running request).
+      var next = this.queuedHandlers.shift();
+      var handler = this._call(next.fn);
+      next.abort = handler.abort;
+      next.done = handler.done;
+    }
+  }, {
+    key: "_queue",
+    value: function _queue(fn) {
+      var _this3 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var handler = {
+        fn: fn,
+        priority: options.priority || 0,
+        abort: function abort() {
+          _this3._dequeue(handler);
+        },
+        done: function done() {
+          throw new Error('Cannot mark a queued request as done: this indicates a bug');
+        }
+      };
+      var index = findIndex(this.queuedHandlers, function (other) {
+        return handler.priority > other.priority;
+      });
+      if (index === -1) {
+        this.queuedHandlers.push(handler);
+      } else {
+        this.queuedHandlers.splice(index, 0, handler);
+      }
+      return handler;
+    }
+  }, {
+    key: "_dequeue",
+    value: function _dequeue(handler) {
+      var index = this.queuedHandlers.indexOf(handler);
+      if (index !== -1) {
+        this.queuedHandlers.splice(index, 1);
+      }
+    }
+  }, {
+    key: "run",
+    value: function run(fn, queueOptions) {
+      if (!this.paused && this.activeRequests < this.limit) {
+        return this._call(fn);
+      }
+      return this._queue(fn, queueOptions);
+    }
+  }, {
+    key: "wrapPromiseFunction",
+    value: function wrapPromiseFunction(fn, queueOptions) {
+      var _this4 = this;
+      return function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var queuedRequest;
+        var outerPromise = new Promise(function (resolve, reject) {
+          queuedRequest = _this4.run(function () {
+            var cancelError;
+            var innerPromise;
+            try {
+              innerPromise = Promise.resolve(fn.apply(void 0, args));
+            } catch (err) {
+              innerPromise = Promise.reject(err);
+            }
+            innerPromise.then(function (result) {
+              if (cancelError) {
+                reject(cancelError);
+              } else {
+                queuedRequest.done();
+                resolve(result);
+              }
+            }, function (err) {
+              if (cancelError) {
+                reject(cancelError);
+              } else {
+                queuedRequest.done();
+                reject(err);
+              }
+            });
+            return function () {
+              cancelError = createCancelError();
+            };
+          }, queueOptions);
+        });
+        outerPromise.abort = function () {
+          queuedRequest.abort();
+        };
+        return outerPromise;
+      };
+    }
+  }, {
+    key: "resume",
+    value: function resume() {
+      this.paused = false;
+      clearTimeout(this.pauseTimer);
+      for (var i = 0; i < this.limit; i++) {
+        this._queueNext();
+      }
+    }
+  }, {
+    key: "pause",
+    value: function pause() {
+      var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      this.paused = true;
+      clearTimeout(this.pauseTimer);
+      if (duration != null) {
+        this.pauseTimer = setTimeout(this.resume, duration);
+      }
+    }
+  }]);
+}();
+export { RateLimitedQueue as default };

package/lib/RequestError.js

@@ -0,0 +1,36 @@
+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 _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 _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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _wrapNativeSuper(t) { var r = "function" == typeof Map ? new Map() : void 0; return _wrapNativeSuper = function _wrapNativeSuper(t) { if (null === t || !_isNativeFunction(t)) return t; if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== r) { if (r.has(t)) return r.get(t); r.set(t, Wrapper); } function Wrapper() { return _construct(t, arguments, _getPrototypeOf(this).constructor); } return Wrapper.prototype = Object.create(t.prototype, { constructor: { value: Wrapper, enumerable: !1, writable: !0, configurable: !0 } }), _setPrototypeOf(Wrapper, t); }, _wrapNativeSuper(t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).indexOf("[native code]"); } catch (n) { return "function" == typeof t; } }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+var RequestError = /*#__PURE__*/function (_Error) {
+  function RequestError(_ref) {
+    var _this;
+    var code = _ref.code,
+      codeLabel = _ref.codeLabel,
+      message = _ref.message,
+      details = _ref.details;
+    _classCallCheck(this, RequestError);
+    _this = _callSuper(this, RequestError, [message]);
+    _this.name = "Request Error (".concat(code, ")");
+    _this.code = code;
+    _this.message = message;
+    _this.details = details;
+    _this.codeLabel = codeLabel;
+    return _this;
+  }
+  _inherits(RequestError, _Error);
+  return _createClass(RequestError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+export default RequestError;

package/lib/Timeframes/getDateRange.js

@@ -0,0 +1,45 @@
+var getDateRange = function getDateRange(dateRange) {
+  var formatDate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (newDate) {
+    return newDate;
+  };
+  var isFuture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var min = 60 * 1000;
+  var hour = 60 * min;
+  var day = 24 * hour;
+  var date = '';
+  var getDateFormat = function getDateFormat(timeFrame) {
+    return formatDate(new Date(isFuture ? Date.now() + timeFrame * day : Date.now() - timeFrame * day));
+  };
+  switch (Math.abs(dateRange)) {
+    case 0:
+      // Today
+      date = getDateFormat(0);
+      break;
+    case 1:
+      // Past/next 24 hours (1 day)
+      date = getDateFormat(1);
+      break;
+    case 2:
+      // Past/next 7 days (1 week)
+      date = getDateFormat(7);
+      break;
+    case 3:
+      // Past/next 30 days (1 month)
+      date = getDateFormat(30);
+      break;
+    case 4:
+      // Past/next 90 days (3 months)
+      date = getDateFormat(90);
+      break;
+    case 5:
+      // Past/next 180 days (6 months)
+      date = getDateFormat(180);
+      break;
+    case 6:
+      // past/next 365 days (1 year)
+      date = getDateFormat(365);
+      break;
+  }
+  return date;
+};
+export default getDateRange;

package/lib/TranslationMissingKeysConsoleHelper.js

@@ -0,0 +1,113 @@
+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 _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 { I18N_GRID_UUID, I18N_PROD_BASE_URL } from '@scaleflex/widget-utils/lib/constants';
+
+/**
+ * Class to console log all missing translation keys and generate curl for convenience.
+ *
+ * How to use?
+ *  - Create instance for your project:
+ *    const missingKeysConsoleHelper = new TranslationMissingKeysConsoleHelper({ name, gridUuid, ... })
+ *    > Notice! Each project should have only one instance of the class (e.g one instance for Hub and one more for Widget)
+ *  - Run method handleMissingKey each time when missing key detected:
+ *    missingKeysConsoleHelper.handleMissingKey(key, valueOrDefault)
+ *  - Enable console helper by adding localStorage prop "translationMissingKeysConsoleHelperEnabled"=true OR by enabled config
+ * As the result you should see all missing keys in browser console with generated cURL for convenience.
+ *
+ * IMPORTANT! For any updates in the class need to sync and double check Hub project as well!
+ */
+var TranslationMissingKeysConsoleHelper = /*#__PURE__*/function () {
+  function TranslationMissingKeysConsoleHelper() {
+    var _this = this;
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      name = _ref.name,
+      baseApiUrl = _ref.baseApiUrl,
+      gridUuid = _ref.gridUuid,
+      debounceDelay = _ref.debounceDelay,
+      _ref$consoleGroupColl = _ref.consoleGroupCollapsed,
+      consoleGroupCollapsed = _ref$consoleGroupColl === void 0 ? false : _ref$consoleGroupColl,
+      _ref$enabled = _ref.enabled,
+      enabled = _ref$enabled === void 0 ? localStorage.getItem('translationMissingKeysConsoleHelperEnabled') === 'true' : _ref$enabled;
+    _classCallCheck(this, TranslationMissingKeysConsoleHelper);
+    _defineProperty(this, "name", 'WIDGET');
+    // Name is used in logs titles. Useful when class is used for multiple projects (e.g. Hub and Widget)
+    _defineProperty(this, "baseApiUrl", I18N_PROD_BASE_URL);
+    _defineProperty(this, "gridUuid", I18N_GRID_UUID);
+    _defineProperty(this, "debounceDelay", 2000);
+    // Delay to not console log too often
+    _defineProperty(this, "consoleGroupCollapsed", false);
+    _defineProperty(this, "enabled", false);
+    _defineProperty(this, "_missingKeys", {});
+    _defineProperty(this, "_timer", null);
+    if (name) {
+      this.name = name;
+    }
+    if (baseApiUrl) {
+      this.baseApiUrl = baseApiUrl;
+    }
+    if (gridUuid) {
+      this.gridUuid = gridUuid;
+    }
+    if (debounceDelay) {
+      this.debounceDelay = debounceDelay;
+    }
+    if (enabled === true) {
+      this.enabled = true;
+      console.log("%cTranslationMissingKeysConsoleHelper enabled for ".concat(this.name), 'font-weight:600;');
+    }
+    this.consoleGroupCollapsed = consoleGroupCollapsed;
+    this.renderCurl = this.renderCurl.bind(this);
+    this._missingKeys = new Proxy(this._missingKeys, {
+      set: function set(target, propName, value, receiver) {
+        if (_this._timer) {
+          clearTimeout(_this._timer);
+        }
+        _this._timer = setTimeout(_this.renderCurl, _this.debounceDelay);
+        return Reflect.set(target, propName, value, receiver);
+      }
+    });
+  }
+  return _createClass(TranslationMissingKeysConsoleHelper, [{
+    key: "renderCurl",
+    value: function renderCurl() {
+      console[this.consoleGroupCollapsed ? 'groupCollapsed' : 'group']("[".concat(this.name, "] Translations missing keys group"));
+      console.log("%c[".concat(this.name, "] Missing keys"), 'font-weight:600;font-size:200%;');
+      console.table(_objectSpread({}, this._missingKeys));
+      console.log('%ccURL (check carefully data before send):', 'font-weight:600;font-size:150%;');
+      console.log("\ncurl '".concat(this.baseApiUrl, "/api/import/request-translations?grid_uuid=").concat(this.gridUuid, "' \\\n  --data-raw '{\"grid_uuid\":\"").concat(this.gridUuid, "\",\"translations_requests\":").concat(JSON.stringify(Object.entries(this._missingKeys).map(function (_ref2) {
+        var _ref3 = _slicedToArray(_ref2, 2),
+          key = _ref3[0],
+          value = _ref3[1];
+        return {
+          key: key,
+          lang: 'en',
+          "default": value
+        };
+      })).replaceAll("'", "'\\''"), "}'\n    "));
+      console.groupEnd();
+    }
+  }, {
+    key: "handleMissingKey",
+    value: function handleMissingKey(key) {
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      if (!this.enabled) {
+        return;
+      }
+      this._missingKeys[key] = value;
+    }
+  }]);
+}();
+export { TranslationMissingKeysConsoleHelper as default };

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

@@ -0,0 +1,27 @@
+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; }
+/**
+ * Check if the passed url has query params already or not and based on this add ?newProp=value or &newProp=value
+ * to the url.
+ * @param {string} url - any valid URL
+ * @param {object | string} newParams - new parameters to be added to the url as query param { newParam: value, newParam2: value2 } or 'newProp=value&newProp2=value2...'
+ * @returns {string} - url with newProp added to it
+ */
+export default (function () {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var newParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  if (url) {
+    var params = typeof newParams === 'string' ? newParams : Object.entries(newParams).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      return "".concat(key, "=").concat(value);
+    }).join('&');
+    return "".concat(url).concat(url.includes('?') ? '&' : '?').concat(params);
+  }
+  return '';
+});

package/lib/adjustUpdatedFolders.js

@@ -0,0 +1,22 @@
+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); }
+/**
+ * Adjust updated folders as currently BE API returns string instead of object for visibility field
+ * To fix that problem, visibilities object is merged to visibility
+ * BE task to fix it https://scaleflexhq.atlassian.net/browse/FRA-2010, after it's fixed, this function will not be
+ * needed anymore
+ * @param {Array} folders - array of folders
+ * @returns {Array} - updated array of folders
+ */
+export default (function (folders) {
+  return folders.map(function (folder) {
+    if (typeof folder.visibility === 'string') {
+      folder.visibility = _objectSpread({}, folder.visibilities);
+    }
+    return folder;
+  });
+});

package/lib/asyncTimeout.js

@@ -0,0 +1,6 @@
+var asyncTimeout = function asyncTimeout(ms) {
+  return new Promise(function (resolve) {
+    setTimeout(resolve, ms);
+  });
+};
+export default asyncTimeout;