@atlaspack/runtime-js 2.12.1-canary.3354

package/src/helpers/.babelrc

@@ -0,0 +1,9 @@
+{
+  "presets": [
+    ["@babel/preset-env", {
+      "targets": {
+        "ie": 11
+      }
+    }]
+  ]
+}

package/src/helpers/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@atlaspack/eslint-config-browser"
+}

package/src/helpers/browser/css-loader.js

@@ -0,0 +1,32 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadCSSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    // Don't insert the same link element twice (e.g. if it was already in the HTML)
+    let existingLinks = document.getElementsByTagName('link');
+    let isCurrentBundle = function (link) {
+      return link.href === bundle && link.rel.indexOf('stylesheet') > -1;
+    };
+
+    if ([].concat(existingLinks).some(isCurrentBundle)) {
+      resolve();
+      return;
+    }
+
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = bundle;
+    link.onerror = function (e) {
+      link.onerror = link.onload = null;
+      link.remove();
+      reject(e);
+    };
+
+    link.onload = function () {
+      link.onerror = link.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(link);
+  });
+});

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

@@ -0,0 +1,26 @@
+async function load(id) {
+  if (!atlaspackRequire.retryState) {
+    atlaspackRequire.retryState = {};
+  }
+
+  if (!globalThis.navigator.onLine) {
+    await new Promise(res =>
+      globalThis.addEventListener('online', res, {once: true}),
+    );
+  }
+
+  let url = require('../bundle-manifest').resolve(id);
+
+  if (atlaspackRequire.retryState[id] != undefined) {
+    url = `${url}?retry=${atlaspackRequire.retryState[id]}`;
+  }
+
+  try {
+    // eslint-disable-next-line no-undef
+    return await __atlaspack__import__(url);
+  } catch (error) {
+    atlaspackRequire.retryState[id] = Date.now();
+  }
+}
+
+module.exports = load;

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

@@ -0,0 +1,6 @@
+function load(id) {
+  // eslint-disable-next-line no-undef
+  return __atlaspack__import__(require('../bundle-manifest').resolve(id));
+}
+
+module.exports = load;

package/src/helpers/browser/html-loader.js

@@ -0,0 +1,7 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadHTMLBundle(bundle) {
+  return fetch(bundle).then(function (res) {
+    return res.text();
+  });
+});

package/src/helpers/browser/import-polyfill.js

@@ -0,0 +1,32 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function importModule(bundle) {
+  return new Promise((resolve, reject) => {
+    // Add a global function to handle when the script loads.
+    let globalName = `i${('' + Math.random()).slice(2)}`;
+    global[globalName] = m => {
+      resolve(m);
+      cleanup();
+    };
+
+    // Remove script on load or error
+    let cleanup = () => {
+      delete global[globalName];
+      script.onerror = null;
+      script.remove();
+    };
+
+    // Append an inline script tag into the document head
+    let script = document.createElement('script');
+    script.async = true;
+    script.type = 'module';
+    script.charset = 'utf-8';
+    script.textContent = `import * as m from '${bundle}'; ${globalName}(m);`;
+    script.onerror = function (e) {
+      reject(e);
+      cleanup();
+    };
+
+    document.head.appendChild(script);
+  });
+});

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

@@ -0,0 +1,42 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    // Don't insert the same script twice (e.g. if it was already in the HTML)
+    let existingScripts = document.getElementsByTagName('script');
+    let isCurrentBundle = function (script) {
+      return script.src === bundle;
+    };
+
+    if ([].concat(existingScripts).some(isCurrentBundle)) {
+      resolve();
+      return;
+    }
+
+    var preloadLink = document.createElement('link');
+    preloadLink.href = bundle;
+    preloadLink.rel = 'preload';
+    preloadLink.as = 'script';
+    document.head.appendChild(preloadLink);
+
+    var script = document.createElement('script');
+    script.async = true;
+    script.type = 'text/javascript';
+    script.src = bundle;
+    script.onerror = function (e) {
+      var error = new TypeError(
+        `Failed to fetch dynamically imported module: ${bundle}. Error: ${e.message}`,
+      );
+      script.onerror = script.onload = null;
+      script.remove();
+      reject(error);
+    };
+
+    script.onload = function () {
+      script.onerror = script.onload = null;
+      resolve();
+    };
+
+    document.getElementsByTagName('head')[0].appendChild(script);
+  });
+});

