module: fix submodules loaded by require() and import() · nodejs/node@7625dc4

StringPrototypeSplit,

StringPrototypeStartsWith,

} = primordials;

let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {

debug = fn;

});

const { ModuleWrap, kEvaluated } = internalBinding('module_wrap');

);

class ModuleJobBase {

constructor(loader, url, importAttributes, moduleWrapMaybePromise, isMain, inspectBrk) {

this.loader = loader;

constructor(url, importAttributes, moduleWrapMaybePromise, isMain, inspectBrk) {

this.importAttributes = importAttributes;

this.isMain = isMain;

this.inspectBrk = inspectBrk;

/* A ModuleJob tracks the loading of a single Module, and the ModuleJobs of

* its dependencies, over time. */

class ModuleJob extends ModuleJobBase {

#loader = null;

// `loader` is the Loader instance used for loading dependencies.

constructor(loader, url, importAttributes = { __proto__: null },

moduleProvider, isMain, inspectBrk, sync = false) {

const modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);

super(loader, url, importAttributes, modulePromise, isMain, inspectBrk);

super(url, importAttributes, modulePromise, isMain, inspectBrk);

this.#loader = loader;

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

// `this.module` is also filled in below.

this.modulePromise = modulePromise;

// these `link` callbacks depending on each other.

const dependencyJobs = [];

const promises = this.module.link(async (specifier, attributes) => {

const job = await this.loader.getModuleJob(specifier, url, attributes);

const job = await this.#loader.getModuleJob(specifier, url, attributes);

debug(`async link() ${this.url} -> ${specifier}`, job);

ArrayPrototypePush(dependencyJobs, job);

return job.modulePromise;

});

async _instantiate() {

const jobsInGraph = new SafeSet();

const addJobsToDependencyGraph = async (moduleJob) => {

debug(`async addJobsToDependencyGraph() ${this.url}`, moduleJob);

if (jobsInGraph.has(moduleJob)) {

return;

}

const { 1: childSpecifier, 2: name } = RegExpPrototypeExec(

/module '(.*)' does not provide an export named '(.+)'/,

e.message);

const { url: childFileURL } = await this.loader.resolve(

const { url: childFileURL } = await this.#loader.resolve(

childSpecifier,

parentFileUrl,

kEmptyObject,

// in the import attributes and some formats require them; but we only

// care about CommonJS for the purposes of this error message.

({ format } =

await this.loader.load(childFileURL));

await this.#loader.load(childFileURL));

} catch {

// Continue regardless of error.

}

// All the steps are ensured to be synchronous and it throws on instantiating

// an asynchronous graph.

class ModuleJobSync extends ModuleJobBase {

#loader = null;

constructor(loader, url, importAttributes, moduleWrap, isMain, inspectBrk) {

super(loader, url, importAttributes, moduleWrap, isMain, inspectBrk, true);

super(url, importAttributes, moduleWrap, isMain, inspectBrk, true);

assert(this.module instanceof ModuleWrap);

this.#loader = loader;

const moduleRequests = this.module.getModuleRequestsSync();

const linked = [];

for (let i = 0; i < moduleRequests.length; ++i) {

const { 0: specifier, 1: attributes } = moduleRequests[i];

const wrap = this.loader.getModuleWrapForRequire(specifier, url, attributes);

const job = this.#loader.getModuleWrapForRequire(specifier, url, attributes);

const isLast = (i === moduleRequests.length - 1);

// TODO(joyeecheung): make the resolution callback deal with both promisified

// an raw module wraps, then we don't need to wrap it with a promise here.

this.module.cacheResolvedWrapsSync(specifier, PromiseResolve(wrap), isLast);

this.module.cacheResolvedWrapsSync(specifier, PromiseResolve(job.module), isLast);

ArrayPrototypePush(linked, job);

}

this.linked = linked;

}

get modulePromise() {

return PromiseResolve(this.module);

}

async run() {