module: centralize SourceTextModule compilation for builtin loader · nodejs/node@4dae68c

},

} = internalBinding('util');

const {

source_text_module_default_hdo,

vm_dynamic_import_default_internal,

vm_dynamic_import_main_context_default,

vm_dynamic_import_missing_flag,

vm_dynamic_import_no_callback,

} = internalBinding('symbols');

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

const {

maybeCacheSourceMap,

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

const {

ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG,

ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING,

moduleRegistries.set(idSymbol, registry);

}

/**

* Proxy the import meta handling to the default loader for source text modules.

* @param {Record<string, string | Function>} meta - The import.meta object to initialize.

* @param {ModuleWrap} wrap - The ModuleWrap of the SourceTextModule where `import.meta` is referenced.

*/

function defaultInitializeImportMetaForModule(meta, wrap) {

const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();

return cascadedLoader.importMetaInitialize(meta, { url: wrap.url });

}

/**

* Defines the `import.meta` object for a given module.

* @param {symbol} symbol - Reference to the module.

* @param {Record<string, string | Function>} meta - The import.meta object to initialize.

* @param {ModuleWrap} wrap - The ModuleWrap of the SourceTextModule where `import.meta` is referenced.

*/

function initializeImportMetaObject(symbol, meta) {

if (moduleRegistries.has(symbol)) {

const { initializeImportMeta, callbackReferrer } = moduleRegistries.get(symbol);

if (initializeImportMeta !== undefined) {

meta = initializeImportMeta(meta, callbackReferrer);

}

function initializeImportMetaObject(symbol, meta, wrap) {

if (symbol === source_text_module_default_hdo) {

defaultInitializeImportMetaForModule(meta, wrap);

return;

}

const data = moduleRegistries.get(symbol);

assert(data, `import.meta registry not found for ${wrap.url}`);

const { initializeImportMeta, callbackReferrer } = data;

if (initializeImportMeta !== undefined) {

meta = initializeImportMeta(meta, callbackReferrer);

}

}

/**

* Proxy the dynamic import to the default loader.

* Proxy the dynamic import handling to the default loader for source text modules.

* @param {string} specifier - The module specifier string.

* @param {Record<string, string>} attributes - The import attributes object.

* @param {string|null|undefined} referrerName - name of the referrer.

* @returns {Promise<import('internal/modules/esm/loader.js').ModuleExports>} - The imported module object.

*/

function defaultImportModuleDynamicallyForModule(specifier, attributes, referrerName) {

const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();

return cascadedLoader.import(specifier, referrerName, attributes);

}

/**

* Proxy the dynamic import to the default loader for classic scripts.

* @param {string} specifier - The module specifier string.

* @param {Record<string, string>} attributes - The import attributes object.

* @param {string|null|undefined} referrerName - name of the referrer.

* @returns {Promise<import('internal/modules/esm/loader.js').ModuleExports>} - The imported module object.

*/

function defaultImportModuleDynamically(specifier, attributes, referrerName) {

function defaultImportModuleDynamicallyForScript(specifier, attributes, referrerName) {

const parentURL = normalizeReferrerURL(referrerName);

const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();

return cascadedLoader.import(specifier, parentURL, attributes);

// and fall back to the default loader.

if (referrerSymbol === vm_dynamic_import_main_context_default) {

emitExperimentalWarning('vm.USE_MAIN_CONTEXT_DEFAULT_LOADER');

return defaultImportModuleDynamically(specifier, attributes, referrerName);

return defaultImportModuleDynamicallyForScript(specifier, attributes, referrerName);

}

// For script compiled internally that should use the default loader to handle dynamic

// import, proxy the request to the default loader without the warning.

if (referrerSymbol === vm_dynamic_import_default_internal) {

return defaultImportModuleDynamically(specifier, attributes, referrerName);

return defaultImportModuleDynamicallyForScript(specifier, attributes, referrerName);

}

// For SourceTextModules compiled internally, proxy the request to the default loader.

if (referrerSymbol === source_text_module_default_hdo) {

return defaultImportModuleDynamicallyForModule(specifier, attributes, referrerName);

}

if (moduleRegistries.has(referrerSymbol)) {

return { __proto__: null, hooks, preloadScripts };

}

/**

* Compile a SourceTextModule for the built-in ESM loader. Register it for default

* source map and import.meta and dynamic import() handling if cascadedLoader is provided.

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

* @param {string} source Source code of the module.

* @param {typeof import('./loader.js').ModuleLoader|undefined} cascadedLoader If provided,

* register the module for default handling.

* @returns {ModuleWrap}

*/

function compileSourceTextModule(url, source, cascadedLoader) {

const hostDefinedOption = cascadedLoader ? source_text_module_default_hdo : undefined;

const wrap = new ModuleWrap(url, undefined, source, 0, 0, hostDefinedOption);

if (!cascadedLoader) {

return wrap;

}

// Cache the source map for the module if present.

if (wrap.sourceMapURL) {

maybeCacheSourceMap(url, source, null, false, undefined, wrap.sourceMapURL);

}

return wrap;

}

module.exports = {

registerModule,

initializeESM,

getConditionsSet,

loaderWorkerId: 'internal/modules/esm/worker',

forceDefaultLoader,

compileSourceTextModule,

};