pub struct Runtime { /* private fields */ }
Expand description
A runtime instance that can be used to execute JavaScript code and interact with it.
Most runtime functions have 3 variants - blocking, async, and immediate
For example:
call_function
will block until the function is resolved and the event loop is emptycall_function_async
will return a future that resolves when the function is resolved and the event loop is emptycall_function_immediate
will return the result immediately, without resolving promises or running the event loop (Seecrate::js_value::Promise
)
Note: For multithreaded applications, you may need to call init_platform
before creating a Runtime
(See [crate::init_platform
)
Implementations§
Source§impl Runtime
impl Runtime
Sourcepub fn new(options: RuntimeOptions) -> Result<Self, Error>
pub fn new(options: RuntimeOptions) -> Result<Self, Error>
Creates a new instance of the runtime with the provided options.
§Arguments
options
- ARuntimeOptions
struct that specifies the configuration options for the runtime.
§Returns
A Result
containing either the initialized runtime instance on success (Ok
) or an error on failure (Err
).
§Example
use rustyscript::{ json_args, Runtime, RuntimeOptions, Module };
use std::time::Duration;
// Creates a runtime that will attempt to run function load() on start
// And which will time-out after 50ms
let mut runtime = Runtime::new(RuntimeOptions {
default_entrypoint: Some("load".to_string()),
timeout: Duration::from_millis(50),
..Default::default()
})?;
let module = Module::new("test.js", "
export const load = () => {
return 'Hello World!';
}
");
let module_handle = runtime.load_module(&module)?;
let value: String = runtime.call_entrypoint(&module_handle, json_args!())?;
assert_eq!("Hello World!", value);
§Errors
Can fail if the tokio runtime cannot be created,
Or if the deno runtime initialization fails (usually issues with extensions)
Sourcepub fn with_tokio_runtime(
options: RuntimeOptions,
tokio: Rc<Runtime>,
) -> Result<Self, Error>
pub fn with_tokio_runtime( options: RuntimeOptions, tokio: Rc<Runtime>, ) -> Result<Self, Error>
Creates a new instance of the runtime with the provided options and a pre-configured tokio runtime.
See Runtime::new
for more information.
§Errors
Can fail if the deno runtime initialization fails (usually issues with extensions)
Sourcepub fn with_tokio_runtime_handle(
options: RuntimeOptions,
handle: Handle,
) -> Result<Self, Error>
pub fn with_tokio_runtime_handle( options: RuntimeOptions, handle: Handle, ) -> Result<Self, Error>
Creates a new instance of the runtime with the provided options and a borrowed tokio runtime handle.
See Runtime::new
for more information.
§Errors
Can fail if the deno runtime initialization fails (usually issues with extensions)
Sourcepub fn deno_runtime(&mut self) -> &mut JsRuntime
pub fn deno_runtime(&mut self) -> &mut JsRuntime
Access the underlying deno runtime instance directly
Sourcepub fn tokio_runtime(&self) -> TokioRuntime
pub fn tokio_runtime(&self) -> TokioRuntime
Access the underlying tokio runtime used for blocking operations
Sourcepub fn heap_exhausted_token(&self) -> CancellationToken
pub fn heap_exhausted_token(&self) -> CancellationToken
Returns the heap exhausted token for the runtime
Used to detect when the runtime has run out of memory
Sourcepub fn into_tokio_runtime(self) -> TokioRuntime
pub fn into_tokio_runtime(self) -> TokioRuntime
Destroy the v8 runtime, releasing all resources
Then the internal tokio runtime will be returned
Sourcepub fn set_current_dir(
&mut self,
path: impl AsRef<Path>,
) -> Result<&Path, Error>
pub fn set_current_dir( &mut self, path: impl AsRef<Path>, ) -> Result<&Path, Error>
Set the current working directory for the runtime
This is used to resolve relative paths in the module loader
The runtime will begin with the current working directory of the process
§Errors
Can fail if the given path is not valid
Sourcepub fn current_dir(&self) -> &Path
pub fn current_dir(&self) -> &Path
Get the current working directory for the runtime
This is used to resolve relative paths in the module loader
The runtime will begin with the current working directory of the process
Sourcepub fn advance_event_loop(
&mut self,
options: PollEventLoopOptions,
) -> Result<bool, Error>
pub fn advance_event_loop( &mut self, options: PollEventLoopOptions, ) -> Result<bool, Error>
Advance the JS event loop by a single tick
See Runtime::block_on_event_loop
for fully running the event loop
Returns true if the event loop has pending work, or false if it has completed
§Arguments
options
- Options for the event loop polling, seedeno_core::PollEventLoopOptions
§Errors
Can fail if a runtime error occurs during the event loop’s execution
Sourcepub async fn advance_event_loop_async(
&mut self,
options: PollEventLoopOptions,
) -> Result<bool, Error>
pub async fn advance_event_loop_async( &mut self, options: PollEventLoopOptions, ) -> Result<bool, Error>
Advance the JS event loop by a single tick
See Runtime::await_event_loop
for fully running the event loop
Returns a future that resolves true if the event loop has pending work, or false if it has completed
§Arguments
options
- Options for the event loop polling, seedeno_core::PollEventLoopOptions
§Errors
Can fail if a runtime error occurs during the event loop’s execution
Sourcepub async fn await_event_loop(
&mut self,
options: PollEventLoopOptions,
timeout: Option<Duration>,
) -> Result<(), Error>
pub async fn await_event_loop( &mut self, options: PollEventLoopOptions, timeout: Option<Duration>, ) -> Result<(), Error>
Run the JS event loop to completion, or until a timeout is reached
Required when using the _immediate
variants of functions
§Arguments
options
- Options for the event loop polling, seedeno_core::PollEventLoopOptions
timeout
- Optional timeout for the event loop
§Errors
Can fail if a runtime error occurs during the event loop’s execution
Sourcepub fn block_on_event_loop(
&mut self,
options: PollEventLoopOptions,
timeout: Option<Duration>,
) -> Result<(), Error>
pub fn block_on_event_loop( &mut self, options: PollEventLoopOptions, timeout: Option<Duration>, ) -> Result<(), Error>
Run the JS event loop to completion, or until a timeout is reached
Required when using the _immediate
variants of functions
This is the blocking variant of Runtime::await_event_loop
§Arguments
options
- Options for the event loop polling, seedeno_core::PollEventLoopOptions
timeout
- Optional timeout for the event loop
§Errors
Can fail if a runtime error occurs during the event loop’s execution
Sourcepub fn take<T>(&mut self) -> Option<T>where
T: 'static,
pub fn take<T>(&mut self) -> Option<T>where
T: 'static,
Remove and return a value from the state, if one exists
use rustyscript::{ Runtime };
let mut runtime = Runtime::new(Default::default())?;
runtime.put("test".to_string())?;
let value: String = runtime.take().unwrap();
assert_eq!(value, "test");
Sourcepub fn put<T>(&mut self, value: T) -> Result<(), Error>where
T: 'static,
pub fn put<T>(&mut self, value: T) -> Result<(), Error>where
T: 'static,
Add a value to the state
Only one value of each type is stored - additional calls to put
overwrite the old value
§Errors
Can fail if the inner state cannot be borrowed mutably
use rustyscript::{ Runtime };
let mut runtime = Runtime::new(Default::default())?;
runtime.put("test".to_string())?;
let value: String = runtime.take().unwrap();
assert_eq!(value, "test");
Sourcepub fn register_function<F>(
&mut self,
name: &str,
callback: F,
) -> Result<(), Error>where
F: RsFunction,
pub fn register_function<F>(
&mut self,
name: &str,
callback: F,
) -> Result<(), Error>where
F: RsFunction,
Register a rust function to be callable from JS
- The
crate::sync_callback
macro can be used to simplify this process
§Errors
Since this function borrows the state, it can fail if the state cannot be borrowed mutably
use rustyscript::{ Runtime, Module, serde_json::Value };
let module = Module::new("test.js", " rustyscript.functions.foo(); ");
let mut runtime = Runtime::new(Default::default())?;
runtime.register_function("foo", |args| {
if let Some(value) = args.get(0) {
println!("called with: {}", value);
}
Ok(Value::Null)
})?;
Sourcepub fn register_async_function<F>(
&mut self,
name: &str,
callback: F,
) -> Result<(), Error>where
F: RsAsyncFunction,
pub fn register_async_function<F>(
&mut self,
name: &str,
callback: F,
) -> Result<(), Error>where
F: RsAsyncFunction,
Register a non-blocking rust function to be callable from JS
- The
crate::async_callback
macro can be used to simplify this process
§Errors
Since this function borrows the state, it can fail if the state cannot be borrowed mutably
use rustyscript::{ Runtime, Module, serde_json::Value, async_callback, Error };
let module = Module::new("test.js", " rustyscript.async_functions.add(1, 2); ");
let mut runtime = Runtime::new(Default::default())?;
runtime.register_async_function("add", async_callback!(
|a: i64, b: i64| async move {
Ok::<i64, Error>(a + b)
}
))?;
Sourcepub fn eval<T>(&mut self, expr: impl ToString) -> Result<T, Error>where
T: DeserializeOwned,
pub fn eval<T>(&mut self, expr: impl ToString) -> Result<T, Error>where
T: DeserializeOwned,
Evaluate a piece of non-ECMAScript-module JavaScript code
The expression is evaluated in the global context, so changes persist
Blocks on promise resolution, and runs the event loop to completion
Asynchronous code is supported, partially
- Top-level await is not supported
- The event loop will be run to completion after the expression is evaluated
For top-level await support, use one of:
call_function_async
call_stored_function_async
load_module_async
load_modules_async
Or any of the _immmediate
variants, paired with crate::js_value::Promise
§Arguments
expr
- A string representing the JavaScript expression to evaluate
§Returns
A Result
containing the deserialized result of the expression (T
)
or an error (Error
) if the expression cannot be evaluated or if the
result cannot be deserialized.
§Errors
Can fail if the expression cannot be evaluated, or if the result cannot be deserialized into the requested type
§Example
use rustyscript::{ Runtime, Error };
let mut runtime = Runtime::new(Default::default())?;
let value: u32 = runtime.eval("2 + 2")?;
assert_eq!(4, value);
let value: String = runtime.eval("new Promise(resolve => resolve('test'))")?;
assert_eq!("test", value);
Sourcepub async fn eval_async<T>(&mut self, expr: impl ToString) -> Result<T, Error>where
T: DeserializeOwned,
pub async fn eval_async<T>(&mut self, expr: impl ToString) -> Result<T, Error>where
T: DeserializeOwned,
Evaluate a piece of non-ECMAScript-module JavaScript code
The expression is evaluated in the global context, so changes persist
Awaits promise resolution, and runs the event loop to completion
Asynchronous code is supported, partially
- Top-level await is not supported
- The event loop will be run to completion after the expression is evaluated
For top-level await support, use one of:
call_function_async
call_stored_function_async
load_module_async
load_modules_async
Or any of the _immmediate
variants, paired with crate::js_value::Promise
§Arguments
expr
- A string representing the JavaScript expression to evaluate
§Returns
A Result
containing the deserialized result of the expression (T
)
or an error (Error
) if the expression cannot be evaluated or if the
result cannot be deserialized.
§Errors
Can fail if the expression cannot be evaluated, or if the result cannot be deserialized into the requested type
§Example
For an example, see Runtime::eval
Sourcepub async fn eval_immediate<T>(
&mut self,
expr: impl ToString,
) -> Result<T, Error>where
T: DeserializeOwned,
pub async fn eval_immediate<T>(
&mut self,
expr: impl ToString,
) -> Result<T, Error>where
T: DeserializeOwned,
Evaluate a piece of non-ECMAScript-module JavaScript code
The expression is evaluated in the global context, so changes persist
Does not await promise resolution, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop
Note that this function needs to be async because calls to setTimeout
must be evaluated from within an async runtime.
Asynchronous code is supported, partially
- Top-level await is not supported
For top-level await support, use one of:
call_function_async
call_stored_function_async
load_module_async
load_modules_async
Or any of the _immmediate
variants, paired with crate::js_value::Promise
§Arguments
expr
- A string representing the JavaScript expression to evaluate
§Returns
A Result
containing the deserialized result of the expression (T
)
or an error (Error
) if the expression cannot be evaluated or if the
result cannot be deserialized.
§Errors
Can fail if the expression cannot be evaluated, or if the result cannot be deserialized into the requested type
§Example
For an example, see Runtime::eval
Sourcepub async fn call_stored_function_async<T>(
&mut self,
module_context: Option<&ModuleHandle>,
function: &Function,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub async fn call_stored_function_async<T>(
&mut self,
module_context: Option<&ModuleHandle>,
function: &Function,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Calls a stored javascript function and deserializes its return value.
Returns a future that resolves when:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
See Runtime::call_function
for an example
Note that synchronous functions are run synchronously. Returned promises will be run asynchronously, however.
§Arguments
module_context
- Optional handle to a module providing global context for the functionfunction
- A The function objectargs
- The arguments to pass to the function
§Returns
A Result
containing the deserialized result of the function call (T
)
or an error (Error
) if there are issues with calling the function,
or if the result cannot be deserialized.
§Errors
Can fail if there are issues with calling the function, or if the result cannot be deserialized into the requested type
Sourcepub fn call_stored_function<T>(
&mut self,
module_context: Option<&ModuleHandle>,
function: &Function,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn call_stored_function<T>(
&mut self,
module_context: Option<&ModuleHandle>,
function: &Function,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Calls a stored javascript function and deserializes its return value.
Blocks until:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
See Runtime::call_function
for an example
§Arguments
module_context
- Optional handle to a module providing global context for the functionfunction
- A The function objectargs
- The arguments to pass to the function
§Returns
A Result
containing the deserialized result of the function call (T
)
or an error (Error
) if there are issues with calling the function,
or if the result cannot be deserialized.
§Errors
Can fail if there are issues with calling the function, or if the result cannot be deserialized into the requested type
Sourcepub fn call_stored_function_immediate<T>(
&mut self,
module_context: Option<&ModuleHandle>,
function: &Function,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn call_stored_function_immediate<T>(
&mut self,
module_context: Option<&ModuleHandle>,
function: &Function,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Calls a stored javascript function and deserializes its return value.
Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop
See Runtime::call_function
for an example
§Arguments
module_context
- Optional handle to a module providing global context for the functionfunction
- A The function objectargs
- The arguments to pass to the function
§Returns
A Result
containing the deserialized result of the function call (T
)
or an error (Error
) if there are issues with calling the function,
or if the result cannot be deserialized.
§Errors
Can fail if there are issues with calling the function, or if the result cannot be deserialized into the requested type
Sourcepub async fn call_function_async<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub async fn call_function_async<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Calls a javascript function within the Deno runtime by its name and deserializes its return value.
Returns a future that resolves when:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
Note that synchronous functions are run synchronously. Returned promises will be run asynchronously, however.
See Runtime::call_function
for an example
§Arguments
module_context
- Optional handle to a module to search - if None, or if the search fails, the global context is usedname
- A string representing the name of the javascript function to call.args
- The arguments to pass to the function
§Returns
A Result
containing the deserialized result of the function call (T
)
or an error (Error
) if the function cannot be found, if there are issues with
calling the function, or if the result cannot be deserialized.
§Errors
Fails if the function cannot be found, if there are issues with calling the function, Or if the result cannot be deserialized into the requested type
Sourcepub fn call_function<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn call_function<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Calls a javascript function within the Deno runtime by its name and deserializes its return value.
Blocks until:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
§Arguments
module_context
- Optional handle to a module to search - if None, or if the search fails, the global context is usedname
- A string representing the name of the javascript function to call.args
- The arguments to pass to the function
§Returns
A Result
containing the deserialized result of the function call (T
)
or an error (Error
) if the function cannot be found, if there are issues with
calling the function, or if the result cannot be deserialized.
§Errors
Fails if the function cannot be found, if there are issues with calling the function,
Or if the result cannot be deserialized into the requested type
§Example
use rustyscript::{ json_args, Runtime, Module, Error };
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "export function f() { return 2; };");
let module = runtime.load_module(&module)?;
let value: usize = runtime.call_function(Some(&module), "f", json_args!())?;
Sourcepub fn call_function_immediate<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn call_function_immediate<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Calls a javascript function within the Deno runtime by its name and deserializes its return value.
Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop
§Arguments
module_context
- Optional handle to a module to search - if None, or if the search fails, the global context is usedname
- A string representing the name of the javascript function to call.args
- The arguments to pass to the function
§Returns
A Result
containing the deserialized result of the function call (T
)
or an error (Error
) if the function cannot be found, if there are issues with
calling the function, or if the result cannot be deserialized.
§Errors
Fails if the function cannot be found, if there are issues with calling the function,
Or if the result cannot be deserialized into the requested type
§Example
use rustyscript::{ json_args, Runtime, Module, Error };
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "export function f() { return 2; };");
let module = runtime.load_module(&module)?;
let value: usize = runtime.call_function_immediate(Some(&module), "f", json_args!())?;
Sourcepub fn get_value<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn get_value<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
) -> Result<T, Error>where
T: DeserializeOwned,
Get a value from a runtime instance
Blocks until:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
§Arguments
module_context
- Optional handle to a module to search - if None, or if the search fails, the global context is usedname
- A string representing the name of the value to find
§Returns
A Result
containing the deserialized result or an error (Error
) if the value cannot be found,
Or if the result cannot be deserialized into the requested type
§Errors
Can fail if the value cannot be found, or if the result cannot be deserialized.
§Example
use rustyscript::{ Runtime, Module, Error };
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "globalThis.my_value = 2;");
let module = runtime.load_module(&module)?;
let value: usize = runtime.get_value(Some(&module), "my_value")?;
Sourcepub async fn get_value_async<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
) -> Result<T, Error>where
T: DeserializeOwned,
pub async fn get_value_async<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
) -> Result<T, Error>where
T: DeserializeOwned,
Get a value from a runtime instance
Returns a future that resolves when:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
See Runtime::get_value
for an example
§Arguments
module_context
- Optional handle to a module to search - if None, or if the search fails, the global context is usedname
- A string representing the name of the value to find
§Returns
A Result
containing the deserialized result or an error (Error
) if the value cannot be found,
Or if the result cannot be deserialized into the requested type
§Errors
Can fail if the value cannot be found, or if the result cannot be deserialized.
Sourcepub fn get_value_immediate<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn get_value_immediate<T>(
&mut self,
module_context: Option<&ModuleHandle>,
name: &str,
) -> Result<T, Error>where
T: DeserializeOwned,
Get a value from a runtime instance
Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop
§Arguments
module_context
- Optional handle to a module to search - if None, or if the search fails, the global context is usedname
- A string representing the name of the value to find
§Returns
A Result
containing the deserialized result or an error (Error
) if the value cannot be found,
Or if the result cannot be deserialized into the requested type
§Errors
Can fail if the value cannot be found, or if the result cannot be deserialized.
§Example
use rustyscript::{ Runtime, Module, Error };
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "globalThis.my_value = 2;");
let module = runtime.load_module(&module)?;
let value: usize = runtime.get_value_immediate(Some(&module), "my_value")?;
Sourcepub fn load_module(&mut self, module: &Module) -> Result<ModuleHandle, Error>
pub fn load_module(&mut self, module: &Module) -> Result<ModuleHandle, Error>
Executes the given module, and returns a handle allowing you to extract values and call functions
Blocks until the module has been executed AND the event loop has fully resolved
See Runtime::load_module_async
for a non-blocking variant, or use with async
background tasks
§Arguments
module
- AModule
object containing the module’s filename and contents.
§Returns
A Result
containing a handle for the loaded module
or an error (Error
) if there are issues with loading or executing the module
§Errors
Can fail if the module cannot be loaded, or execution fails
§Example
// Create a module with filename and contents
use rustyscript::{Runtime, Module, Error};
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
runtime.load_module(&module);
Sourcepub async fn load_module_async(
&mut self,
module: &Module,
) -> Result<ModuleHandle, Error>
pub async fn load_module_async( &mut self, module: &Module, ) -> Result<ModuleHandle, Error>
Executes the given module, and returns a handle allowing you to extract values and call functions
Returns a future that resolves to the handle for the loaded module
Makes no attempt to fully resolve the event loop - call Runtime::await_event_loop
to resolve background tasks and async listeners
§Arguments
module
- AModule
object containing the module’s filename and contents.
§Returns
A Result
containing a handle for the loaded module
or an error (Error
) if there are issues with loading or executing the module
§Errors
Can fail if the module cannot be loaded, or execution fails
See Runtime::load_module
for an example
Sourcepub fn load_modules(
&mut self,
module: &Module,
side_modules: Vec<&Module>,
) -> Result<ModuleHandle, Error>
pub fn load_modules( &mut self, module: &Module, side_modules: Vec<&Module>, ) -> Result<ModuleHandle, Error>
Executes the given module, and returns a handle allowing you to extract values and call functions.
Blocks until all modules have been executed AND the event loop has fully resolved
See Runtime::load_module_async
for a non-blocking variant, or use with async
background tasks
This will load ‘module’ as the main module, and the others as side-modules.
Only one main module can be loaded per runtime
§Arguments
module
- AModule
object containing the module’s filename and contents.side_modules
- A set of additional modules to be loaded into memory for use
§Returns
A Result
containing a handle for the loaded module
or an error (Error
) if there are issues with loading or executing the module
§Errors
Can fail if the module cannot be loaded, or execution fails
§Example
// Create a module with filename and contents
use rustyscript::{Runtime, Module, Error};
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
runtime.load_modules(&module, vec![]);
Sourcepub async fn load_modules_async(
&mut self,
module: &Module,
side_modules: Vec<&Module>,
) -> Result<ModuleHandle, Error>
pub async fn load_modules_async( &mut self, module: &Module, side_modules: Vec<&Module>, ) -> Result<ModuleHandle, Error>
Executes the given module, and returns a handle allowing you to extract values and call functions.
Returns a future that resolves to the handle for the loaded module
Makes no attempt to resolve the event loop - call Runtime::await_event_loop
to
resolve background tasks and async listeners
This will load ‘module’ as the main module, and the others as side-modules.
Only one main module can be loaded per runtime
See Runtime::load_modules
for an example
§Arguments
module
- AModule
object containing the module’s filename and contents.side_modules
- A set of additional modules to be loaded into memory for use
§Returns
A Result
containing a handle for the loaded main module, or the last side-module
or an error (Error
) if there are issues with loading or executing the modules
§Errors
Can fail if the modules cannot be loaded, or execution fails
Sourcepub fn call_entrypoint<T>(
&mut self,
module_context: &ModuleHandle,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn call_entrypoint<T>(
&mut self,
module_context: &ModuleHandle,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Executes the entrypoint function of a module within the Deno runtime.
Blocks until:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
§Arguments
module_context
- A handle returned by loading a module into the runtime
§Returns
A Result
containing the deserialized result of the entrypoint execution (T
)
if successful, or an error (Error
) if the entrypoint is missing, the execution fails,
or the result cannot be deserialized.
§Errors
Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails,
Or if the result cannot be deserialized into the requested type
§Example
use rustyscript::{json_args, Runtime, Module, Error};
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
let module = runtime.load_module(&module)?;
// Run the entrypoint and handle the result
let value: String = runtime.call_entrypoint(&module, json_args!())?;
Sourcepub async fn call_entrypoint_async<T>(
&mut self,
module_context: &ModuleHandle,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub async fn call_entrypoint_async<T>(
&mut self,
module_context: &ModuleHandle,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Executes the entrypoint function of a module within the Deno runtime.
Returns a future that resolves when:
- The event loop is resolved, and
- If the value is a promise, the promise is resolved
Note that synchronous functions are run synchronously. Returned promises will be run asynchronously, however.
See Runtime::call_entrypoint
for an example
§Arguments
module_context
- A handle returned by loading a module into the runtime
§Returns
A Result
containing the deserialized result of the entrypoint execution (T
)
if successful, or an error (Error
) if the entrypoint is missing, the execution fails,
or the result cannot be deserialized.
§Errors
Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails,
Or if the result cannot be deserialized into the requested type
Sourcepub fn call_entrypoint_immediate<T>(
&mut self,
module_context: &ModuleHandle,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn call_entrypoint_immediate<T>(
&mut self,
module_context: &ModuleHandle,
args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Executes the entrypoint function of a module within the Deno runtime.
Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop
§Arguments
module_context
- A handle returned by loading a module into the runtime
§Returns
A Result
containing the deserialized result of the entrypoint execution (T
)
if successful, or an error (Error
) if the entrypoint is missing, the execution fails,
or the result cannot be deserialized.
§Errors
Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails, Or if the result cannot be deserialized into the requested type
§Example
use rustyscript::{json_args, Runtime, Module, Error};
let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
let module = runtime.load_module(&module)?;
// Run the entrypoint and handle the result
let value: String = runtime.call_entrypoint_immediate(&module, json_args!())?;
Sourcepub fn execute_module<T>(
module: &Module,
side_modules: Vec<&Module>,
runtime_options: RuntimeOptions,
entrypoint_args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
pub fn execute_module<T>(
module: &Module,
side_modules: Vec<&Module>,
runtime_options: RuntimeOptions,
entrypoint_args: &impl Serialize,
) -> Result<T, Error>where
T: DeserializeOwned,
Loads a module into a new runtime, executes the entry function and returns the
result of the module’s execution, deserialized into the specified Rust type (T
).
§Arguments
module
- AModule
object containing the module’s filename and contents.side_modules
- A set of additional modules to be loaded into memory for useruntime_options
- Options for the creation of the runtimeentrypoint_args
- Arguments to pass to the entrypoint function
§Returns
A Result
containing the deserialized result of the entrypoint execution (T
)
if successful, or an error (Error
) if the entrypoint is missing, the execution fails,
or the result cannot be deserialized.
§Errors
Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails,
Or if the result cannot be deserialized into the requested type
§Example
// Create a module with filename and contents
use rustyscript::{json_args, Runtime, Module, Error};
let module = Module::new("test.js", "export default () => 2");
let value: usize = Runtime::execute_module(&module, vec![], Default::default(), json_args!())?;
Auto Trait Implementations§
impl Freeze for Runtime
impl !Send for Runtime
impl !Sync for Runtime
impl !RefUnwindSafe for Runtime
impl Unpin for Runtime
impl !UnwindSafe for Runtime
Blanket Implementations§
Source§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
Source§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CheckedAs for T
impl<T> CheckedAs for T
Source§fn checked_as<Dst>(self) -> Option<Dst>where
T: CheckedCast<Dst>,
fn checked_as<Dst>(self) -> Option<Dst>where
T: CheckedCast<Dst>,
Source§impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere
Src: CheckedCast<Dst>,
impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere
Src: CheckedCast<Dst>,
Source§fn checked_cast_from(src: Src) -> Option<Dst>
fn checked_cast_from(src: Src) -> Option<Dst>
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.Source§impl<T> FutureExt for T
impl<T> FutureExt for T
Source§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
Source§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
Source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request
Source§impl<T> OverflowingAs for T
impl<T> OverflowingAs for T
Source§fn overflowing_as<Dst>(self) -> (Dst, bool)where
T: OverflowingCast<Dst>,
fn overflowing_as<Dst>(self) -> (Dst, bool)where
T: OverflowingCast<Dst>,
Source§impl<Src, Dst> OverflowingCastFrom<Src> for Dstwhere
Src: OverflowingCast<Dst>,
impl<Src, Dst> OverflowingCastFrom<Src> for Dstwhere
Src: OverflowingCast<Dst>,
Source§fn overflowing_cast_from(src: Src) -> (Dst, bool)
fn overflowing_cast_from(src: Src) -> (Dst, bool)
Source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.Source§impl<T> Pointable for T
impl<T> Pointable for T
Source§impl<T> SaturatingAs for T
impl<T> SaturatingAs for T
Source§fn saturating_as<Dst>(self) -> Dstwhere
T: SaturatingCast<Dst>,
fn saturating_as<Dst>(self) -> Dstwhere
T: SaturatingCast<Dst>,
Source§impl<Src, Dst> SaturatingCastFrom<Src> for Dstwhere
Src: SaturatingCast<Dst>,
impl<Src, Dst> SaturatingCastFrom<Src> for Dstwhere
Src: SaturatingCast<Dst>,
Source§fn saturating_cast_from(src: Src) -> Dst
fn saturating_cast_from(src: Src) -> Dst
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.