Struct deno_core::JsRuntime

pub struct JsRuntime { /* private fields */ }

A single execution context of JavaScript. Corresponds roughly to the “Web Worker” concept in the DOM. A JsRuntime is a Future that can be used with an event loop (Tokio, async_std). The JsRuntime future completes when there is an error or when all pending ops have completed.

Pending ops are created in JavaScript by calling Deno.core.opAsync(), and in Rust by implementing an async function that takes a serde::Deserialize “control argument” and an optional zero copy buffer, each async Op is tied to a Promise in JavaScript.

Implementations

impl JsRuntime

pub fn new(options: RuntimeOptions) -> Self

Only constructor, configuration is done through options.

pub fn global_context(&mut self) -> Global<Context>

pub fn v8_isolate(&mut self) -> &mut OwnedIsolate

pub fn inspector(&mut self) -> Rc<RefCell<JsRuntimeInspector>>

pub fn global_realm(&mut self) -> JsRealm

pub fn create_realm(&mut self) -> Result<JsRealm, Error>

Creates a new realm (V8 context) in this JS execution context, pre-initialized with all of the extensions that were passed in RuntimeOptions::extensions when the JsRuntime was constructed.

If the JsRuntime was not built from a snapshot (see RuntimeOptions::startup_snapshot), the JS code for the extensions will be run in the call to this method. In contrast, if there is a snapshot, that will be used instead, and the extensions’ initialization will come “for free”.

pub fn handle_scope(&mut self) -> HandleScope<'_>

pub fn grab_global<'s, T>(
    scope: &mut HandleScope<'s>,
    path: &str
) -> Option<Local<'s, T>>where
    Local<'s, T>: TryFrom<Local<'s, Value>, Error = DataError>,

pub fn op_state(&mut self) -> Rc<RefCell<OpState>>

Returns the runtime’s op state, which can be used to maintain ops and access resources between op calls.

pub fn execute_script(
    &mut self,
    name: &str,
    source_code: &str
) -> Result<Global<Value>, Error>

Executes traditional JavaScript code (traditional = not ES modules).

The execution takes place on the current global context, so it is possible to maintain local JS state and invoke this method multiple times.

name can be a filepath or any other string, eg.

• “/some/file/path.js”
• “”
• “[native code]”

The same name value can be used for multiple executions.

Error can usually be downcast to JsError.

pub fn snapshot(self) -> StartupData

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

Error can usually be downcast to JsError.

pub fn get_module_namespace(
    &mut self,
    module_id: ModuleId
) -> Result<Global<Object>, Error>

Returns the namespace object of a module.

This is only available after module evaluation has completed. This function panics if module has not been instantiated.

pub fn add_near_heap_limit_callback<C>(&mut self, cb: C)where
    C: FnMut(usize, usize) -> usize + 'static,

Registers a callback on the isolate when the memory limits are approached. Use this to prevent V8 from crashing the process when reaching the limit.

Calls the closure with the current heap limit and the initial heap limit. The return value of the closure is set as the new limit.

pub fn remove_near_heap_limit_callback(&mut self, heap_limit: usize)

pub fn poll_value(
    &mut self,
    global: &Global<Value>,
    cx: &mut Context<'_>
) -> Poll<Result<Global<Value>, Error>>

pub async fn resolve_value(
    &mut self,
    global: Global<Value>
) -> Result<Global<Value>, Error>

Waits for the given value to resolve while polling the event loop.

This future resolves when either the value is resolved or the event loop runs to completion.

pub async fn run_event_loop(
    &mut self,
    wait_for_inspector: bool
) -> Result<(), Error>

Runs event loop to completion

This future resolves when:

• there are no more pending dynamic imports
• there are no more pending ops
• there are no more active inspector sessions (only if wait_for_inspector is set to true)

pub fn poll_event_loop(
    &mut self,
    cx: &mut Context<'_>,
    wait_for_inspector: bool
) -> Poll<Result<(), Error>>

Runs a single tick of event loop

If wait_for_inspector is set to true event loop will return Poll::Pending if there are active inspector sessions.

impl JsRuntime

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

Evaluates an already instantiated ES module.

Returns a receiver handle that resolves when module promise resolves. Implementors must manually call JsRuntime::run_event_loop to drive module evaluation future.

Error can usually be downcast to JsError and should be awaited and checked after JsRuntime::run_event_loop completion.

This function panics if module has not been instantiated.

pub async fn load_main_module(
    &mut self,
    specifier: &ModuleSpecifier,
    code: Option<String>
) -> Result<ModuleId, Error>

Asynchronously load specified module and all of its dependencies.

The module will be marked as “main”, and because of that “import.meta.main” will return true when checked inside that module.

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

pub async fn load_side_module(
    &mut self,
    specifier: &ModuleSpecifier,
    code: Option<String>
) -> Result<ModuleId, Error>

Asynchronously load specified ES module and all of its dependencies.

This method is meant to be used when loading some utility code that might be later imported by the main module (ie. an entry point module).

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

Trait Implementations

impl Drop for JsRuntime

fn drop(&mut self)

Executes the destructor for this type.