module: add __esModule to require()'d ESM · nodejs/node@f9dc1ea

}

}

// This v8::Module::ResolveModuleCallback simply links `import 'original'`

// to the env->temporary_required_module_facade_original() which is stashed

// right before this callback is called and will be restored as soon as

// v8::Module::Instantiate() returns.

MaybeLocal<Module> LinkRequireFacadeWithOriginal(

Local<Context> context,

Local<String> specifier,

Local<FixedArray> import_attributes,

Local<Module> referrer) {

Environment* env = Environment::GetCurrent(context);

Isolate* isolate = context->GetIsolate();

CHECK(specifier->Equals(context, env->original_string()).ToChecked());

CHECK(!env->temporary_required_module_facade_original.IsEmpty());

return env->temporary_required_module_facade_original.Get(isolate);

}

// Wraps an existing source text module with a facade that adds

// .__esModule = true to the exports.

// See env->required_module_facade_source_string() for the source.

void ModuleWrap::CreateRequiredModuleFacade(

const FunctionCallbackInfo<Value>& args) {

Isolate* isolate = args.GetIsolate();

Local<Context> context = isolate->GetCurrentContext();

Environment* env = Environment::GetCurrent(context);

CHECK(args[0]->IsObject()); // original module

Local<Object> wrap = args[0].As<Object>();

ModuleWrap* original;

ASSIGN_OR_RETURN_UNWRAP(&original, wrap);

// Use the same facade source and URL to hit the compilation cache.

ScriptOrigin origin(isolate,

env->required_module_facade_url_string(),

0, // line offset

0, // column offset

true, // is cross origin

-1, // script id

Local<Value>(), // source map URL

false, // is opaque (?)

false, // is WASM

true); // is ES Module

ScriptCompiler::Source source(env->required_module_facade_source_string(),

origin);

// The module facade instantiation simply links `import 'original'` in the

// facade with the original module and should never fail.

Local<Module> facade =

ScriptCompiler::CompileModule(isolate, &source).ToLocalChecked();

// Stash the original module in temporary_required_module_facade_original

// for the LinkRequireFacadeWithOriginal() callback to pick it up.

CHECK(env->temporary_required_module_facade_original.IsEmpty());

env->temporary_required_module_facade_original.Reset(

isolate, original->module_.Get(isolate));

CHECK(facade->InstantiateModule(context, LinkRequireFacadeWithOriginal)

.IsJust());

env->temporary_required_module_facade_original.Reset();

// The evaluation of the facade is synchronous.

Local<Value> evaluated = facade->Evaluate(context).ToLocalChecked();

CHECK(evaluated->IsPromise());

CHECK_EQ(evaluated.As<Promise>()->State(), Promise::PromiseState::kFulfilled);

args.GetReturnValue().Set(facade->GetModuleNamespace());

}

void ModuleWrap::CreatePerIsolateProperties(IsolateData* isolate_data,

Local<ObjectTemplate> target) {

Isolate* isolate = isolate_data->isolate();

target,

"setInitializeImportMetaObjectCallback",

SetInitializeImportMetaObjectCallback);

SetMethod(isolate,

target,

"createRequiredModuleFacade",

CreateRequiredModuleFacade);

}

void ModuleWrap::CreatePerContextProperties(Local<Object> target,

registry->Register(GetStatus);

registry->Register(GetError);

registry->Register(CreateRequiredModuleFacade);

registry->Register(SetImportModuleDynamicallyCallback);

registry->Register(SetInitializeImportMetaObjectCallback);

}