package/src/helpers/browser/prefetch-loader.js

@@ -0,0 +1,13 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function prefetchJSBundle(bundle, priority) {
+  var link = document.createElement('link');
+  link.rel = 'prefetch';
+  link.href = bundle;
+  if (priority) {
+    link.as = priority;
+  }
+
+  document.getElementsByTagName('head')[0].appendChild(link);
+  return Promise.resolve();
+}, 'prefetch');

package/src/helpers/browser/preload-loader.js

@@ -0,0 +1,19 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function preloadJSBundle(
+  bundle,
+  priority,
+  isModule,
+) {
+  var link = document.createElement('link');
+  link.charset = 'utf-8';
+  link.rel = isModule ? 'modulepreload' : 'preload';
+  link.href = bundle;
+  if (priority) {
+    link.as = priority;
+  }
+
+  document.getElementsByTagName('head')[0].appendChild(link);
+  return Promise.resolve();
+},
+'preload');

package/src/helpers/browser/wasm-loader.js

@@ -0,0 +1,17 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadWASMBundle(bundle) {
+  return fetch(bundle)
+    .then(function (res) {
+      if (WebAssembly.instantiateStreaming) {
+        return WebAssembly.instantiateStreaming(res);
+      } else {
+        return res.arrayBuffer().then(function (data) {
+          return WebAssembly.instantiate(data);
+        });
+      }
+    })
+    .then(function (wasmModule) {
+      return wasmModule.instance.exports;
+    });
+});

package/src/helpers/bundle-manifest.js

@@ -0,0 +1,21 @@
+var mapping = new Map();
+
+function register(baseUrl, manifest) {
+  for (var i = 0; i < manifest.length - 1; i += 2) {
+    mapping.set(manifest[i], {
+      baseUrl: baseUrl,
+      path: manifest[i + 1],
+    });
+  }
+}
+
+function resolve(id) {
+  var resolved = mapping.get(id);
+  if (resolved == null) {
+    throw new Error('Could not resolve bundle with id ' + id);
+  }
+  return new URL(resolved.path, resolved.baseUrl).toString();
+}
+
+module.exports.register = register;
+module.exports.resolve = resolve;

package/src/helpers/bundle-url.js

