Struct deno_core::JsRuntime

source ·
pub struct JsRuntime { /* private fields */ }
Expand description

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§

Only constructor, configuration is done through options.

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”.

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

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.

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

Error can usually be downcast to JsError.

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.

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.

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.

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)

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.

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.

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.

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§

Executes the destructor for this type. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.