Struct quickjs_runtime::builder::QuickJsRuntimeBuilder

pub struct QuickJsRuntimeBuilder { /* private fields */ }

the EsRuntimeBuilder is used to init an EsRuntime

Example

use quickjs_runtime::builder::QuickJsRuntimeBuilder;
// init a rt which may use 16MB of memory
let rt = QuickJsRuntimeBuilder::new()
.memory_limit(1024*1024*16)
.build();

Implementations

impl QuickJsRuntimeBuilder

pub fn build(self) -> QuickJsRuntimeFacade

build an EsRuntime

pub fn new() -> Self

init a new EsRuntimeBuilder

pub fn script_module_loader<M: ScriptModuleLoader<QuickJsRealmAdapter> + Send + 'static>(
    self,
    loader: Box<M>
) -> Self

add a script loaders which will be used to load modules when they are imported from script

Example

use hirofa_utils::js_utils::Script;
use quickjs_runtime::builder::QuickJsRuntimeBuilder;
use quickjs_runtime::quickjsrealmadapter::QuickJsRealmAdapter;
use hirofa_utils::js_utils::modules::ScriptModuleLoader;
struct MyModuleLoader {}
impl ScriptModuleLoader<QuickJsRealmAdapter> for MyModuleLoader {
    fn normalize_path(&self, realm: &QuickJsRealmAdapter ,ref_path: &str,path: &str) -> Option<String> {
        Some(path.to_string())
    }

    fn load_module(&self, realm: &QuickJsRealmAdapter, absolute_path: &str) -> String {
        "export const foo = 12;".to_string()
    }
}

let rt = QuickJsRuntimeBuilder::new()
    .script_module_loader(Box::new(MyModuleLoader{}))
    .build();
rt.eval_module_sync(Script::new("test_module.es", "import {foo} from 'some_module.mes';\nconsole.log('foo = %s', foo);")).ok().unwrap();

pub fn script_pre_processor<S: ScriptPreProcessor + Send + 'static>(
    self,
    processor: S
) -> Self

add a ScriptPreProcessor which will be called for all scripts which are evaluated and compiled

pub fn runtime_init_hook<H>(self, hook: H) -> Self where
    H: FnOnce(&QuickJsRuntimeFacade) -> Result<(), JsError> + Send + 'static, 

pub fn native_module_loader<M: NativeModuleLoader<QuickJsRealmAdapter> + Send + 'static>(
    self,
    loader: Box<M>
) -> Self

add a module loader which can load native functions and proxy classes

Example

use quickjs_runtime::builder::QuickJsRuntimeBuilder;
use quickjs_runtime::valueref::JSValueRef;
use quickjs_runtime::quickjsrealmadapter::QuickJsRealmAdapter;
use quickjs_runtime::quickjs_utils::functions;
use quickjs_runtime::quickjs_utils::primitives::{from_bool, from_i32};
use quickjs_runtime::reflection::Proxy;
use hirofa_utils::js_utils::Script;
use hirofa_utils::js_utils::modules::NativeModuleLoader;

struct MyModuleLoader{}
impl NativeModuleLoader<QuickJsRealmAdapter> for MyModuleLoader {
    fn has_module(&self, _q_ctx: &QuickJsRealmAdapter,module_name: &str) -> bool {
        module_name.eq("my_module")
    }

    fn get_module_export_names(&self, _q_ctx: &QuickJsRealmAdapter, _module_name: &str) -> Vec<&str> {
        vec!["someVal", "someFunc", "SomeClass"]
    }

    fn get_module_exports(&self, q_ctx: &QuickJsRealmAdapter, _module_name: &str) -> Vec<(&str, JSValueRef)> {
         
        let js_val = from_i32(1470);
        let js_func = functions::new_function_q(
            q_ctx,
            "someFunc", |_q_ctx, _this, _args| {
                return Ok(from_i32(432));
            }, 0)
            .ok().unwrap();
        let js_class = Proxy::new()
            .name("SomeClass")
            .static_method("doIt", |_q_ctx, _args|{
                return Ok(from_i32(185));
            })
            .install(q_ctx, false)
            .ok().unwrap();

        vec![("someVal", js_val), ("someFunc", js_func), ("SomeClass", js_class)]
    }
}

let rt = QuickJsRuntimeBuilder::new()
.native_module_loader(Box::new(MyModuleLoader{}))
.build();

rt.eval_module_sync(Script::new("test_native_mod.es", "import {someVal, someFunc, SomeClass} from 'my_module';\nlet i = (someVal + someFunc() + SomeClass.doIt());\nif (i !== 2087){throw Error('i was not 2087');}")).ok().expect("script failed");

pub fn memory_limit(self, bytes: u64) -> Self

set max memory the runtime may use

pub fn gc_threshold(self, size: u64) -> Self

number of allocations before gc is run

pub fn max_stack_size(self, size: u64) -> Self

set a max stack size

pub fn gc_interval(self, interval: Duration) -> Self

set a Garbage Collection interval, this will start a timer thread which will trigger a full GC every set interval

pub fn set_interrupt_handler<I: Fn(&QuickJsRuntimeAdapter) -> bool + Send + 'static>(
    self,
    interrupt_handler: I
) -> Self

add an interrupt handler, this will be called several times during script execution and may be used to cancel a running script

Trait Implementations

impl Default for QuickJsRuntimeBuilder

fn default() -> Self

Returns the “default value” for a type.

impl JsRuntimeBuilder for QuickJsRuntimeBuilder

type JsRuntimeFacadeType = QuickJsRuntimeFacade

fn js_build(self) -> QuickJsRuntimeFacade

construct a JsRuntimeFacade based on this builders options

fn js_runtime_init_hook<H: FnOnce(&QuickJsRuntimeFacade) -> Result<(), JsError> + Send + 'static>(
    self,
    hook: H
) -> Self

add a runtime init hook, this closure will be invoked when a JsRuntimeFacade is constructed (e.g. builder.build is called)

fn js_realm_adapter_init_hook<H: Fn(&QuickJsRuntimeAdapter, &QuickJsRealmAdapter) -> Result<(), JsError> + Send + 'static>(
    self,
    hook: H
) -> Self

add a realm adapter init hook, this will be called every time a realm is initialized

fn js_runtime_adapter_init_hook<H: FnOnce(&QuickJsRuntimeAdapter) -> Result<(), JsError> + Send + 'static>(
    self,
    hook: H
) -> Self

fn js_script_pre_processor<S: ScriptPreProcessor + Send + 'static>(
    self,
    preprocessor: S
) -> Self

add a script preprocessor

fn js_script_module_loader<S: ScriptModuleLoader<QuickJsRealmAdapter> + Send + 'static>(
    self,
    module_loader: S
) -> Self

add a module loader

fn js_compiled_module_loader<S: CompiledModuleLoader<<<<Self as JsRuntimeBuilder>::JsRuntimeFacadeType as JsRuntimeFacade>::JsRuntimeAdapterType as JsRuntimeAdapter>::JsRealmAdapterType> + Send + 'static>(
    self,
    module_loader: S
) -> Self

add a compiled_module loader

fn js_native_module_loader<S: NativeModuleLoader<<<<Self as JsRuntimeBuilder>::JsRuntimeFacadeType as JsRuntimeFacade>::JsRuntimeAdapterType as JsRuntimeAdapter>::JsRealmAdapterType> + Send + 'static>(
    self,
    module_loader: S
) -> Self where
    Self: Sized, 

add a native module loader (e.g. with proxy classes instead of a script)