@atlaspack/runtime-js 2.12.1-canary.3603 → 2.12.1-canary.3605

package/lib/helpers/browser/esm-js-loader-retry.js

@@ -9,42 +9,92 @@ function load() {
 }
 function _load() {
   _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(id) {
-    var url;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
+    var url, maxRetries, _loop, _ret, i;
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          if (!parcelRequire.retryState) {
-            parcelRequire.retryState = {};
-          }
-          if (globalThis.navigator.onLine) {
-            _context.next = 4;
-            break;
-          }
-          _context.next = 4;
-          return new Promise(function (res) {
-            return globalThis.addEventListener('online', res, {
-              once: true
-            });
+          url = require('../bundle-manifest').resolve(id);
+          maxRetries = 6;
+          _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+            var requestUrl, jitter, delay;
+            return _regeneratorRuntime().wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  if (globalThis.navigator.onLine) {
+                    _context.next = 3;
+                    break;
+                  }
+                  _context.next = 3;
+                  return new Promise(function (resolve) {
+                    return globalThis.addEventListener('online', resolve, {
+                      once: true
+                    });
+                  });
+                case 3:
+                  requestUrl = url;
+                  if (i !== 0) {
+                    // Date ensures the client hasn't previously cached a failed request
+                    requestUrl = "".concat(requestUrl, "?retry=").concat(i, ":").concat(Date.now());
+                  }
+                  _context.prev = 5;
+                  _context.next = 8;
+                  return __parcel__import__(requestUrl);
+                case 8:
+                  _context.t0 = _context.sent;
+                  return _context.abrupt("return", {
+                    v: _context.t0
+                  });
+                case 12:
+                  _context.prev = 12;
+                  _context.t1 = _context["catch"](5);
+                  if (!(i === maxRetries)) {
+                    _context.next = 16;
+                    break;
+                  }
+                  throw _context.t1;
+                case 16:
+                  // Dispatch event for reporting
+                  window.dispatchEvent(new CustomEvent('atlaspack:import_retry', {
+                    detail: {
+                      target: url,
+                      attempt: i
+                    }
+                  }));
+                  jitter = Math.round(Math.random() * 100);
+                  delay = Math.min(Math.pow(2, i), 8) * 1000;
+                  _context.next = 21;
+                  return new Promise(function (resolve) {
+                    return setTimeout(resolve, delay + jitter);
+                  });
+                case 21:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop, null, [[5, 12]]);
           });
+          i = 1;
         case 4:
-          url = require('../bundle-manifest').resolve(id);
-          if (parcelRequire.retryState[id] != undefined) {
-            url = "".concat(url, "?retry=").concat(parcelRequire.retryState[id]);
+          if (!(i <= maxRetries)) {
+            _context2.next = 12;
+            break;
+          }
+          return _context2.delegateYield(_loop(), "t0", 6);
+        case 6:
+          _ret = _context2.t0;
+          if (!_ret) {
+            _context2.next = 9;
+            break;
           }
-          _context.prev = 6;
-          _context.next = 9;
-          return __parcel__import__(url);
+          return _context2.abrupt("return", _ret.v);
         case 9:
-          return _context.abrupt("return", _context.sent);
+          i++;
+          _context2.next = 4;
+          break;
         case 12:
-          _context.prev = 12;
-          _context.t0 = _context["catch"](6);
-          parcelRequire.retryState[id] = Date.now();
-        case 15:
         case "end":
-          return _context.stop();
+          return _context2.stop();
       }
-    }, _callee, null, [[6, 12]]);
+    }, _callee);
   }));
   return _load.apply(this, arguments);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/runtime-js",
-  "version": "2.12.1-canary.3603+7e9e0e6a8",
+  "version": "2.12.1-canary.3605+c3c25718d",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -12,16 +12,16 @@
   "main": "lib/JSRuntime.js",
   "source": "src/JSRuntime.js",
   "engines": {
-    "atlaspack": "2.12.1-canary.3603+7e9e0e6a8",
+    "atlaspack": "2.12.1-canary.3605+c3c25718d",
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.12.1-canary.3603+7e9e0e6a8",
-    "@atlaspack/domain-sharding": "2.12.1-canary.3603+7e9e0e6a8",
-    "@atlaspack/feature-flags": "2.12.1-canary.3603+7e9e0e6a8",
-    "@atlaspack/plugin": "2.12.1-canary.3603+7e9e0e6a8",
-    "@atlaspack/utils": "2.12.1-canary.3603+7e9e0e6a8",
+    "@atlaspack/diagnostic": "2.12.1-canary.3605+c3c25718d",
+    "@atlaspack/domain-sharding": "2.12.1-canary.3605+c3c25718d",
+    "@atlaspack/feature-flags": "2.12.1-canary.3605+c3c25718d",
+    "@atlaspack/plugin": "2.12.1-canary.3605+c3c25718d",
+    "@atlaspack/utils": "2.12.1-canary.3605+c3c25718d",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "7e9e0e6a8614f7f5da8d7fa7da471395f65bd81a"
+  "gitHead": "c3c25718d9e8e63323d574e2ad26367251b1d46b"
 }

package/src/helpers/browser/esm-js-loader-retry.js

@@ -1,25 +1,41 @@
 async function load(id) {
-  if (!parcelRequire.retryState) {
-    parcelRequire.retryState = {};
-  }
+  const url = require('../bundle-manifest').resolve(id);
 
-  if (!globalThis.navigator.onLine) {
-    await new Promise((res) =>
-      globalThis.addEventListener('online', res, {once: true}),
-    );
-  }
+  const maxRetries = 6;
 
-  let url = require('../bundle-manifest').resolve(id);
+  for (let i = 1; i <= maxRetries; i++) {
+    // Wait for the user to go online before making a request
+    if (!globalThis.navigator.onLine) {
+      await new Promise((resolve) =>
+        globalThis.addEventListener('online', resolve, {once: true}),
+      );
+    }
 
-  if (parcelRequire.retryState[id] != undefined) {
-    url = `${url}?retry=${parcelRequire.retryState[id]}`;
-  }
+    let requestUrl = url;
+    if (i !== 0) {
+      // Date ensures the client hasn't previously cached a failed request
+      requestUrl = `${requestUrl}?retry=${i}:${Date.now()}`;
+    }
+
+    try {
+      // eslint-disable-next-line no-undef
+      return await __parcel__import__(requestUrl);
+    } catch (error) {
+      if (i === maxRetries) throw error;
+      // Dispatch event for reporting
+      window.dispatchEvent(
+        new CustomEvent('atlaspack:import_retry', {
+          detail: {
+            target: url,
+            attempt: i,
+          },
+        }),
+      );
+      const jitter = Math.round(Math.random() * 100);
+      const delay = Math.min(Math.pow(2, i), 8) * 1000;
 
-  try {
-    // eslint-disable-next-line no-undef
-    return await __parcel__import__(url);
-  } catch (error) {
-    parcelRequire.retryState[id] = Date.now();
+      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+    }
   }
 }