@atlaspack/runtime-js 2.12.1-canary.3354

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (bundle) {
+  return new Promise(function (resolve, reject) {
+    // Don't insert the same script twice (e.g. if it was already in the HTML)
+    var existingScripts = document.getElementsByTagName('script');
+    if ([].concat(existingScripts).some(function isCurrentBundle(script) {
+      return script.src === bundle;
+    })) {
+      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: ".concat(bundle, ". Error: ").concat(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/lib/helpers/browser/prefetch-loader.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/lib/helpers/browser/preload-loader.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/lib/helpers/browser/wasm-loader.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/lib/helpers/bundle-manifest.js

@@ -0,0 +1,20 @@
+"use strict";
+
+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/lib/helpers/bundle-url.js

@@ -0,0 +1,39 @@
+"use strict";
+
+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) {
+  var 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/lib/helpers/cacheLoader.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var cachedBundles = {};
+var cachedPreloads = {};
+var cachedPrefetches = {};
+function getCache(type) {
+  switch (type) {
+    case 'preload':
+      return cachedPreloads;
+    case 'prefetch':
+      return cachedPrefetches;
+    default:
+      return cachedBundles;
+  }
+}
+module.exports = function (loader, type) {
+  return function (bundle) {
+    var 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/lib/helpers/get-worker-url.js

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = function (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`.
+    var source = isESM ? 'import ' + JSON.stringify(workerUrl) + ';' : 'importScripts(' + JSON.stringify(workerUrl) + ');';
+    return URL.createObjectURL(new Blob([source], {
+      type: 'application/javascript'
+    }));
+  }
+};

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+
+var fs = require('fs');
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/lib/helpers/node/js-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var fs = require('fs');
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/lib/helpers/node/wasm-loader.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var fs = require('fs');
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/lib/helpers/worker/js-loader.js

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+var cacheLoader = require('../cacheLoader');
+module.exports = cacheLoader(function (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/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@atlaspack/runtime-js",
+  "version": "2.12.1-canary.3354+7bb54d46a",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atlassian-labs/atlaspack.git"
+  },
+  "main": "lib/JSRuntime.js",
+  "source": "src/JSRuntime.js",
+  "engines": {
+    "node": ">= 16.0.0",
+    "atlaspack": "2.12.1-canary.3354+7bb54d46a"
+  },
+  "dependencies": {
+    "@atlaspack/diagnostic": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/plugin": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/utils": "2.12.1-canary.3354+7bb54d46a",
+    "nullthrows": "^1.1.1"
+  },
+  "gitHead": "7bb54d46a00c5ba9cdbc2ee426dcbe82c8d79a3e"
+}