rename the function init, run it from main/ files

Author: aduh95

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;