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 + Send + 'static>( self, loader: M, ) -> Self

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

Example

use quickjs_runtime::builder::QuickJsRuntimeBuilder;
use quickjs_runtime::jsutils::modules::ScriptModuleLoader;
use quickjs_runtime::quickjsrealmadapter::QuickJsRealmAdapter;
use quickjs_runtime::jsutils::Script;
struct MyModuleLoader {}
impl ScriptModuleLoader 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(MyModuleLoader{})
    .build();
rt.eval_module_sync(None, 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 native_module_loader<S: NativeModuleLoader + Send + 'static>( self, module_loader: S, ) -> Self

where Self: Sized,

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

Example

use quickjs_runtime::builder::QuickJsRuntimeBuilder;
use quickjs_runtime::jsutils::modules::NativeModuleLoader;
use quickjs_runtime::jsutils::Script;
use quickjs_runtime::quickjsvalueadapter::QuickJsValueAdapter;
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;

struct MyModuleLoader{}
impl NativeModuleLoader 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, QuickJsValueAdapter)> {
         
        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", |_rt, _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(MyModuleLoader{})
.build();

rt.eval_module_sync(None, 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

impl QuickJsRuntimeBuilder

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

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

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

pub fn compiled_module_loader<S: CompiledModuleLoader + Send + 'static>( self, module_loader: S, ) -> Self

Trait Implementations

impl Default for QuickJsRuntimeBuilder

fn default() -> Self

Returns the “default value” for a type.