rename the function init, run it from main/ files

lib/internal/main/check_syntax.js

@@ -52,7 +52,8 @@ function loadESMIfNeeded(cb) {
   const hasModulePreImport = getOptionValue('--import').length > 0;
 
   if (hasModulePreImport) {
-    const { loadESM } = require('internal/process/esm_loader');
+    const { loadESM, init } = require('internal/process/esm_loader');
+    init();
     loadESM(cb);
     return;
   }

lib/internal/main/eval_stdin.js

@@ -18,19 +18,23 @@ const {
 prepareMainThreadExecution();
 markBootstrapComplete();
 
+
 readStdin((code) => {
   // This is necessary for fork() and CJS module compilation.
   // TODO(joyeecheung): pass this with something really internal.
   process._eval = code;
 
   const print = getOptionValue('--print');
   const loadESM = getOptionValue('--import').length > 0;
-  if (getOptionValue('--input-type') === 'module')
+  if (getOptionValue('--input-type') === 'module') {
+    require('internal/process/esm_loader').init();
     evalModule(code, print);
-  else
+  } else {
     evalScript('[stdin]',
                code,
                getOptionValue('--inspect-brk'),
                print,
                loadESM);
+    require('internal/process/esm_loader').initIfNeeded();
+  }
 });

lib/internal/main/eval_string.js

@@ -25,9 +25,11 @@ markBootstrapComplete();
 const source = getOptionValue('--eval');
 const print = getOptionValue('--print');
 const loadESM = getOptionValue('--import').length > 0;
-if (getOptionValue('--input-type') === 'module')
+const esmLoader = require('internal/process/esm_loader');
+if (getOptionValue('--input-type') === 'module') {
+  esmLoader.init();
   evalModule(source, print);
-else {
+} else {
   // For backward compatibility, we want the identifier crypto to be the
   // `node:crypto` module rather than WebCrypto.
   const isUsingCryptoIdentifier =
@@ -54,4 +56,5 @@ else {
              getOptionValue('--inspect-brk'),
              print,
              loadESM);
+  esmLoader.initIfNeeded();
 }

lib/internal/main/inspect.js

@@ -11,6 +11,7 @@ prepareMainThreadExecution();
 
 
 markBootstrapComplete();
+require('internal/process/esm_loader').init();
 
 // Start the debugger agent.
 process.nextTick(() => {

lib/internal/main/repl.js

@@ -36,6 +36,7 @@ if (process.env.NODE_REPL_EXTERNAL_MODULE) {
   }
 
   const esmLoader = require('internal/process/esm_loader');
+  esmLoader.init();
   esmLoader.loadESM(() => {
     console.log(`Welcome to Node.js ${process.version}.\n` +
       'Type ".help" for more information.');

lib/internal/main/run_main_module.js

@@ -11,6 +11,8 @@ prepareMainThreadExecution(true);
 
 markBootstrapComplete();
 
+require('internal/process/esm_loader').init();
+
 // Necessary to reset RegExp statics before user code runs.
 RegExpPrototypeExec(/^/, '');
 

lib/internal/main/test_runner.js

@@ -22,6 +22,8 @@ if (isUsingInspector()) {
   inspectPort = process.debugPort;
 }
 
+require('internal/process/esm_loader').init();
+
 run({ concurrency, inspectPort, watch: getOptionValue('--watch'), setup: setupTestReporters })
 .once('test:fail', () => {
   process.exitCode = kGenericUserError;

lib/internal/main/worker_thread.js

@@ -162,11 +162,13 @@ port.on('message', (message) => {
         });
         ArrayPrototypeSplice(process.argv, 1, 0, name);
         evalScript(name, filename);
+        require('internal/process/esm_loader').initIfNeeded();
         break;
       }
 
       case 'module': {
         const { evalModule } = require('internal/process/execution');
+        require('internal/process/esm_loader').init();
         PromisePrototypeThen(evalModule(filename), undefined, (e) => {
           workerOnGlobalUncaughtException(e, true);
         });
@@ -179,6 +181,7 @@ port.on('message', (message) => {
         // XXX: the monkey-patchability here should probably be deprecated.
         ArrayPrototypeSplice(process.argv, 1, 0, filename);
         const CJSLoader = require('internal/modules/cjs/loader');
+        require('internal/process/esm_loader').initIfNeeded();
         CJSLoader.Module.runMain(filename);
         break;
       }

lib/internal/modules/esm/utils.js

@@ -2,10 +2,7 @@
 
 const {
   ArrayIsArray,
-  ArrayPrototypePush,
   PromisePrototypeThen,
-  ReflectApply,
-  SafeMap,
   SafeSet,
   SafeWeakMap,
   ObjectFreeze,
@@ -17,7 +14,7 @@ const {
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
 const { pathToFileURL } = require('internal/url');
-const { kEmptyObject, createDeferredPromise } = require('internal/util');
+const { kEmptyObject } = require('internal/util');
 const {
   setImportModuleDynamicallyCallback,
   setInitializeImportMetaObjectCallback,
@@ -95,14 +92,6 @@ async function importModuleDynamicallyCallback(wrap, specifier, assertions) {
 }
 
 function initializeESM() {
-  const { setESMLoader } = require('internal/process/esm_loader');
-  // Minimal mock for letting `--require` work before we have any actual ESM loader.
-  setESMLoader({ __proto__: null, cjsCache: new SafeMap(), import() {
-    const { promise, resolve, reject } = createDeferredPromise();
-    ArrayPrototypePush(this.importRequests, { arguments: arguments, resolve, reject });
-    return promise;
-  }, importRequests: [] });
-
   initializeDefaultConditions();
   // Setup per-isolate callbacks that locate data or callbacks that we keep
   // track of for different ESM modules.
@@ -126,22 +115,10 @@ async function initializeHooks() {
   const hooks = new Hooks();
 
   const { DefaultModuleLoader } = require('internal/modules/esm/loader');
-  const { esmLoader, setESMLoader } = require('internal/process/esm_loader');
+  const { init } = require('internal/process/esm_loader');
   class ModuleLoader extends DefaultModuleLoader {
-    constructor() {
-      super();
-      for (const { 0: key, 1: value } of esmLoader.cjsCache) {
-        // Getting back the values from the mocked loader.
-        this.cjsCache.set(key, value);
-      }
-      for (let i = 0; i < esmLoader.importRequests.length; i++) {
-        PromisePrototypeThen(
-          ReflectApply(this.import, this, esmLoader.importRequests[i].arguments),
-          esmLoader.importRequests[i].resolve,
-          esmLoader.importRequests[i].reject,
-        );
-      }
-    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() { super(); }
 
     loaderType = 'internal';
     async #getModuleJob(specifier, parentURL, importAssertions) {
@@ -166,8 +143,6 @@ async function initializeHooks() {
   }
   const privateModuleLoader = new ModuleLoader();
 
-  setESMLoader(privateModuleLoader);
-
   const parentURL = pathToFileURL(cwd).href;
 
   for (let i = 0; i < customLoaderPaths.length; i++) {
@@ -185,6 +160,8 @@ async function initializeHooks() {
 
   const preloadScripts = hooks.initializeGlobalPreload();
 
+  init(privateModuleLoader);
+
   return { __proto__: null, hooks, preloadScripts };
 }
 

lib/internal/modules/run_main.js

@@ -47,12 +47,9 @@ function shouldUseESMLoader(mainPath) {
 }
 
 function runMainESM(mainPath) {
-  const { loadESM, setESMLoader } = require('internal/process/esm_loader');
-  const { createModuleLoader } = require('internal/modules/esm/loader');
+  const { loadESM } = require('internal/process/esm_loader');
   const { pathToFileURL } = require('internal/url');
 
-  setESMLoader(createModuleLoader(true));
-
   handleMainPromise(loadESM((esmLoader) => {
     const main = path.isAbsolute(mainPath) ?
       pathToFileURL(mainPath).href : mainPath;

lib/internal/process/esm_loader.js

@@ -1,16 +1,56 @@
 'use strict';
 
+const {
+  ArrayPrototypePush,
+  PromisePrototypeThen,
+  ReflectApply,
+  SafeMap,
+} = primordials;
+
+const assert = require('internal/assert');
+const { createModuleLoader } = require('internal/modules/esm/loader');
 const { getOptionValue } = require('internal/options');
 const {
   hasUncaughtExceptionCaptureCallback,
 } = require('internal/process/execution');
 const { pathToFileURL } = require('internal/url');
-const { kEmptyObject } = require('internal/util');
+const { kEmptyObject, createDeferredPromise } = require('internal/util');
+
+let esmLoader;
+let init = false;
 
 module.exports = {
-  esmLoader: undefined,
-  setESMLoader(loader) {
-    module.exports.esmLoader = loader;
+  get esmLoader() {
+    return esmLoader ??= { __proto__: null, cjsCache: new SafeMap(), import() {
+      const { promise, resolve, reject } = createDeferredPromise();
+      ArrayPrototypePush(this.importRequests, { arguments: arguments, resolve, reject });
+      return promise;
+    }, importRequests: [] };
+  },
+  initIfNeeded() {
+    // TODO: we could try to avoid loading ESM loader on CJS-only codebase
+    return module.exports.init();
+  },
+  init(loader = undefined) {
+    assert(!init);
+    init = true;
+
+    loader ??= createModuleLoader(true);
+
+    if (esmLoader != null) {
+      for (const { 0: key, 1: value } of esmLoader.cjsCache) {
+        // Getting back the values from the mocked loader.
+        loader.cjsCache.set(key, value);
+      }
+      for (let i = 0; i < esmLoader.importRequests.length; i++) {
+        PromisePrototypeThen(
+          ReflectApply(loader.import, loader, esmLoader.importRequests[i].arguments),
+          esmLoader.importRequests[i].resolve,
+          esmLoader.importRequests[i].reject,
+        );
+      }
+    }
+    esmLoader = loader;
   },
   async loadESM(callback) {
     const { esmLoader } = module.exports;

lib/internal/process/execution.js

@@ -45,12 +45,8 @@ function evalModule(source, print) {
   if (print) {
     throw new ERR_EVAL_ESM_CANNOT_PRINT();
   }
-  const { loadESM, setESMLoader } = require('internal/process/esm_loader');
-  const { createModuleLoader } = require('internal/modules/esm/loader');
+  const { loadESM } = require('internal/process/esm_loader');
   const { handleMainPromise } = require('internal/modules/run_main');
-
-  setESMLoader(createModuleLoader(true));
-
   RegExpPrototypeExec(/^/, ''); // Necessary to reset RegExp statics before user code runs.
   return handleMainPromise(loadESM((loader) => loader.eval(source)));
 }
@@ -67,8 +63,10 @@ function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false) {
   module.filename = path.join(cwd, name);
   module.paths = CJSModule._nodeModulePaths(cwd);
 
+  const { handleMainPromise } = require('internal/modules/run_main');
   const asyncESM = require('internal/process/esm_loader');
   const baseUrl = pathToFileURL(module.filename).href;
+  const { loadESM } = asyncESM;
 
   const runScript = () => {
     // Create wrapper for cache entry
@@ -101,11 +99,6 @@ function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false) {
   };
 
   if (shouldLoadESM) {
-    const { loadESM, setESMLoader } = asyncESM;
-    const { createModuleLoader } = require('internal/modules/esm/loader');
-    const { handleMainPromise } = require('internal/modules/run_main');
-
-    setESMLoader(createModuleLoader(true));
     return handleMainPromise(loadESM(runScript));
   }
   return runScript();

lib/internal/process/pre_execution.js

@@ -120,8 +120,8 @@ function prepareExecution(options) {
 }
 
 function setupUserModules() {
-  initializeCJSLoader();
   initializeESMLoader();
+  initializeCJSLoader();
   const CJSLoader = require('internal/modules/cjs/loader');
   assert(!CJSLoader.hasLoadedAnyUserCJSModule);
   loadPreloadModules();