Function loadCJSModuleWithSpecialRequire

lib/internal/modules/esm/translators.js:112–191

* This may be eventually removed when module.register() reaches end-of-life. * * Loads a CommonJS module via the ESM Loader sync CommonJS translator. * This translator creates its own version of the `require` function passed into CommonJS modules. * Any monkey patches applied to the CommonJS Loa

(module, source, url, filename, isMain, translateContext)

 * @param {TranslateContext} translateContext Context for the translator
 */
function loadCJSModuleWithSpecialRequire(module, source, url, filename, isMain, translateContext) {
  // Use the full URL as the V8 resource name so that any search params
  // (e.g. ?node-test-mock) are preserved in coverage reports.
  const compileResult = compileFunctionForCJSLoader(source, url, false /* is_sea_main */, false);

  const { function: compiledWrapper, sourceMapURL, sourceURL } = compileResult;
  // Cache the source map for the cjs module if present.
  if (sourceMapURL) {
    maybeCacheSourceMap(url, source, module, false, sourceURL, sourceMapURL);
  }
  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
  const __dirname = dirname(filename);
  // eslint-disable-next-line func-name-matching,func-style
  const requireFn = function require(specifier) {
    let importAttributes = kEmptyObject;
    if (!StringPrototypeStartsWith(specifier, 'node:') && !BuiltinModule.normalizeRequirableId(specifier)) {
      // TODO: do not depend on the monkey-patchable CJS loader here.
      const path = CJSModule._resolveFilename(specifier, module);
      switch (extname(path)) {
        case '.json':
          importAttributes = { __proto__: null, type: 'json' };
          break;
        case '.node':
          // If it gets here in the translators, the hooks must have already been invoked
          // in the loader. Skip them in the synthetic module evaluation step.
          return wrapModuleLoad(specifier, module, false, kShouldSkipModuleHooks);
        default:
            // fall through
      }
      specifier = `${pathToFileURL(path)}`;
    }

    // NOTE: This re-invented require() is only used on the loader-hook worker thread.
    // On the main thread, the authentic require() is used instead (fixed by #60380).
    const request = { specifier, attributes: importAttributes, phase: kEvaluationPhase, __proto__: null };
    const job = cascadedLoader.getOrCreateModuleJob(url, request, kRequireInImportedCJS);
    job.runSync();
    let mod = cjsCache.get(job.url);
    assert(job.module, `Imported CJS module ${url} failed to load module ${job.url} using require() due to race condition`);

    if (job.module.synthetic) {
      assert(mod, `Imported CJS module ${url} failed to load module ${job.url} using require() due to missed cache`);
      return mod.exports;
    }

    // The module being required is a source text module.
    if (!mod) {
      mod = cjsEmplaceModuleCacheEntry(job.url);
      cjsCache.set(job.url, mod);
    }
    // The module has been cached by the re-invented require. Update the exports object
    // from the namespace object and return the evaluated exports.
    if (!mod.loaded) {
      debug('populateCJSExportsFromESM from require(esm) in imported CJS', url, mod, job.module);
      populateCJSExportsFromESM(mod, job.module, job.module.getNamespace());
      mod.loaded = true;
    }
    return mod.exports;