@@ -0,0 +1,51 @@
+var bundleURL = {};
+function getBundleURLCached(id) {
+  var value = bundleURL[id];
+  if (!value) {
+    value = getBundleURL();
+    bundleURL[id] = value;
+  }
+
+  return value;
+}
+
+function getBundleURL() {
+  try {
+    throw new Error();
+  } catch (err) {
+    var matches = ('' + err.stack).match(
+      /(https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/[^)\n]+/g,
+    );
+    if (matches) {
+      // The first two stack frames will be this function and getBundleURLCached.
+      // Use the 3rd one, which will be a runtime in the original bundle.
+      return getBaseURL(matches[2]);
+    }
+  }
+
+  return '/';
+}
+
+function getBaseURL(url) {
+  return (
+    ('' + url).replace(
+      /^((?:https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/.+)\/[^/]+$/,
+      '$1',
+    ) + '/'
+  );
+}
+
+// TODO: Replace uses with `new URL(url).origin` when ie11 is no longer supported.
+function getOrigin(url) {
+  let matches = ('' + url).match(
+    /(https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/[^/]+/,
+  );
+  if (!matches) {
+    throw new Error('Origin not found');
+  }
+  return matches[0];
+}
+
+exports.getBundleURL = getBundleURLCached;
+exports.getBaseURL = getBaseURL;
+exports.getOrigin = getOrigin;

package/src/helpers/cacheLoader.js

@@ -0,0 +1,29 @@
+let cachedBundles = {};
+let cachedPreloads = {};
+let cachedPrefetches = {};
+
+function getCache(type) {
+  switch (type) {
+    case 'preload':
+      return cachedPreloads;
+    case 'prefetch':
+      return cachedPrefetches;
+    default:
+      return cachedBundles;
+  }
+}
+
+module.exports = function cacheLoader(loader, type) {
+  return function (bundle) {
+    let cache = getCache(type);
+
+    if (cache[bundle]) {
+      return cache[bundle];
+    }
+
+    return (cache[bundle] = loader.apply(null, arguments).catch(function (e) {
+      delete cache[bundle];
+      throw e;
+    }));
+  };
+};

package/src/helpers/get-worker-url.js

@@ -0,0 +1,15 @@
+module.exports = function loadWorker(workerUrl, origin, isESM) {
+  if (origin === self.location.origin) {
+    // If the worker bundle's url is on the same origin as the document,
+    // use the worker bundle's own url.
+    return workerUrl;
+  } else {
+    // Otherwise, create a blob URL which loads the worker bundle with `importScripts`.
+    let source = isESM
+      ? 'import ' + JSON.stringify(workerUrl) + ';'
+      : 'importScripts(' + JSON.stringify(workerUrl) + ');';
+    return URL.createObjectURL(
+      new Blob([source], {type: 'application/javascript'}),
+    );
+  }
+};

package/src/helpers/node/css-loader.js

@@ -0,0 +1,4 @@
+// loading a CSS style is a no-op in Node.js
+module.exports = function loadCSSBundle() {
+  return Promise.resolve();
+};

package/src/helpers/node/html-loader.js

@@ -0,0 +1,18 @@
+const fs = require('fs');
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadHTMLBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    fs.readFile(__dirname + bundle, 'utf8', function (err, data) {
+      if (err) {
+        reject(err);
+      } else {
+        // wait for the next event loop iteration, so we are sure
+        // the current module is fully loaded
+        setImmediate(function () {
+          resolve(data);
+        });
+      }
+    });
+  });
+});

package/src/helpers/node/js-loader.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    fs.readFile(__dirname + bundle, 'utf8', function (err, data) {
+      if (err) {
+        reject(err);
+      } else {
+        // wait for the next event loop iteration, so we are sure
+        // the current module is fully loaded
+        setImmediate(function () {
+          resolve(data);
+        });
+      }
+    });
+  }).then(function (code) {
+    new Function('', code)();
+  });
+});

package/src/helpers/node/wasm-loader.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadWASMBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    fs.readFile(__dirname + bundle, function (err, data) {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.buffer);
+      }
+    });
+  })
+    .then(function (data) {
+      return WebAssembly.instantiate(data);
+    })
+    .then(function (wasmModule) {
+      return wasmModule.instance.exports;
+    });
+});

package/src/helpers/worker/js-loader.js

@@ -0,0 +1,13 @@
+/* global __atlaspack__importScripts__:readonly*/
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadJSBundle(bundle) {
+  return new Promise(function (resolve, reject) {
+    try {
+      __atlaspack__importScripts__(bundle);
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});

package/src/helpers/worker/wasm-loader.js

@@ -0,0 +1,17 @@
+const cacheLoader = require('../cacheLoader');
+
+module.exports = cacheLoader(function loadWASMBundle(bundle) {
+  return fetch(bundle)
+    .then(function (res) {
+      if (WebAssembly.instantiateStreaming) {
+        return WebAssembly.instantiateStreaming(res);
+      } else {
+        return res.arrayBuffer().then(function (data) {
+          return WebAssembly.instantiate(data);
+        });
+      }
+    })
+    .then(function (wasmModule) {
+      return wasmModule.instance.exports;
+    });
+});