@lowentry/utils 1.13.5 → 1.14.1

package/index.js

@@ -1427,7 +1427,7 @@ var LeUtils = {
    * Allows you to do a fetch, with built-in retry and abort functionality.
    *
    * @param {string} url
-   * @param {Object} [options]
+   * @param {{[retries]:number|null, [delay]:number|((attempt:number)=>number)|null}|null} [options]
    * @returns {{then:Function, catch:Function, finally:Function, remove:Function, isRemoved:Function}}
    */
   fetch: function (_fetch) {
@@ -1554,6 +1554,120 @@ var LeUtils = {
     };
     return result;
   }),
+  /**
+   * Allows you to do a fetch, with built-in retry functionality. Caches on the requested URL, so that the same URL will not be fetched multiple times.
+   *
+   * @param {string} url
+   * @param {{[retries]:number|null, [delay]:number|((attempt:number)=>number)|null, [verify]:((data:*, response:*)=>void)|null}|null} [options]
+   * @param {((response:*) => *)|null} [responseFunction] A function that will be called with the response object, and should return the data to be cached.
+   * @returns {Promise<*>}
+   */
+  cachedFetch: function () {
+    var cache = new Map();
+    return /*#__PURE__*/function () {
+      var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10(url, options, responseFunction) {
+        var result, promise;
+        return _regeneratorRuntime.wrap(function _callee10$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              if (!cache.has(url)) {
+                _context11.next = 12;
+                break;
+              }
+              result = cache.get(url);
+              if (!result.data) {
+                _context11.next = 4;
+                break;
+              }
+              return _context11.abrupt("return", result.data);
+            case 4:
+              if (!result.promise) {
+                _context11.next = 8;
+                break;
+              }
+              _context11.next = 7;
+              return result.promise;
+            case 7:
+              return _context11.abrupt("return", _context11.sent);
+            case 8:
+              if (!result.error) {
+                _context11.next = 10;
+                break;
+              }
+              throw result.error;
+            case 10:
+              console.warn('Failed to use the cachedFetch cache, for URL: ', url, ', it is in an unexpected state: ', result);
+              return _context11.abrupt("return", null);
+            case 12:
+              promise = LeUtils.fetch(url, options).then(/*#__PURE__*/function () {
+                var _ref9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9(response) {
+                  var data;
+                  return _regeneratorRuntime.wrap(function _callee9$(_context10) {
+                    while (1) switch (_context10.prev = _context10.next) {
+                      case 0:
+                        if (!responseFunction) {
+                          _context10.next = 6;
+                          break;
+                        }
+                        _context10.next = 3;
+                        return responseFunction(response);
+                      case 3:
+                        _context10.t0 = _context10.sent;
+                        _context10.next = 7;
+                        break;
+                      case 6:
+                        _context10.t0 = response;
+                      case 7:
+                        data = _context10.t0;
+                        if (!(typeof (options === null || options === void 0 ? void 0 : options.verify) === 'function')) {
+                          _context10.next = 11;
+                          break;
+                        }
+                        _context10.next = 11;
+                        return options.verify(data, response);
+                      case 11:
+                        return _context10.abrupt("return", data);
+                      case 12:
+                      case "end":
+                        return _context10.stop();
+                    }
+                  }, _callee9);
+                }));
+                return function (_x14) {
+                  return _ref9.apply(this, arguments);
+                };
+              }()).then(function (data) {
+                cache.set(url, {
+                  data: data
+                });
+                return data;
+              })["catch"](function (error) {
+                cache.set(url, {
+                  error: error
+                });
+                console.error('Failed to fetch: ', error);
+                throw error;
+              });
+              if (!cache.has(url)) {
+                cache.set(url, {
+                  promise: promise
+                });
+              }
+              _context11.next = 16;
+              return promise;
+            case 16:
+              return _context11.abrupt("return", _context11.sent);
+            case 17:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee10);
+      }));
+      return function (_x11, _x12, _x13) {
+        return _ref8.apply(this, arguments);
+      };
+    }();
+  }(),
   /**
    * Returns true if the user is on a smartphone device (mobile).
    * Will return false if the user is on a tablet or on a desktop.
@@ -1826,7 +1940,7 @@ var LeUtils = {
    */
   uniqueId: function () {
     var previousUniqueIdsTime = null;
-    var previousUniqueIds = {};
+    var previousUniqueIds = new Map();
     var numberToBytes = function numberToBytes(number) {
       var size = number === 0 ? 0 : Math.ceil((Math.floor(Math.log2(number)) + 1) / 8);
       var bytes = new Uint8ClampedArray(size);
@@ -1886,10 +2000,11 @@ var LeUtils = {
         var result = generateUniqueId();
         if (previousUniqueIdsTime !== result.time) {
           previousUniqueIdsTime = result.time;
-          previousUniqueIds = _defineProperty({}, result.id, true);
+          previousUniqueIds.clear();
+          previousUniqueIds.set(result.id, true);
           return result.id;
-        } else if (previousUniqueIds[result.id] !== true) {
-          previousUniqueIds[result.id] = true;
+        } else if (previousUniqueIds.get(result.id) !== true) {
+          previousUniqueIds.set(result.id, true);
           return result.id;
         }
       }
@@ -2315,7 +2430,7 @@ var LeUtils = {
    * @returns {string}
    */
   btoa: function (_btoa) {
-    function btoa(_x11) {
+    function btoa(_x15) {
       return _btoa.apply(this, arguments);
     }
     btoa.toString = function () {
@@ -2335,7 +2450,7 @@ var LeUtils = {
    * @returns {string}
    */
   atob: function (_atob) {
-    function atob(_x12) {
+    function atob(_x16) {
       return _atob.apply(this, arguments);
     }
     atob.toString = function () {
@@ -2929,12 +3044,12 @@ var LeUtils = {
       };
     }
     var worker = new Worker('/workers/' + name + '.worker.js');
-    var listeners = {};
+    var listeners = new Map();
     var addListener = function addListener(id, callback) {
-      listeners[id] = callback;
+      listeners.set(id, callback);
     };
     var removeListener = function removeListener(id) {
-      delete listeners[id];
+      listeners["delete"](id);
     };
     var sendMessage = function sendMessage(data, options) {
       return new Promise(function (resolve, reject) {
@@ -2956,7 +3071,7 @@ var LeUtils = {
     worker.onmessage = function (message) {
       var data = message.data;
       if (data !== null && data !== void 0 && data.id) {
-        var callback = listeners[data.id];
+        var callback = listeners.get(data.id);
         if (callback) {
           removeListener(data.id);
           callback(data);
@@ -2979,12 +3094,12 @@ var LeUtils = {
    * @returns {Promise<Object>}
    */
   sendWorkerMessage: function () {
-    var workers = {};
+    var workers = new Map();
     return function (workerName, data, options) {
-      if (!workers[workerName]) {
-        workers[workerName] = LeUtils.createWorkerThread(workerName);
+      if (!workers.has(workerName)) {
+        workers.set(workerName, LeUtils.createWorkerThread(workerName));
       }
-      return workers[workerName].sendMessage(data, options);
+      return workers.get(workerName).sendMessage(data, options);
     };
   }(),
   /**