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
sourceimpl JsRuntime
impl JsRuntime
sourcepub fn new(options: RuntimeOptions) -> Self
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) -> &mut Box<JsRuntimeInspector>
pub fn handle_scope(&mut self) -> HandleScope<'_>
sourcepub fn sync_ops_cache(&mut self)
pub fn sync_ops_cache(&mut self)
Ensures core.js has the latest op-name to op-id mappings
sourcepub fn op_state(&mut self) -> Rc<RefCell<OpState>>
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.
sourcepub fn execute_script(
&mut self,
name: &str,
source_code: &str
) -> Result<Global<Value>, Error>
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 be downcast to a type that exposes additional information
about the V8 exception. By default this type is JsError
, however it may
be a different type if RuntimeOptions::js_error_create_fn
has been set.
sourcepub fn snapshot(&mut self) -> StartupData
pub fn snapshot(&mut self) -> StartupData
Takes a snapshot. The isolate should have been created with will_snapshot set to true.
Error
can be downcast to a type that exposes additional information
about the V8 exception. By default this type is JsError
, however it may
be a different type if RuntimeOptions::js_error_create_fn
has been set.
sourcepub fn register_op<F>(&mut self, name: &str, op_fn: F) -> OpId where
F: Fn(Rc<RefCell<OpState>>, OpPayload<'_, '_, '_>) -> Op + 'static,
pub fn register_op<F>(&mut self, name: &str, op_fn: F) -> OpId where
F: Fn(Rc<RefCell<OpState>>, OpPayload<'_, '_, '_>) -> Op + 'static,
Registers an op that can be called from JavaScript.
The op mechanism allows to expose Rust functions to the JS runtime,
which can be called using the provided name
.
This function provides byte-level bindings. To pass data via JSON, the
following functions can be passed as an argument for op_fn
:
sourcepub fn add_near_heap_limit_callback<C>(&mut self, cb: C) where
C: FnMut(usize, usize) -> usize + 'static,
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>>
sourcepub async fn resolve_value(
&mut self,
global: Global<Value>
) -> 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.
sourcepub async fn run_event_loop(
&mut self,
wait_for_inspector: bool
) -> Result<(), Error>
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)
sourceimpl JsRuntime
impl JsRuntime
sourcepub fn mod_evaluate(&mut self, id: ModuleId) -> Receiver<Result<(), Error>>
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 run_event_loop()
to drive module
evaluation future.
Error
can be downcast to a type that exposes additional information
about the V8 exception. By default this type is JsError
, however it may
be a different type if RuntimeOptions::js_error_create_fn
has been set.
This function panics if module has not been instantiated.
sourcepub async fn load_main_module(
&mut self,
specifier: &ModuleSpecifier,
code: Option<String>
) -> Result<ModuleId, Error>
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.
sourcepub async fn load_side_module(
&mut self,
specifier: &ModuleSpecifier,
code: Option<String>
) -> Result<ModuleId, Error>
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
Auto Trait Implementations
impl !RefUnwindSafe for JsRuntime
impl !Send for JsRuntime
impl !Sync for JsRuntime
impl Unpin for JsRuntime
impl !UnwindSafe for JsRuntime
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more