esm: use sync loading/resolving on non-loader-hook thread · nodejs/node@3bcf86d

} = globalThis;

const {

ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED,

ERR_INTERNAL_ASSERTION,

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_RETURN_PROPERTY_VALUE,

ERR_INVALID_RETURN_VALUE,

ERR_LOADER_CHAIN_INCOMPLETE,

ERR_METHOD_NOT_IMPLEMENTED,

ERR_WORKER_UNSERIALIZABLE_ERROR,

} = require('internal/errors').codes;

const { exitCodes: { kUnsettledTopLevelAwait } } = internalBinding('errors');

const { URLParse } = require('internal/url');

const { canParse: URLCanParse } = internalBinding('url');

const { receiveMessageOnPort } = require('worker_threads');

* via `ModuleLoader.#setAsyncLoaderHooks()`.

* @typedef {object} AsyncLoaderHooks

* @property {boolean} allowImportMetaResolve Whether to allow the use of `import.meta.resolve`.

* @property {boolean} isForAsyncLoaderHookWorker Whether the instance is running on the loader hook worker thread.

* @property {(url: string, context: object, defaultLoad: Function) => Promise<LoadResult>} load

* Calling the asynchronous `load` hook asynchronously.

* @property {(url: string, context: object, defaultLoad: Function) => LoadResult} loadSync

* @property {(url: string, context: object, defaultLoad: Function) => LoadResult} [loadSync]

* Calling the asynchronous `load` hook synchronously.

* @property {(originalSpecifier: string, parentURL: string,

* importAttributes: Record<string, string>) => Promise<ResolveResult>} resolve

* Calling the asynchronous `resolve` hook asynchronously.

* @property {(originalSpecifier: string, parentURL: string,

* importAttributes: Record<string, string>) => ResolveResult} resolveSync

* importAttributes: Record<string, string>) => ResolveResult} [resolveSync]

* Calling the asynchronous `resolve` hook synchronously.

* @property {(specifier: string, parentURL: string) => any} register Register asynchronous loader hooks

* @property {() => void} waitForLoaderHookInitialization Force loading of hooks.

allowImportMetaResolve = false;

isForAsyncLoaderHookWorker = true;

/**

* Import and register custom/user-defined module loader hook(s).

* @param {string} urlOrSpecifier

};

}

resolveSync(_originalSpecifier, _parentURL, _importAttributes) {

throw new ERR_METHOD_NOT_IMPLEMENTED('resolveSync()');

}

/**

* Provide source that is understood by one of Node's translators.

*

debug('wait for signal from worker');

AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0);

const response = this.#worker.receiveMessageSync();

if (response == null || response.message.status === 'exit') { return; }

if (response == null) { return; }

if (response.message.status === 'exit') {

process.exit(response.message.body);

}

// ! This line catches initialization errors in the worker thread.

this.#unwrapMessage(response);

this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);

response = this.#worker.receiveMessageSync();

debug('got sync message from worker', { method, args, response });

} while (response == null);

debug('got sync response from worker', { method, args });

if (response.message.status === 'never-settle') {

process.exit(kUnsettledTopLevelAwait);

const error = new ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED();

error.details = { method, args };

throw error;

} else if (response.message.status === 'exit') {

process.exit(response.message.body);

}

allowImportMetaResolve = true;

isForAsyncLoaderHookWorker = false;

/**

* Instantiate a module loader that uses user-provided custom loader hooks.

*/