@atlaspack/runtime-js 2.12.1-canary.3581 → 2.12.1-canary.3583

package/lib/JSRuntime.js

@@ -93,6 +93,19 @@ const CONFIG_SCHEMA = {
   properties: {
     splitManifestThreshold: {
       type: 'number'
+    },
+    domainSharding: {
+      type: 'object',
+      properties: {
+        maxShards: {
+          type: 'number'
+        },
+        cookieName: {
+          type: 'string'
+        }
+      },
+      additionalProperties: false,
+      required: ['maxShards', 'cookieName']
     }
   },
   additionalProperties: false
@@ -181,7 +194,8 @@ var _default = exports.default = new (_plugin().Runtime)({
           dependency,
           bundleGraph,
           bundleGroup: resolved.value,
-          options
+          options,
+          shardingConfig: config.domainSharding
         });
         if (loaderRuntime != null) {
           assets.push(loaderRuntime);
@@ -257,7 +271,7 @@ var _default = exports.default = new (_plugin().Runtime)({
       }
 
       // URL dependency or not, fall back to including a runtime that exports the url
-      assets.push(getURLRuntime(dependency, bundle, mainBundle, options));
+      assets.push(getURLRuntime(dependency, bundle, mainBundle, options, config.domainSharding));
     }
 
     // In development, bundles can be created lazily. This means that the parent bundle may not
@@ -275,7 +289,7 @@ var _default = exports.default = new (_plugin().Runtime)({
           continue;
         }
         let relativePathExpr = getRelativePathExpr(bundle, referencedBundle, options);
-        let loaderCode = `require(${JSON.stringify(loader)})( ${getAbsoluteUrlExpr(relativePathExpr, bundle)})`;
+        let loaderCode = `require(${JSON.stringify(loader)})(${getAbsoluteUrlExpr(relativePathExpr, bundle, referencedBundle, config.domainSharding)})`;
         assets.push({
           filePath: __filename,
           code: loaderCode,
@@ -338,7 +352,8 @@ function getLoaderRuntime({
   dependency,
   bundleGroup,
   bundleGraph,
-  options
+  options,
+  shardingConfig
 }) {
   let loaders = getLoaders(bundle.env);
   if (loaders == null) {
@@ -372,7 +387,7 @@ function getLoaderRuntime({
   let needsDynamicImportPolyfill = !bundle.env.isLibrary && !bundle.env.supports('dynamic-import', true);
   let needsEsmLoadPrelude = false;
   let loaderModules = [];
-  function getLoaderForBundle(bundle, to) {
+  function getLoaderForBundle(bundle, to, shardingConfig) {
     let loader = loaders[to.type];
     if (!loader) {
       return;
@@ -392,7 +407,7 @@ function getLoaderRuntime({
     } else if (to.type === 'js' && to.env.outputFormat === 'commonjs') {
       return `Promise.resolve(__parcel__require__("./" + ${relativePathExpr}))`;
     }
-    let absoluteUrlExpr = shouldUseRuntimeManifest(bundle, options) ? `require('./helpers/bundle-manifest').resolve(${JSON.stringify(to.publicId)})` : getAbsoluteUrlExpr(relativePathExpr, bundle);
+    let absoluteUrlExpr = shouldUseRuntimeManifest(bundle, options) ? `require('./helpers/bundle-manifest').resolve(${JSON.stringify(to.publicId)})` : getAbsoluteUrlExpr(relativePathExpr, bundle, to, shardingConfig);
     let code = `require(${JSON.stringify(loader)})(${absoluteUrlExpr})`;
 
     // In development, clear the require cache when an error occurs so the
@@ -415,7 +430,7 @@ function getLoaderRuntime({
     }
   }
   for (let to of externalBundles) {
-    let loaderModule = getLoaderForBundle(bundle, to);
+    let loaderModule = getLoaderForBundle(bundle, to, shardingConfig);
     if (loaderModule !== undefined) loaderModules.push(loaderModule);
   }
 
@@ -513,7 +528,7 @@ function getHintLoaders(bundleGraph, from, bundleGroups, loader, options) {
     for (let bundleToPreload of bundlesToPreload) {
       let relativePathExpr = getRelativePathExpr(from, bundleToPreload, options);
       let priority = TYPE_TO_RESOURCE_PRIORITY[bundleToPreload.type];
-      hintLoaders.push(`require(${JSON.stringify(loader)})(${getAbsoluteUrlExpr(relativePathExpr, from)}, ${priority ? JSON.stringify(priority) : 'null'}, ${JSON.stringify(bundleToPreload.target.env.outputFormat === 'esmodule')})`);
+      hintLoaders.push(`require(${JSON.stringify(loader)})(${getAbsoluteUrlExpr(relativePathExpr, from, bundleToPreload)}, ${priority ? JSON.stringify(priority) : 'null'}, ${JSON.stringify(bundleToPreload.target.env.outputFormat === 'esmodule')})`);
     }
   }
   return hintLoaders;
@@ -523,7 +538,7 @@ function isNewContext(bundle, bundleGraph) {
   let isInEntryBundleGroup = bundleGraph.getBundleGroupsContainingBundle(bundle).some(g => bundleGraph.isEntryBundleGroup(g));
   return isInEntryBundleGroup || parents.length === 0 || parents.some(parent => parent.env.context !== bundle.env.context || parent.type !== 'js');
 }
-function getURLRuntime(dependency, from, to, options) {
+function getURLRuntime(dependency, from, to, options, shardingConfig) {
   let relativePathExpr = getRelativePathExpr(from, to, options);
   let code;
   if (dependency.meta.webworker === true && !from.env.isLibrary) {
@@ -537,7 +552,7 @@ function getURLRuntime(dependency, from, to, options) {
       code += `module.exports = workerURL(url, bundleURL.getOrigin(url), ${String(from.env.outputFormat === 'esmodule')});`;
     }
   } else {
-    code = `module.exports = ${getAbsoluteUrlExpr(relativePathExpr, from)};`;
+    code = `module.exports = ${getAbsoluteUrlExpr(relativePathExpr, from, to, shardingConfig)};`;
   }
   return {
     filePath: __filename,
@@ -585,13 +600,16 @@ function getRelativePathExpr(from, to, options) {
   }
   return res;
 }
-function getAbsoluteUrlExpr(relativePathExpr, bundle) {
-  if (bundle.env.outputFormat === 'esmodule' && bundle.env.supports('import-meta-url') || bundle.env.outputFormat === 'commonjs') {
+function getAbsoluteUrlExpr(relativePathExpr, fromBundle, toBundle, shardingConfig) {
+  if (fromBundle.env.outputFormat === 'esmodule' && fromBundle.env.supports('import-meta-url') || fromBundle.env.outputFormat === 'commonjs') {
     // This will be compiled to new URL(url, import.meta.url) or new URL(url, 'file:' + __filename).
     return `new __parcel__URL__(${relativePathExpr}).toString()`;
-  } else {
-    return `require('./helpers/bundle-url').getBundleURL('${bundle.publicId}') + ${relativePathExpr}`;
   }
+  if (shardingConfig) {
+    const bundleUrlArgs = [`'${toBundle.name}'`, `'${shardingConfig.cookieName}'`, 'document.cookie', shardingConfig.maxShards].join(', ');
+    return `require('./helpers/bundle-url-shards').getShardedBundleURL(${bundleUrlArgs}) + ${relativePathExpr}`;
+  }
+  return `require('./helpers/bundle-url').getBundleURL('${fromBundle.publicId}') + ${relativePathExpr}`;
 }
 function shouldUseRuntimeManifest(bundle, options) {
   let env = bundle.env;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/runtime-js",
-  "version": "2.12.1-canary.3581+f0f92f212",
+  "version": "2.12.1-canary.3583+3054dda39",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -12,15 +12,15 @@
   "main": "lib/JSRuntime.js",
   "source": "src/JSRuntime.js",
   "engines": {
-    "atlaspack": "2.12.1-canary.3581+f0f92f212",
+    "atlaspack": "2.12.1-canary.3583+3054dda39",
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.12.1-canary.3581+f0f92f212",
-    "@atlaspack/feature-flags": "2.12.1-canary.3581+f0f92f212",
-    "@atlaspack/plugin": "2.12.1-canary.3581+f0f92f212",
-    "@atlaspack/utils": "2.12.1-canary.3581+f0f92f212",
+    "@atlaspack/diagnostic": "2.12.1-canary.3583+3054dda39",
+    "@atlaspack/feature-flags": "2.12.1-canary.3583+3054dda39",
+    "@atlaspack/plugin": "2.12.1-canary.3583+3054dda39",
+    "@atlaspack/utils": "2.12.1-canary.3583+3054dda39",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "f0f92f21248b1577c6ad3673e2eca9a9bb39940c"
+  "gitHead": "3054dda39b54666caba268f09cadf801b43ce3a5"
 }

package/src/JSRuntime.js

@@ -74,6 +74,10 @@ let bundleDependencies = new WeakMap<
 
 type JSRuntimeConfig = {|
   splitManifestThreshold: number,
+  domainSharding?: {|
+    maxShards: number,
+    cookieName: string,
+  |},
 |};
 
 let defaultConfig: JSRuntimeConfig = {
@@ -86,6 +90,19 @@ const CONFIG_SCHEMA: SchemaEntity = {
     splitManifestThreshold: {
       type: 'number',
     },
+    domainSharding: {
+      type: 'object',
+      properties: {
+        maxShards: {
+          type: 'number',
+        },
+        cookieName: {
+          type: 'string',
+        },
+      },
+      additionalProperties: false,
+      required: ['maxShards', 'cookieName'],
+    },
   },
   additionalProperties: false,
 };
@@ -181,6 +198,7 @@ export default (new Runtime({
           bundleGraph,
           bundleGroup: resolved.value,
           options,
+          shardingConfig: config.domainSharding,
         });
 
         if (loaderRuntime != null) {
@@ -271,7 +289,15 @@ export default (new Runtime({
       }
 
       // URL dependency or not, fall back to including a runtime that exports the url
-      assets.push(getURLRuntime(dependency, bundle, mainBundle, options));
+      assets.push(
+        getURLRuntime(
+          dependency,
+          bundle,
+          mainBundle,
+          options,
+          config.domainSharding,
+        ),
+      );
     }
 
     // In development, bundles can be created lazily. This means that the parent bundle may not
@@ -297,7 +323,12 @@ export default (new Runtime({
         );
         let loaderCode = `require(${JSON.stringify(
           loader,
-        )})( ${getAbsoluteUrlExpr(relativePathExpr, bundle)})`;
+        )})(${getAbsoluteUrlExpr(
+          relativePathExpr,
+          bundle,
+          referencedBundle,
+          config.domainSharding,
+        )})`;
         assets.push({
           filePath: __filename,
           code: loaderCode,
@@ -376,12 +407,14 @@ function getLoaderRuntime({
   bundleGroup,
   bundleGraph,
   options,
+  shardingConfig,
 }: {|
   bundle: NamedBundle,
   dependency: Dependency,
   bundleGroup: BundleGroup,
   bundleGraph: BundleGraph<NamedBundle>,
   options: PluginOptions,
+  shardingConfig: JSRuntimeConfig['domainSharding'],
 |}): ?RuntimeAsset {
   let loaders = getLoaders(bundle.env);
   if (loaders == null) {
@@ -423,6 +456,7 @@ function getLoaderRuntime({
   function getLoaderForBundle(
     bundle: NamedBundle,
     to: NamedBundle,
+    shardingConfig: JSRuntimeConfig['domainSharding'],
   ): string | void {
     let loader = loaders[to.type];
     if (!loader) {
@@ -459,7 +493,7 @@ function getLoaderRuntime({
       ? `require('./helpers/bundle-manifest').resolve(${JSON.stringify(
           to.publicId,
         )})`
-      : getAbsoluteUrlExpr(relativePathExpr, bundle);
+      : getAbsoluteUrlExpr(relativePathExpr, bundle, to, shardingConfig);
     let code = `require(${JSON.stringify(loader)})(${absoluteUrlExpr})`;
 
     // In development, clear the require cache when an error occurs so the
@@ -508,7 +542,7 @@ function getLoaderRuntime({
   }
 
   for (let to of externalBundles) {
-    let loaderModule = getLoaderForBundle(bundle, to);
+    let loaderModule = getLoaderForBundle(bundle, to, shardingConfig);
     if (loaderModule !== undefined) loaderModules.push(loaderModule);
   }
 
@@ -650,6 +684,7 @@ function getHintLoaders(
         `require(${JSON.stringify(loader)})(${getAbsoluteUrlExpr(
           relativePathExpr,
           from,
+          bundleToPreload,
         )}, ${priority ? JSON.stringify(priority) : 'null'}, ${JSON.stringify(
           bundleToPreload.target.env.outputFormat === 'esmodule',
         )})`,
@@ -683,6 +718,7 @@ function getURLRuntime(
   from: NamedBundle,
   to: NamedBundle,
   options: PluginOptions,
+  shardingConfig: JSRuntimeConfig['domainSharding'],
 ): RuntimeAsset {
   let relativePathExpr = getRelativePathExpr(from, to, options);
   let code;
@@ -705,7 +741,12 @@ function getURLRuntime(
       )});`;
     }
   } else {
-    code = `module.exports = ${getAbsoluteUrlExpr(relativePathExpr, from)};`;
+    code = `module.exports = ${getAbsoluteUrlExpr(
+      relativePathExpr,
+      from,
+      to,
+      shardingConfig,
+    )};`;
   }
 
   return {
@@ -775,17 +816,33 @@ function getRelativePathExpr(
   return res;
 }
 
-function getAbsoluteUrlExpr(relativePathExpr: string, bundle: NamedBundle) {
+function getAbsoluteUrlExpr(
+  relativePathExpr: string,
+  fromBundle: NamedBundle,
+  toBundle: NamedBundle,
+  shardingConfig: JSRuntimeConfig['domainSharding'],
+) {
   if (
-    (bundle.env.outputFormat === 'esmodule' &&
-      bundle.env.supports('import-meta-url')) ||
-    bundle.env.outputFormat === 'commonjs'
+    (fromBundle.env.outputFormat === 'esmodule' &&
+      fromBundle.env.supports('import-meta-url')) ||
+    fromBundle.env.outputFormat === 'commonjs'
   ) {
     // This will be compiled to new URL(url, import.meta.url) or new URL(url, 'file:' + __filename).
     return `new __parcel__URL__(${relativePathExpr}).toString()`;
-  } else {
-    return `require('./helpers/bundle-url').getBundleURL('${bundle.publicId}') + ${relativePathExpr}`;
   }
+
+  if (shardingConfig) {
+    const bundleUrlArgs = [
+      `'${toBundle.name}'`,
+      `'${shardingConfig.cookieName}'`,
+      'document.cookie',
+      shardingConfig.maxShards,
+    ].join(', ');
+
+    return `require('./helpers/bundle-url-shards').getShardedBundleURL(${bundleUrlArgs}) + ${relativePathExpr}`;
+  }
+
+  return `require('./helpers/bundle-url').getBundleURL('${fromBundle.publicId}') + ${relativePathExpr}`;
 }
 
 function shouldUseRuntimeManifest(

package/src/helpers/bundle-url-common.ts

@@ -0,0 +1,10 @@
+// Get the URL without the filename (last / segment)
+function getBaseURL(url: string) {
+  return url.slice(0, url.lastIndexOf('/')) + '/';
+}
+
+const stackTraceUrlRegexp =
+  /(https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/[^)\n]+/g;
+
+exports.getBaseURL = getBaseURL;
+exports.stackTraceUrlRegexp = stackTraceUrlRegexp;

package/src/helpers/bundle-url-shards.ts

@@ -0,0 +1,95 @@
+const {getBaseURL, stackTraceUrlRegexp} = require('./bundle-url-common');
+
+const bundleURL: Record<string, string> = {};
+
+function getShardedBundleURL(
+  bundleName: string,
+  cookieName: string,
+  cookieString: string,
+  maxShards: number,
+  inputError?: string,
+): string {
+  let value = bundleURL[bundleName];
+
+  if (value) {
+    return value;
+  }
+
+  try {
+    throw inputError ?? new Error();
+  } catch (err) {
+    var matches = ('' + err.stack).match(stackTraceUrlRegexp);
+
+    if (!matches) {
+      return '/';
+    }
+
+    // The first stack frame will be this function.
+    // Use the 2nd one, which will be a runtime in the original bundle.
+    const stackUrl = matches[1];
+    const baseUrl = getBaseURL(stackUrl);
+
+    // If the cookie doesn't exist then we don't need to shard
+    if (cookieString.indexOf(cookieName) === -1) {
+      return baseUrl;
+    }
+
+    const shardNumber = getDomainShardIndex(bundleName, maxShards);
+    const url = new URL(baseUrl);
+
+    const shardedDomain = getShardedDomain(url.hostname, shardNumber);
+    url.hostname = shardedDomain;
+
+    value = url.toString();
+
+    bundleURL[bundleName] = value;
+    return value;
+  }
+}
+
+function getDomainShardIndex(str: string, maxShards: number) {
+  let shard = str.split('').reduce((a, b) => {
+    const n = (a << maxShards) - a + b.charCodeAt(0);
+
+    // The value returned by << is 64 bit, the & operator coerces to 32,
+    // prevents overflow as we iterate.
+    return n & n;
+  }, 0);
+
+  shard = shard % maxShards;
+
+  // Make number positive
+  if (shard < 0) {
+    shard += maxShards;
+  }
+
+  return shard;
+}
+
+function getShardedDomain(domain: string, shard: number) {
+  let i = domain.indexOf('.');
+
+  // Domains like localhost have no . separators
+  if (i === -1) {
+    return `${removeTrailingShard(domain)}-${shard}`;
+  }
+
+  // If this domain already has a shard number in it, strip it out before adding
+  // the new one
+  const firstSubdomain = removeTrailingShard(domain.slice(0, i));
+
+  return `${firstSubdomain}-${shard}${domain.slice(i)}`;
+}
+
+const trailingShardRegex = /-\d+$/;
+
+function removeTrailingShard(subdomain: string) {
+  if (!trailingShardRegex.test(subdomain)) {
+    return subdomain;
+  }
+
+  const shardIdx = subdomain.lastIndexOf('-');
+  return subdomain.slice(0, shardIdx);
+}
+
+exports.getShardedBundleURL = getShardedBundleURL;

package/src/helpers/bundle-url.ts

@@ -0,0 +1,36 @@
+const {getBaseURL, stackTraceUrlRegexp} = require('./bundle-url-common');
+
+const bundleURL = {};
+
+function getBundleURLCached(id: string) {
+  let 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(stackTraceUrlRegexp);
+    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 getOrigin(url: string) {
+  return new URL(url).origin;
+}
+
+exports.getOrigin = getOrigin;
+exports.getBundleURL = getBundleURLCached;

package/test/bundle-url-common.test.js

@@ -0,0 +1,27 @@
+import assert from 'assert';
+
+import {getBaseURL} from '../src/helpers/bundle-url-common';
+
+describe('getBaseUrl', () => {
+  it('should return the URL with the filename removed', () => {
+    const testUrl =
+      'https://bundle-shard-3.assets.example.com/assets/testBundle.123abc.js';
+
+    assert.equal(
+      getBaseURL(testUrl),
+      'https://bundle-shard-3.assets.example.com/assets/',
+    );
+  });
+
+  it('should handle domains with no .', () => {
+    const testUrl = 'http://localhost/assets/testBundle.123abc.js';
+
+    assert.equal(getBaseURL(testUrl), 'http://localhost/assets/');
+  });
+
+  it('should handle domains with ports', () => {
+    const testUrl = 'http://localhost:8081/assets/testBundle.123abc.js';
+
+    assert.equal(getBaseURL(testUrl), 'http://localhost:8081/assets/');
+  });
+});

package/test/bundle-url-shards.test.js

@@ -0,0 +1,139 @@
+import assert from 'assert';
+
+import {fsFixture, overlayFS, bundle} from '@atlaspack/test-utils';
+
+import {getShardedBundleURL} from '../src/helpers/bundle-url-shards';
+
+const testingCookieName = 'DOMAIN_SHARDING_TEST';
+
+const createErrorStack = (url) => {
+  // This error stack is copied from a local dev, with a bunch
+  // of lines trimmed off the end so it's not unnecessarily long
+  return `
+Error
+    at Object.getShardedBundleURL (http://localhost:8081/main-bundle.1a2fa8b7.js:15688:29)
+    at a7u9v.6d3ceb6ac67fea50 (${url}.1a2fa8b7.js:361466:46)
+    at newRequire (http://localhost:8081/main-bundle.1a2fa8b7.js:71:24)
+    at localRequire (http://localhost:8081/main-bundle.1a2fa8b7.js:84:35)
+    at 7H8wc.react-intl-next (http://localhost:8081/main-bundle.1a2fa8b7.js:279746:28)
+    at newRequire (http://localhost:8081/main-bundle.1a2fa8b7.js:71:24)
+    at localRequire (http://localhost:8081/main-bundle.1a2fa8b7.js:84:35)
+    at 1nL5S../manifest (http://localhost:8081/main-bundle.1a2fa8b7.js:279714:17)
+    at newRequire (http://localhost:8081/main-bundle.1a2fa8b7.js:71:24)
+    at localRequire (http://localhost:8081/main-bundle.1a2fa8b7.js:84:35)
+`.trim();
+};
+
+describe('bundle-url-shards helper', () => {
+  describe('getShardedBundleURL', () => {
+    it('should shard a URL if the cookie is present', () => {
+      const testBundle = 'test-bundle.123abc.js';
+
+      const err = new Error();
+      err.stack = createErrorStack(
+        'https://bundle-shard.assets.example.com/assets/ParentBundle.cba321.js',
+      );
+
+      const result = getShardedBundleURL(
+        testBundle,
+        testingCookieName,
+        `${testingCookieName}=1`,
+        5,
+        err,
+      );
+
+      assert.equal(result, 'https://bundle-shard-0.assets.example.com/assets/');
+    });
+
+    it('should re-shard a domain that has already been sharded', () => {
+      const testBundle = 'TestBundle.1a2b3c.js';
+
+      const err = new Error();
+      err.stack = createErrorStack(
+        'https://bundle-shard-1.assets.example.com/assets/ParentBundle.cba321.js',
+      );
+
+      const result = getShardedBundleURL(
+        testBundle,
+        testingCookieName,
+        `${testingCookieName}=1`,
+        5,
+        err,
+      );
+
+      assert.equal(result, 'https://bundle-shard-4.assets.example.com/assets/');
+    });
+
+    it('should not add a shard if the cookie is not present', () => {
+      const testBundle = 'UnshardedBundle.9z8x7y.js';
+
+      const err = new Error();
+      err.stack = createErrorStack(
+        'https://bundle-unsharded.assets.example.com/assets/ParentBundle.cba321.js',
+      );
+
+      const result = getShardedBundleURL(
+        testBundle,
+        testingCookieName,
+        `some.other.cookie=1`,
+        5,
+        err,
+      );
+
+      assert.equal(
+        result,
+        'https://bundle-unsharded.assets.example.com/assets/',
+      );
+    });
+  });
+
+  describe('compiled into JS Runtime', () => {
+    it('should insert all arguments into compiled output', async () => {
+      const maxShards = 8;
+      await fsFixture(overlayFS)`
+        package.json:
+          {
+            "name": "bundle-sharding-test",
+            "@atlaspack/runtime-js": {
+              "domainSharding": {
+                "maxShards": ${maxShards},
+                "cookieName": "${testingCookieName}"
+              }
+            }
+          }
+
+        src/index.js:
+          async function fn() {
+            const a = await import('./a.js');
+            const b = await import('./b.js');
+            console.log('a', a, b);
+          }
+          fn();
+
+        src/a.js:
+          export const a = async () => {
+            const b = await import('./b');
+            return b + 'A';
+          }
+        src/b.js:
+          export const b = 'B';
+
+        yarn.lock:
+      `;
+
+      const bundleGraph = await bundle('src/index.js', {inputFS: overlayFS});
+
+      const mainBundle = bundleGraph
+        .getBundles()
+        .find((b) => b.name === 'index.js');
+
+      const code = await overlayFS.readFile(mainBundle.filePath, 'utf-8');
+      assert.ok(
+        code.includes(
+          `require("449af90f11ccd363").getShardedBundleURL('b.8575baaf.js', '${testingCookieName}', document.cookie, ${maxShards}) + "b.8575baaf.js"`,
+        ),
+        'Expected generated code for getShardedBundleURL was not found',
+      );
+    });
+  });
+});

package/lib/helpers/bundle-url.js

@@ -1,39 +0,0 @@
-"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/src/helpers/bundle-url.js

@@ -1,51 +0,0 @@
-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;