@atlaspack/runtime-js 2.19.9 → 2.20.0

package/lib/JSRuntime.js

@@ -172,6 +172,14 @@ var _default = exports.default = new (_plugin().Runtime)({
             dependency,
             env: {
               sourceType: 'module'
+            },
+            // Pre-computed symbols: exports Promise, no external dependencies (uses global)
+            symbolData: {
+              symbols: new Map([['default', {
+                local: 'module.exports',
+                loc: null
+              }]]),
+              dependencies: []
             }
           });
         }
@@ -186,6 +194,14 @@ var _default = exports.default = new (_plugin().Runtime)({
             dependency,
             env: {
               sourceType: 'module'
+            },
+            // Pre-computed symbols: exports Promise, no external dependencies
+            symbolData: {
+              symbols: new Map([['default', {
+                local: 'module.exports',
+                loc: null
+              }]]),
+              dependencies: []
             }
           });
           continue;
@@ -238,6 +254,30 @@ var _default = exports.default = new (_plugin().Runtime)({
           dependency: cond.ifFalseDependency,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: conditional loader with potential sync-js-loader fallback
+          symbolData: {
+            symbols: new Map([['default', {
+              local: 'module.exports',
+              loc: null
+            }]]),
+            dependencies: [{
+              specifier: loaderPath,
+              symbols: new Map([['default', {
+                local: 'default',
+                loc: null,
+                isWeak: false
+              }]]),
+              usedSymbols: new Set(['default'])
+            }, ...(shouldUseFallback ? [{
+              specifier: './helpers/browser/sync-js-loader',
+              symbols: new Map([['default', {
+                local: 'l',
+                loc: null,
+                isWeak: false
+              }]]),
+              usedSymbols: new Set(['default'])
+            }] : [])]
           }
         });
       }
@@ -253,6 +293,14 @@ var _default = exports.default = new (_plugin().Runtime)({
           dependency,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: simple export with no dependencies
+          symbolData: {
+            symbols: new Map([['default', {
+              local: 'module.exports',
+              loc: null
+            }]]),
+            dependencies: []
           }
         });
         continue;
@@ -270,6 +318,14 @@ var _default = exports.default = new (_plugin().Runtime)({
           dependency,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: simple export with no dependencies
+          symbolData: {
+            symbols: new Map([['default', {
+              local: 'module.exports',
+              loc: null
+            }]]),
+            dependencies: []
           }
         });
         continue;
@@ -315,6 +371,20 @@ var _default = exports.default = new (_plugin().Runtime)({
           isEntry: true,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: lazy bundle loader, requires specific loader helper
+          symbolData: {
+            symbols: new Map(),
+            // No exports, just side effects
+            dependencies: [{
+              specifier: loader,
+              symbols: new Map([['default', {
+                local: 'default',
+                loc: null,
+                isWeak: false
+              }]]),
+              usedSymbols: new Set(['default'])
+            }]
           }
         });
       }
@@ -328,7 +398,21 @@ var _default = exports.default = new (_plugin().Runtime)({
           sourceType: 'module'
         },
         runtimeAssetRequiringExecutionOnLoad: true,
-        priority: getManifestBundlePriority(bundleGraph, bundle, config.splitManifestThreshold)
+        priority: getManifestBundlePriority(bundleGraph, bundle, config.splitManifestThreshold),
+        // Pre-computed symbols: requires bundle-manifest helper
+        symbolData: {
+          symbols: new Map(),
+          // No exports, just executes
+          dependencies: [{
+            specifier: './helpers/bundle-manifest',
+            symbols: new Map([['register', {
+              local: 'register',
+              loc: null,
+              isWeak: false
+            }]]),
+            usedSymbols: new Set(['register'])
+          }]
+        }
       });
     }
     return assets;
@@ -535,6 +619,22 @@ function getLoaderRuntime({
       dependency,
       env: {
         sourceType: 'module'
+      },
+      // Pre-computed symbols: ESM loader with retry, requires esm-js-loader-retry helper
+      symbolData: {
+        symbols: new Map([['default', {
+          local: 'module.exports',
+          loc: null
+        }]]),
+        dependencies: [{
+          specifier: './helpers/browser/esm-js-loader-retry',
+          symbols: new Map([['default', {
+            local: 'default',
+            loc: null,
+            isWeak: false
+          }]]),
+          usedSymbols: new Set(['default'])
+        }]
       }
     };
   }
