Struct deno_core::EsIsolate

pub struct EsIsolate {
    pub modules: Modules,
    // some fields omitted
}

More specialized version of Isolate that provides loading and execution of ES Modules.

Creating EsIsolate requires to pass loader argument that implements Loader trait - that way actual resolution and loading of modules can be customized by the implementor.

Fields

modules: Modules

Methods

impl EsIsolate

pub fn new(
    loader: Rc<dyn Loader + Unpin>,
    startup_data: StartupData,
    will_snapshot: bool
) -> Box<Self>

pub fn mod_evaluate_dyn_import(&mut self, id: ModuleId) -> Result<(), ErrBox>

TODO(bartlomieju): copy-pasta to avoid problem with global handle attached to ErrBox

pub fn mod_evaluate(&mut self, id: ModuleId) -> Result<(), ErrBox>

Evaluates an already instantiated ES module.

ErrBox can be downcast to a type that exposes additional information about the V8 exception. By default this type is CoreJSError, however it may be a different type if Isolate::set_js_error_create() has been used.

pub fn module_resolve_cb(
    &mut self,
    specifier: &str,
    referrer_id: ModuleId
) -> ModuleId

pub fn dyn_import_cb(
    &mut self,
    specifier: &str,
    referrer: &str,
    id: DynImportId
)

pub async fn load_module<'_, '_>(
    &'_ mut self,
    specifier: &'_ ModuleSpecifier,
    code: Option<String>
) -> Result<ModuleId, ErrBox>

Asynchronously load specified module and all of it's dependencies

User must call Isolate::mod_evaluate with returned ModuleId manually after load is finished.

Methods from Deref<Target = Isolate>

pub fn exception_to_err_result<'a, T>(
    &mut self,
    scope: &mut impl ToLocal<'a> + InContext,
    exception: Local<Value>
) -> Result<T, ErrBox>

pub fn handle_exception<'a>(
    &mut self,
    scope: &mut impl ToLocal<'a> + InContext,
    exception: Local<Value>
)

pub fn encode_message_as_json<'a>(
    &mut self,
    scope: &mut impl ToLocal<'a> + InContext,
    message: Local<Message>
) -> String

pub fn register_op<F>(&self, name: &str, op: F) -> OpId where
    F: Fn(&[u8], Option<ZeroCopyBuf>) -> CoreOp + 'static, 

Defines the how Deno.core.dispatch() acts. Called whenever Deno.core.dispatch() is called in JavaScript. zero_copy_buf corresponds to the second argument of Deno.core.dispatch().

Requires runtime to explicitly ask for op ids before using any of the ops.

pub fn set_js_error_create<F>(&mut self, f: F) where
    F: Fn(V8Exception) -> ErrBox + 'static, 

Allows a callback to be set whenever a V8 exception is made. This allows the caller to wrap the V8Exception into an error. By default this callback is set to CoreJSError::from_v8_exception.

pub fn shared_isolate_handle(&mut self) -> IsolateHandle

Get a thread safe handle on the isolate.

pub fn dispatch_op<'s>(
    &mut self,
    scope: &mut impl ToLocal<'s> + InContext,
    op_id: OpId,
    control_buf: &[u8],
    zero_copy_buf: Option<ZeroCopyBuf>
) -> Option<(OpId, Box<[u8]>)>

pub fn execute(
    &mut self,
    js_filename: &str,
    js_source: &str
) -> Result<(), ErrBox>

Executes traditional JavaScript code (traditional = not ES modules)

ErrBox can be downcast to a type that exposes additional information about the V8 exception. By default this type is CoreJSError, however it may be a different type if Isolate::set_js_error_create() has been used.

pub fn snapshot(&mut self) -> Result<OwnedStartupData, ErrBox>

Takes a snapshot. The isolate should have been created with will_snapshot set to true.

ErrBox can be downcast to a type that exposes additional information about the V8 exception. By default this type is CoreJSError, however it may be a different type if Isolate::set_js_error_create() has been used.

Trait Implementations

impl Deref for EsIsolate

type Target = Isolate

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for EsIsolate

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for EsIsolate

fn drop(&mut self)

Executes the destructor for this type.

impl Future for EsIsolate

type Output = Result<(), ErrBox>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl Send for EsIsolate