constructor

vm.SyntheticModule.constructor

Not implemented in Bun

constructor SyntheticModule(

exportNames: string[],

evaluateCallback: (this: SyntheticModule) => void,

options?: SyntheticModuleOptions

): SyntheticModule;

Creates a new SyntheticModule instance.

@param exportNames

Array of names that will be exported from the module.

@param evaluateCallback

Called when the module is evaluated.

Referenced types

interface SyntheticModuleOptions

context?: Context
The contextified object as returned by the vm.createContext() method, to compile and evaluate this module in.
identifier?: string
String used in stack traces.

class SyntheticModule

This feature is only available with the --experimental-vm-modules command flag enabled.

The vm.SyntheticModule class provides the Synthetic Module Record as defined in the WebIDL specification. The purpose of synthetic modules is to provide a generic interface for exposing non-JavaScript sources to ECMAScript module graphs.

import vm from 'node:vm';

const source = '{ "a": 1 }';
const module = new vm.SyntheticModule(['default'], function() {
  const obj = JSON.parse(source);
  this.setExport('default', obj);
});

// Use `module` in linking...

context: Context
error: any
If the module.status is 'errored', this property contains the exception thrown by the module during evaluation. If the status is anything else, accessing this property will result in a thrown exception.
The value undefined cannot be used for cases where there is not a thrown exception due to possible ambiguity with throw undefined;.
Corresponds to the [[EvaluationError]] field of Cyclic Module Record s in the ECMAScript specification.
identifier: string
The identifier of the current module, as set in the constructor.
namespace: Object
The namespace object of the module. This is only available after linking (module.link()) has completed.
Corresponds to the GetModuleNamespace abstract operation in the ECMAScript specification.
status: ModuleStatus
The current status of the module. Will be one of:
'unlinked': module.link() has not yet been called.
'linking': module.link() has been called, but not all Promises returned by the linker function have been resolved yet.
'linked': The module has been linked successfully, and all of its dependencies are linked, but module.evaluate() has not yet been called.
'evaluating': The module is being evaluated through a module.evaluate() on itself or a parent module.
'evaluated': The module has been successfully evaluated.
'errored': The module has been evaluated, but an exception was thrown.
Other than 'errored', this status string corresponds to the specification's Cyclic Module Record's [[Status]] field. 'errored' corresponds to 'evaluated' in the specification, but with [[EvaluationError]] set to a value that is not undefined.
evaluate(
options?: ModuleEvaluateOptions
): Promise<void>;
Evaluate the module.
This must be called after the module has been linked; otherwise it will reject. It could be called also when the module has already been evaluated, in which case it will either do nothing if the initial evaluation ended in success (module.status is 'evaluated') or it will re-throw the exception that the initial evaluation resulted in (module.status is 'errored').
This method cannot be called while the module is being evaluated (module.status is 'evaluating').
Corresponds to the Evaluate() concrete method field of Cyclic Module Record s in the ECMAScript specification.
@returns
Fulfills with undefined upon success.
link(
linker: ModuleLinker
): Promise<void>;
Link module dependencies. This method must be called before evaluation, and can only be called once per module.
Use sourceTextModule.linkRequests(modules) and sourceTextModule.instantiate() to link modules either synchronously or asynchronously.
The function is expected to return a Module object or a Promise that eventually resolves to a Module object. The returned Module must satisfy the following two invariants:
It must belong to the same context as the parent Module.
Its status must not be 'errored'.
If the returned Module's status is 'unlinked', this method will be recursively called on the returned Module with the same provided linker function.
link() returns a Promise that will either get resolved when all linking instances resolve to a valid Module, or rejected if the linker function either throws an exception or returns an invalid Module.
The linker function roughly corresponds to the implementation-defined HostResolveImportedModule abstract operation in the ECMAScript specification, with a few key differences:
The linker function is allowed to be asynchronous while HostResolveImportedModule is synchronous.
The actual HostResolveImportedModule implementation used during module linking is one that returns the modules linked during linking. Since at that point all modules would have been fully linked already, the HostResolveImportedModule implementation is fully synchronous per specification.
Corresponds to the Link() concrete method field of Cyclic Module Record s in the ECMAScript specification.
setExport(
name: string,
value: any
): void;
This method sets the module export binding slots with the given value.
import vm from 'node:vm'; const m = new vm.SyntheticModule(['x'], () => { m.setExport('x', 1); }); await m.evaluate(); assert.strictEqual(m.namespace.x, 1);
@param name
Name of the export to set.
@param value
The value to set the export to.