@@ -544,12 +644,165 @@ function getLoaderRuntime({
     code.push(preludeLoad);
   }
   code.push(`module.exports = ${loaderCode};`);
+
+  // Collect all potential helper dependencies used in loader runtime
+  let helperDependencies = [];
+
+  // Always potential dependencies based on the code patterns
+  if (needsEsmLoadPrelude) {
+    if (shardingConfig) {
+      helperDependencies.push({
+        specifier: './helpers/browser/esm-js-loader-shards',
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    } else {
+      helperDependencies.push({
+        specifier: './helpers/browser/esm-js-loader',
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    }
+  }
+
+  // Bundle manifest dependency if using runtime manifest
+  if (shouldUseRuntimeManifest(bundle, options)) {
+    helperDependencies.push({
+      specifier: './helpers/bundle-manifest',
+      symbols: new Map([['resolve', {
+        local: 'resolve',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['resolve'])
+    });
+  }
+
+  // Domain sharding dependency if configured
+  if (shardingConfig) {
+    helperDependencies.push({
+      specifier: '@atlaspack/domain-sharding',
+      symbols: new Map([['shardUrl', {
+        local: 'shardUrl',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['shardUrl'])
+    });
+  }
+
+  // Various loader dependencies based on bundle types in externalBundles
+  for (let to of externalBundles) {
+    let loader = loaders[to.type];
+    if (loader && typeof loader === 'string') {
+      helperDependencies.push({
+        specifier: loader,
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    }
+  }
+
+  // Import polyfill if needed
+  if (needsDynamicImportPolyfill && loaders !== null && loaders !== void 0 && loaders.IMPORT_POLYFILL) {
+    helperDependencies.push({
+      specifier: loaders.IMPORT_POLYFILL,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+  }
+
+  // Conditional loaders if using conditional bundling
+  if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi')) {
+    const loaderPath = `./helpers/conditional-loader${options.mode === 'development' ? '-dev' : ''}`;
+    helperDependencies.push({
+      specifier: loaderPath,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+
+    // Sync loader for fallback
+    if (options.mode === 'development') {
+      helperDependencies.push({
+        specifier: './helpers/browser/sync-js-loader',
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    }
+  }
+
+  // Preload/prefetch loaders for browser context
+  if (bundle.env.context === 'browser') {
+    helperDependencies.push({
+      specifier: BROWSER_PRELOAD_LOADER,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+    helperDependencies.push({
+      specifier: BROWSER_PREFETCH_LOADER,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+  }
+
+  // ESM loader retry if using import retry feature
+  if (needsEsmLoadPrelude && options.featureFlags.importRetry) {
+    helperDependencies.push({
+      specifier: './helpers/browser/esm-js-loader-retry',
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+  }
   return {
     filePath: __filename,
     code: code.join('\n'),
     dependency,
     env: {
       sourceType: 'module'
+    },
+    // Pre-computed symbols: loader runtime with comprehensive helper dependencies
+    symbolData: {
+      symbols: new Map([['default', {
+        local: 'module.exports',
+        loc: null
+      }]]),
+      dependencies: helperDependencies
     }
   };
 }
@@ -628,12 +881,88 @@ function getURLRuntime(dependency, from, to, options, shardingConfig) {
   } else {
     code = `module.exports = ${getAbsoluteUrlExpr(relativePathExpr, from, shardingConfig)};`;
   }
+
+  // Collect dependencies based on the URL runtime code patterns
+  let urlRuntimeDependencies = [];
+  if (dependency.meta.webworker === true && !from.env.isLibrary) {
+    // Web worker runtime requires get-worker-url helper
+    urlRuntimeDependencies.push({
+      specifier: './helpers/get-worker-url',
+      symbols: new Map([['default', {
+        local: 'workerURL',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+    if (!(from.env.outputFormat === 'esmodule' && from.env.supports('import-meta-url'))) {
+      // Also requires bundle-url helper in non-ESM environments
+      urlRuntimeDependencies.push({
+        specifier: './helpers/bundle-url',
+        symbols: new Map([['getBundleURL', {
+          local: 'getBundleURL',
+          loc: null,
+          isWeak: false
+        }], ['getOrigin', {
+          local: 'getOrigin',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['getBundleURL', 'getOrigin'])
+      });
+
+      // Domain sharding if configured
+      if (shardingConfig) {
+        urlRuntimeDependencies.push({
+          specifier: '@atlaspack/domain-sharding',
+          symbols: new Map([['shardUrl', {
+            local: 'shardUrl',
+            loc: null,
+            isWeak: false
+          }]]),
+          usedSymbols: new Set(['shardUrl'])
+        });
+      }
+    }
+  } else {
+    // Regular URL runtime may use bundle-url helper
+    if (!(from.env.outputFormat === 'esmodule' && from.env.supports('import-meta-url')) && !(from.env.outputFormat === 'commonjs')) {
+      urlRuntimeDependencies.push({
+        specifier: './helpers/bundle-url',
+        symbols: new Map([['getBundleURL', {
+          local: 'getBundleURL',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['getBundleURL'])
+      });
+      if (shardingConfig) {
+        urlRuntimeDependencies.push({
+          specifier: '@atlaspack/domain-sharding',
+          symbols: new Map([['shardUrl', {
+            local: 'shardUrl',
+            loc: null,
+            isWeak: false
+          }]]),
+          usedSymbols: new Set(['shardUrl'])
+        });
+      }
+    }
+  }
   return {
     filePath: __filename,
     code,
     dependency,
     env: {
       sourceType: 'module'
+    },
+    // Pre-computed symbols: URL runtime with helper dependencies
+    symbolData: {
+      symbols: new Map([['default', {
+        local: 'module.exports',
+        loc: null
+      }]]),
+      dependencies: urlRuntimeDependencies
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/runtime-js",
-  "version": "2.19.9",
+  "version": "2.20.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -19,9 +19,9 @@
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/domain-sharding": "2.14.4",
     "@atlaspack/feature-flags": "2.27.3",
-    "@atlaspack/plugin": "2.14.42",
-    "@atlaspack/utils": "3.2.3",
-    "@atlaspack/types-internal": "2.21.3",
+    "@atlaspack/plugin": "2.14.43",
+    "@atlaspack/utils": "3.2.4",
+    "@atlaspack/types-internal": "2.22.0",
     "nullthrows": "^1.1.1"
   },
   "type": "commonjs",