esm: link modules synchronously when no async loader hooks are used · nodejs/node@2fafe4c

debug = fn;

});

const { isPromise } = require('internal/util/types');

/**

* @typedef {import('./hooks.js').HooksProxy} HooksProxy

* @typedef {import('./module_job.js').ModuleJobBase} ModuleJobBase

/**

* Load a module and translate it into a ModuleWrap for ordinary imported ESM.

* This is run asynchronously.

* This may be run asynchronously if there are asynchronous module loader hooks registered.

* @param {string} url URL of the module to be translated.

* @param {object} loadContext See {@link load}

* @param {boolean} isMain Whether the module to be translated is the entry point.

* @returns {Promise<ModuleWrap>}

* @returns {Promise<ModuleWrap>|ModuleWrap}

*/

async loadAndTranslate(url, loadContext, isMain) {

const { format, source } = await this.load(url, loadContext);

return this.#translate(url, format, source, isMain);

loadAndTranslate(url, loadContext, isMain) {

const maybePromise = this.load(url, loadContext);

const afterLoad = ({ format, source }) => {

return this.#translate(url, format, source, isMain);

};

if (isPromise(maybePromise)) {

return maybePromise.then(afterLoad);

}

return afterLoad(maybePromise);

}

/**

},

} = internalBinding('util');

const { decorateErrorStack, kEmptyObject } = require('internal/util');

const { isPromise } = require('internal/util/types');

const {

getSourceMapsSupport,

} = require('internal/source_map/source_map_cache');

this.#loader = loader;

// Expose the promise to the ModuleWrap directly for linking below.

if (isForRequireInImportedCJS) {

this.module = moduleOrModulePromise;

assert(this.module instanceof ModuleWrap);

this.modulePromise = PromiseResolve(this.module);

} else {

if (isPromise(moduleOrModulePromise)) {

this.modulePromise = moduleOrModulePromise;

} else {

this.module = moduleOrModulePromise;

this.modulePromise = PromiseResolve(moduleOrModulePromise);

}

if (this.phase === kEvaluationPhase) {

await assert.rejects(

() => import(file),

(e) => {

assert.strictEqual(error, e);

// The module may be compiled again and a new SyntaxError would be thrown but

// with the same content.

assert.deepStrictEqual(error, e);

return true;

}

);

await rejects(

import(jsModuleDataUrl, { with: { type: 'json', other: 'unsupported' } }),

{ code: 'ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE' }

{ code: 'ERR_IMPORT_ATTRIBUTE_UNSUPPORTED' }

);

await rejects(

await rejects(

import(jsonModuleDataUrl, { with: { foo: 'bar' } }),

{ code: 'ERR_IMPORT_ATTRIBUTE_MISSING' }

{ code: 'ERR_IMPORT_ATTRIBUTE_UNSUPPORTED' }

);

await rejects(

await rejects(

import(jsModuleDataUrl, { with: { type: 'json', other: 'unsupported' } }),

{ code: 'ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE' }

{ code: 'ERR_IMPORT_ATTRIBUTE_UNSUPPORTED' }

);

await rejects(

await rejects(

import(jsonModuleDataUrl, { with: { foo: 'bar' } }),

{ code: 'ERR_IMPORT_ATTRIBUTE_MISSING' }

{ code: 'ERR_IMPORT_ATTRIBUTE_UNSUPPORTED' }

);

await rejects(