Struct deno_core::JsRuntimeForSnapshot
source · pub struct JsRuntimeForSnapshot(/* private fields */);
Expand description
The runtime type used for snapshot creation.
Implementations§
source§impl JsRuntimeForSnapshot
impl JsRuntimeForSnapshot
pub fn new(options: RuntimeOptions) -> JsRuntimeForSnapshot
Methods from Deref<Target = JsRuntime>§
pub fn main_context(&self) -> Global<Context>
pub fn v8_isolate(&mut self) -> &mut OwnedIsolate
pub fn inspector(&mut self) -> Rc<RefCell<JsRuntimeInspector>>
pub fn wait_for_inspector_disconnect(&mut self)
pub fn runtime_activity_stats_factory(&self) -> RuntimeActivityStatsFactory
pub fn handle_scope(&mut self) -> HandleScope<'_>
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: &'static str,
source_code: impl IntoModuleCodeString
) -> Result<Global<Value>, Error>
pub fn execute_script( &mut self, name: &'static str, source_code: impl IntoModuleCodeString ) -> Result<Global<Value>, Error>
Executes traditional, non-ECMAScript-module JavaScript code, This code executes in the global scope by default, and it is possible to maintain local JS state and invoke this method multiple times.
name
can be a filepath or any other string, but it is required to be 7-bit ASCII, eg.
- “/some/file/path.js”
- “
” - “[native code]”
The same name
value can be used for multiple executions.
The source may be any type that implements the internal [IntoModuleCodeString
] trait, but
it is highly recommended that embedders use the ascii_str!
to generate the fastest version
of strings for v8 to handle. If the strings are not static, you may also pass a String
generated by the format!
macro.
Error
can usually be downcast to JsError
.
sourcepub fn call(
&mut self,
function: &Global<Function>
) -> impl Future<Output = Result<Global<Value>, Error>>
pub fn call( &mut self, function: &Global<Function> ) -> impl Future<Output = Result<Global<Value>, Error>>
Call a function and return a future resolving with the return value of the function. If the function returns a promise, the future will resolve only once the event loop resolves the underlying promise. If the future rejects, the future will resolve with the underlying error.
The event loop must be polled seperately for this future to resolve. If the event loop is not polled, the future will never make progress.
sourcepub fn call_with_args(
&mut self,
function: &Global<Function>,
args: &[Global<Value>]
) -> impl Future<Output = Result<Global<Value>, Error>>
pub fn call_with_args( &mut self, function: &Global<Function>, args: &[Global<Value>] ) -> impl Future<Output = Result<Global<Value>, Error>>
Call a function and returns a future resolving with the return value of the function. If the function returns a promise, the future will resolve only once the event loop resolves the underlying promise. If the future rejects, the future will resolve with the underlying error.
The event loop must be polled seperately for this future to resolve. If the event loop is not polled, the future will never make progress.
sourcepub async fn call_and_await(
&mut self,
function: &Global<Function>
) -> Result<Global<Value>, Error>
👎Deprecated: Use call
pub async fn call_and_await( &mut self, function: &Global<Function> ) -> Result<Global<Value>, Error>
Call a function. If it returns a promise, run the event loop until that
promise is settled. If the promise rejects or there is an uncaught error
in the event loop, return Err(error)
. Or return Ok(<await returned>)
.
sourcepub async fn call_with_args_and_await(
&mut self,
function: &Global<Function>,
args: &[Global<Value>]
) -> Result<Global<Value>, Error>
👎Deprecated: Use call_with_args
pub async fn call_with_args_and_await( &mut self, function: &Global<Function>, args: &[Global<Value>] ) -> Result<Global<Value>, Error>
Call a function with args. If it returns a promise, run the event loop until that
promise is settled. If the promise rejects or there is an uncaught error
in the event loop, return Err(error)
. Or return Ok(<await returned>)
.
sourcepub fn get_module_namespace(
&mut self,
module_id: ModuleId
) -> Result<Global<Object>, Error>
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.
sourcepub fn add_near_heap_limit_callback<C>(&mut self, cb: C)
pub fn add_near_heap_limit_callback<C>(&mut self, cb: C)
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 maybe_init_inspector(&mut self)
sourcepub fn resolve(
&mut self,
promise: Global<Value>
) -> impl Future<Output = Result<Global<Value>, Error>>
pub fn resolve( &mut self, promise: Global<Value> ) -> impl Future<Output = 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 resolve_value(
&mut self,
global: Global<Value>
) -> Result<Global<Value>, Error>
👎Deprecated: Use resolve
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,
poll_options: PollEventLoopOptions
) -> Result<(), Error>
pub async fn run_event_loop( &mut self, poll_options: PollEventLoopOptions ) -> 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
PollEventLoopOptions.wait_for_inspector
is set to true)
sourcepub async fn with_event_loop_promise<'fut, T, E>(
&mut self,
fut: impl Future<Output = Result<T, E>> + Unpin + 'fut,
poll_options: PollEventLoopOptions
) -> Result<T, AnyError>
pub async fn with_event_loop_promise<'fut, T, E>( &mut self, fut: impl Future<Output = Result<T, E>> + Unpin + 'fut, poll_options: PollEventLoopOptions ) -> Result<T, AnyError>
A utility function that run provided future concurrently with the event loop.
If the event loop resolves while polling the future, it return an error with the text
Promise resolution is still pending but the event loop has already resolved.
sourcepub async fn with_event_loop_future<'fut, T, E>(
&mut self,
fut: impl Future<Output = Result<T, E>> + Unpin + 'fut,
poll_options: PollEventLoopOptions
) -> Result<T, AnyError>
pub async fn with_event_loop_future<'fut, T, E>( &mut self, fut: impl Future<Output = Result<T, E>> + Unpin + 'fut, poll_options: PollEventLoopOptions ) -> Result<T, AnyError>
A utility function that run provided future concurrently with the event loop.
If the event loop resolves while polling the future, it will continue to be polled, regardless of whether it returned an error or success.
Useful for interacting with local inspector session.
sourcepub fn poll_event_loop(
&mut self,
cx: &mut Context<'_>,
poll_options: PollEventLoopOptions
) -> Poll<Result<(), Error>>
pub fn poll_event_loop( &mut self, cx: &mut Context<'_>, poll_options: PollEventLoopOptions ) -> Poll<Result<(), Error>>
Runs a single tick of event loop
If PollEventLoopOptions.wait_for_inspector
is set to true, the event
loop will return Poll::Pending
if there are active inspector sessions.
sourcepub fn mod_evaluate(
&mut self,
id: ModuleId
) -> impl Future<Output = Result<(), Error>>
pub fn mod_evaluate( &mut self, id: ModuleId ) -> impl Future<Output = Result<(), Error>>
Evaluates an already instantiated ES module.
Returns a future that resolves when module promise resolves.
Implementors must manually call JsRuntime::run_event_loop
to drive
module evaluation future.
Modules with top-level await are treated like promises, so a throw
in the top-level
block of a module is treated as an unhandled rejection. These rejections are provided to
the unhandled promise rejection handler, which has the opportunity to pass them off to
error-handling code. If those rejections are not handled (indicated by a false
return
from that unhandled promise rejection handler), then the runtime will terminate.
The future provided by mod_evaluate
will only return errors in the case where
the runtime is shutdown and no longer available to provide unhandled rejection
information.
This function panics if module has not been instantiated.
sourcepub async fn load_main_es_module_from_code(
&mut self,
specifier: &ModuleSpecifier,
code: impl IntoModuleCodeString
) -> Result<ModuleId, Error>
pub async fn load_main_es_module_from_code( &mut self, specifier: &ModuleSpecifier, code: impl IntoModuleCodeString ) -> 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.
The source may be any type that implements the internal [IntoModuleCodeString
] trait, but
it is highly recommended that embedders use the ascii_str!
to generate the fastest version
of strings for v8 to handle. If the strings are not static, you may also pass a String
generated by the format!
macro.
User must call JsRuntime::mod_evaluate
with returned ModuleId
manually after load is finished.
sourcepub async fn load_main_es_module(
&mut self,
specifier: &ModuleSpecifier
) -> Result<ModuleId, Error>
pub async fn load_main_es_module( &mut self, specifier: &ModuleSpecifier ) -> Result<ModuleId, Error>
Asynchronously load specified module and all of its dependencies, retrieving
the module from the supplied ModuleLoader
.
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_es_module_from_code(
&mut self,
specifier: &ModuleSpecifier,
code: impl IntoModuleCodeString
) -> Result<ModuleId, Error>
pub async fn load_side_es_module_from_code( &mut self, specifier: &ModuleSpecifier, code: impl IntoModuleCodeString ) -> Result<ModuleId, Error>
Asynchronously load specified ES module and all of its dependencies from the provided source.
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).
The source may be any type that implements the internal [IntoModuleCodeString
] trait, but
it is highly recommended that embedders use the ascii_str!
to generate the fastest version
of strings for v8 to handle. If the strings are not static, you may also pass a String
generated by the format!
macro.
User must call JsRuntime::mod_evaluate
with returned ModuleId
manually after load is finished.
sourcepub async fn load_side_es_module(
&mut self,
specifier: &ModuleSpecifier
) -> Result<ModuleId, Error>
pub async fn load_side_es_module( &mut self, specifier: &ModuleSpecifier ) -> Result<ModuleId, Error>
Asynchronously load specified ES module and all of its dependencies, retrieving
the module from the supplied ModuleLoader
.
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.
sourcepub fn lazy_load_es_module_with_code(
&mut self,
specifier: impl IntoModuleName,
code: impl IntoModuleCodeString
) -> Result<Global<Value>, Error>
pub fn lazy_load_es_module_with_code( &mut self, specifier: impl IntoModuleName, code: impl IntoModuleCodeString ) -> Result<Global<Value>, Error>
Load and evaluate an ES module provided the specifier and source code.
The module should not have Top-Level Await (that is, it should be possible to evaluate it synchronously).
It is caller’s responsibility to ensure that not duplicate specifiers are passed to this method.