esm: remove CLI flag limitation to programmatic registration

lib/internal/errors.js

@@ -1036,11 +1036,6 @@ E('ERR_ENCODING_INVALID_ENCODED_DATA', function(encoding, ret) {
 }, TypeError);
 E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported',
   RangeError);
-E('ERR_ESM_LOADER_REGISTRATION_UNAVAILABLE', 'Programmatically registering custom ESM loaders ' +
-  'currently requires at least one custom loader to have been registered via the --experimental-loader ' +
-  'flag. A no-op loader registered via CLI is sufficient (for example: `--experimental-loader ' +
-  '"data:text/javascript,"` with the necessary trailing comma). A future version of Node.js ' +
-  'will remove this requirement.', Error);
 E('ERR_EVAL_ESM_CANNOT_PRINT', '--print cannot be used with ESM input', Error);
 E('ERR_EVENT_RECURSION', 'The event "%s" is already being dispatched', Error);
 E('ERR_FALSY_VALUE_REJECTION', function(reason) {

lib/internal/modules/esm/loader.js

@@ -11,16 +11,18 @@ const {
 } = primordials;
 
 const {
-  ERR_ESM_LOADER_REGISTRATION_UNAVAILABLE,
   ERR_UNKNOWN_MODULE_FORMAT,
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
 const { pathToFileURL } = require('internal/url');
-const { emitExperimentalWarning } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
 let defaultResolve, defaultLoad, importMetaInitializer;
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
 
 function newModuleMap() {
   const ModuleMap = require('internal/modules/esm/module_map');
@@ -99,22 +101,10 @@ class DefaultModuleLoader {
     source,
     url = pathToFileURL(`${process.cwd()}/[eval${++this.evalIndex}]`).href,
   ) {
-    const evalInstance = (url) => {
-      const { ModuleWrap } = internalBinding('module_wrap');
-      const { setCallbackForWrap } = require('internal/modules/esm/utils');
-      const module = new ModuleWrap(url, undefined, source, 0, 0);
-      setCallbackForWrap(module, {
-        initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
-        importModuleDynamically: (specifier, { url }, importAssertions) => {
-          return this.import(specifier, url, importAssertions);
-        },
-      });
-
-      return module;
-    };
+    const { ModuleWrap } = internalBinding('module_wrap');
+    const moduleWrapper = new ModuleWrap(url, undefined, source, 0, 0);
     const ModuleJob = require('internal/modules/esm/module_job');
-    const job = new ModuleJob(
-      this, url, undefined, evalInstance, false, false);
+    const job = new ModuleJob(url, moduleWrapper, undefined, false, false);
     this.moduleMap.set(url, undefined, job);
     const { module } = await job.run();
 
@@ -153,9 +143,7 @@ class DefaultModuleLoader {
       this.moduleMap.set(url, undefined, job = job());
     }
 
-    if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
-    }
+    job ??= this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
 
     return job;
   }
@@ -171,26 +159,7 @@ class DefaultModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAssertions, parentURL, format) {
-    const moduleProvider = async (url, isMain) => {
-      const {
-        format: finalFormat,
-        responseURL,
-        source,
-      } = await this.load(url, {
-        format,
-        importAssertions,
-      });
-
-      const translator = getTranslators().get(finalFormat);
-
-      if (!translator) {
-        throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
-      }
-
-      return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
-    };
-
+  async #createModuleJob(url, importAssertions, parentURL, format) {
     const inspectBrk = (
       parentURL === undefined &&
       getOptionValue('--inspect-brk')
@@ -200,12 +169,28 @@ class DefaultModuleLoader {
       process.send({ 'watch:import': [url] });
     }
 
+    const {
+      format: finalFormat,
+      responseURL,
+      source,
+    } = await this.load(url, {
+      format,
+      importAssertions,
+    });
+
+    const translator = getTranslators().get(finalFormat);
+
+    if (!translator) {
+      throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
+    }
+
+    const moduleWrapper = FunctionPrototypeCall(translator, this, responseURL, source, isMain);
+
     const ModuleJob = require('internal/modules/esm/module_job');
     const job = new ModuleJob(
-      this,
       url,
+      moduleWrapper,
       importAssertions,
-      moduleProvider,
       parentURL === undefined,
       inspectBrk,
     );
@@ -285,10 +270,21 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
   /**
    * Instantiate a module loader that uses user-provided custom loader hooks.
    */
-  constructor() {
+  constructor({
+    cjsCache,
+    evalIndex,
+    moduleMap,
+  } = kEmptyObject) {
     super();
 
-    getHooksProxy();
+    if (cjsCache != null) { this.cjsCache = cjsCache; }
+    if (evalIndex != null) { this.evalIndex = evalIndex; }
+    if (moduleMap != null) { this.moduleMap = moduleMap; }
+
+    if (!hooksProxy) {
+      const { HooksProxy } = require('internal/modules/esm/hooks');
+      hooksProxy = new HooksProxy();
+    }
   }
 
   /**
@@ -357,40 +353,29 @@ let emittedExperimentalWarning = false;
  * A loader instance is used as the main entry point for loading ES modules. Currently, this is a singleton; there is
  * only one used for loading the main module and everything in its dependency graph, though separate instances of this
  * class might be instantiated as part of bootstrap for other purposes.
- * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
+ * @param {boolean} forceCustomizedLoaderInMain Ignore whether custom loader(s) have been provided
+ * via CLI and instantiate a CustomizedModuleLoader instance regardless.
  * @returns {DefaultModuleLoader | CustomizedModuleLoader}
  */
-function createModuleLoader(useCustomLoadersIfPresent = true) {
-  if (useCustomLoadersIfPresent &&
-      // Don't spawn a new worker if we're already in a worker thread created by instantiating CustomizedModuleLoader;
-      // doing so would cause an infinite loop.
-      !require('internal/modules/esm/utils').isLoaderWorker()) {
-    const userLoaderPaths = getOptionValue('--experimental-loader');
-    if (userLoaderPaths.length > 0) {
+function createModuleLoader(customizationSetup) {
+  // Don't spawn a new worker if we're already in a worker thread (doing so would cause an infinite loop).
+  if (!require('internal/modules/esm/utils').isLoaderWorker()) {
+    if (
+      customizationSetup ||
+      getOptionValue('--experimental-loader').length > 0
+    ) {
       if (!emittedExperimentalWarning) {
         emitExperimentalWarning('Custom ESM Loaders');
         emittedExperimentalWarning = true;
       }
-      return new CustomizedModuleLoader();
+      debug('instantiating CustomizedModuleLoader');
+      return new CustomizedModuleLoader(customizationSetup);
     }
   }
 
   return new DefaultModuleLoader();
 }
 
-/**
- * Get the HooksProxy instance. If it is not defined, then create a new one.
- * @returns {HooksProxy}
- */
-function getHooksProxy() {
-  if (!hooksProxy) {
-    const { HooksProxy } = require('internal/modules/esm/hooks');
-    hooksProxy = new HooksProxy();
-  }
-
-  return hooksProxy;
-}
-
 /**
  * Register a single loader programmatically.
  * @param {string} specifier
@@ -405,19 +390,19 @@ function getHooksProxy() {
  * ```
  */
 function register(specifier, parentURL = 'data:') {
-  // TODO: Remove this limitation in a follow-up before `register` is released publicly
-  if (getOptionValue('--experimental-loader').length < 1) {
-    throw new ERR_ESM_LOADER_REGISTRATION_UNAVAILABLE();
-  }
+  let moduleLoader = require('internal/process/esm_loader').esmLoader;
 
-  const moduleLoader = require('internal/process/esm_loader').esmLoader;
+  if (!(moduleLoader instanceof CustomizedModuleLoader)) {
+    debug('register called on DefaultModuleLoader; switching to CustomizedModuleLoader');
+    moduleLoader = createModuleLoader(moduleLoader);
+    require('internal/process/esm_loader').esmLoader = moduleLoader;
+  }
 
   moduleLoader.register(`${specifier}`, parentURL);
 }
 
 module.exports = {
   DefaultModuleLoader,
   createModuleLoader,
-  getHooksProxy,
   register,
 };

lib/internal/modules/esm/module_job.js

@@ -8,7 +8,6 @@ const {
   ObjectSetPrototypeOf,
   PromiseResolve,
   PromisePrototypeThen,
-  ReflectApply,
   RegExpPrototypeExec,
   RegExpPrototypeSymbolReplace,
   SafePromiseAllReturnArrayLike,
@@ -20,13 +19,17 @@ const {
 } = primordials;
 
 const { ModuleWrap } = internalBinding('module_wrap');
+const { setCallbackForWrap } = require('internal/modules/esm/utils');
 
 const { decorateErrorStack } = require('internal/util');
 const {
   getSourceMapsEnabled,
 } = require('internal/source_map/source_map_cache');
 const assert = require('internal/assert');
 const resolvedPromise = PromiseResolve();
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
 
 const noop = FunctionPrototype;
 
@@ -45,22 +48,43 @@ const isCommonJSGlobalLikeNotDefinedError = (errorMessage) =>
     (globalLike) => errorMessage === `${globalLike} is not defined`,
   );
 
-/* A ModuleJob tracks the loading of a single Module, and the ModuleJobs of
- * its dependencies, over time. */
+/**
+ * A ModuleJob tracks the loading of a single Module, and the ModuleJobs of its dependencies, over
+ * time.
+ */
 class ModuleJob {
-  // `loader` is the Loader instance used for loading dependencies.
-  // `moduleProvider` is a function
-  constructor(loader, url, importAssertions = { __proto__: null },
-              moduleProvider, isMain, inspectBrk) {
-    this.loader = loader;
+  /**
+   * Deep dependency jobs wrappers are instantiated, and module wrapper is instantiated.
+   */
+  instantiated;
+
+  module;
+
+  constructor(
+    url,
+    moduleWrapper,
+    importAssertions = { __proto__: null },
+    isMain,
+    inspectBrk,
+  ) {
     this.importAssertions = importAssertions;
     this.isMain = isMain;
     this.inspectBrk = inspectBrk;
+    this.modulePromise = moduleWrapper;
+
+    debug('new ModuleJob(%o)', { url, importAssertions, isMain, inspectBrk });
 
-    this.module = undefined;
     // Expose the promise to the ModuleWrap directly for linking below.
     // `this.module` is also filled in below.
-    this.modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
+
+    setCallbackForWrap(this.modulePromise, {
+      initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
+      importModuleDynamically: (specifier, { url }, importAssertions) => {
+        const moduleLoader = require('internal/process/esm_loader').esmLoader;
+        debug('importModuleDynamically: %o', { specifier, url, moduleLoader });
+        return moduleLoader.import(specifier, url, importAssertions);
+      },
+    });
 
     // Wait for the ModuleWrap instance being linked with all dependencies.
     const link = async () => {
@@ -73,7 +97,8 @@ class ModuleJob {
       // these `link` callbacks depending on each other.
       const dependencyJobs = [];
       const promises = this.module.link((specifier, assertions) => {
-        const job = this.loader.getModuleJob(specifier, url, assertions);
+        const moduleLoader = require('internal/process/esm_loader').esmLoader;
+        const job = moduleLoader.getModuleJob(specifier, url, assertions);
         ArrayPrototypePush(dependencyJobs, job);
         return job.modulePromise;
       });
@@ -88,16 +113,11 @@ class ModuleJob {
     // This promise is awaited later anyway, so silence
     // 'unhandled rejection' warnings.
     PromisePrototypeThen(this.linked, undefined, noop);
-
-    // instantiated == deep dependency jobs wrappers are instantiated,
-    // and module wrapper is instantiated.
-    this.instantiated = undefined;
   }
 
   instantiate() {
-    if (this.instantiated === undefined) {
-      this.instantiated = this._instantiate();
-    }
+    this.instantiated ??= this._instantiate();
+
     return this.instantiated;
   }
 
@@ -139,16 +159,16 @@ class ModuleJob {
         const { 1: childSpecifier, 2: name } = RegExpPrototypeExec(
           /module '(.*)' does not provide an export named '(.+)'/,
           e.message);
-        const { url: childFileURL } = await this.loader.resolve(
+          const moduleLoader = require('internal/process/esm_loader').esmLoader;
+        const { url: childFileURL } = await moduleLoader.resolve(
           childSpecifier, parentFileUrl,
         );
         let format;
         try {
           // This might throw for non-CommonJS modules because we aren't passing
           // in the import assertions and some formats require them; but we only
           // care about CommonJS for the purposes of this error message.
-          ({ format } =
-            await this.loader.load(childFileURL));
+          ({ format } = await moduleLoader.load(childFileURL));
         } catch {
           // Continue regardless of error.
         }

lib/internal/modules/esm/translators.js

@@ -103,22 +103,13 @@ function errPath(url) {
   return url;
 }
 
-async function importModuleDynamically(specifier, { url }, assertions) {
-  return asyncESM.esmLoader.import(specifier, url, assertions);
-}
-
 // Strategy for loading a standard JavaScript module.
 translators.set('module', async function moduleStrategy(url, source, isMain) {
   assertBufferSource(source, true, 'load');
   source = stringify(source);
   maybeCacheSourceMap(url, source);
   debug(`Translating StandardModule ${url}`);
   const module = new ModuleWrap(url, undefined, source, 0, 0);
-  const { setCallbackForWrap } = require('internal/modules/esm/utils');
-  setCallbackForWrap(module, {
-    initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
-    importModuleDynamically,
-  });
   return module;
 });