Struct Module 

pub struct Module<'js, T = Declared> { /* private fields */ }

A JavaScript module.

Implementations

impl<'js, T> Module<'js, T>

pub fn name<N>(&self) -> Result<N>

where N: FromAtom<'js>,

Returns the name of the module

impl<'js> Module<'js, Declared>

pub fn declare<N, S>( ctx: Ctx<'js>, name: N, source: S, ) -> Result<Module<'js, Declared>>

where N: Into<Vec<u8>>, S: Into<Vec<u8>>,

Declare a module but don’t evaluate it.

pub fn declare_def<D, N>( ctx: Ctx<'js>, name: N, ) -> Result<Module<'js, Declared>>

where N: Into<Vec<u8>>, D: ModuleDef,

Declare a rust native module but don’t evaluate it.

pub fn evaluate<N, S>(ctx: Ctx<'js>, name: N, source: S) -> Result<Promise<'js>>

where N: Into<Vec<u8>>, S: Into<Vec<u8>>,

Evaluate the source of a module.

This function returns a promise which resolved when the modules was fully compiled and returns undefined.

Since QuickJS doesn’t give us a way to retrieve the module if we immediately evaluate a modules source this function doesn’t return a module object. If the module is required, you should first declare it with Module::declare and then call Module::eval on the returned module.

pub fn evaluate_def<D, N>( ctx: Ctx<'js>, name: N, ) -> Result<(Module<'js, Evaluated>, Promise<'js>)>

where N: Into<Vec<u8>>, D: ModuleDef,

Declares a module in the runtime and evaluates it.

pub unsafe fn load(ctx: Ctx<'js>, bytes: &[u8]) -> Result<Module<'js, Declared>>

Load a module from quickjs bytecode.

Safety

User must ensure that bytes handed to this function contain valid bytecode.

pub unsafe fn from_load_fn<N>( ctx: Ctx<'js>, name: N, load_fn: ModuleLoadFn, ) -> Result<Module<'js, Declared>>

where N: Into<Vec<u8>>,

Load a module from a raw module loading function.

Safety

The soundness of this function depends completely on if load_fn is implemented correctly. THe load_fn function must return a pointer to a valid module loaded with the given context.

pub fn eval(self) -> Result<(Module<'js, Evaluated>, Promise<'js>)>

Evaluate the module.

Returns the module as being evaluated and a promise which resolves when the module has finished evaluating. The return value of the promise is the JavaScript value undefined.

pub unsafe extern "C" fn init_raw<D>( ctx: *mut JSContext, name: *const c_char, ) -> *mut JSModuleDef

where D: ModuleDef,

A function for loading a Rust module from C.

Safety

This function should only be called when the module is loaded as part of a dynamically loaded library.

pub fn import<S: Into<Vec<u8>>>( ctx: &Ctx<'js>, specifier: S, ) -> Result<Promise<'js>>

Import and evaluate a module

This will work similar to an import(specifier) statement in JavaScript returning a promise with the result of the imported module.

impl<'js, Evaluated> Module<'js, Evaluated>

pub fn write(&self, options: WriteOptions) -> Result<Vec<u8>>

Write object bytecode for the module.

Examples

use rquickjs::{Context, Module, Result, Runtime, WriteOptions, WriteOptionsEndianness};
fn main() -> Result<()> {
    let rt = Runtime::new()?;
    let ctx = Context::full(&rt)?;
    let bytecode = ctx.with(|ctx| {
        let src = "console.log('hello world')";
        let module = Module::declare(ctx.clone(), "foo.js", src)?;
        module.write(WriteOptions {
            endianness: WriteOptionsEndianness::Little,
            ..Default::default()
        })
    })?;
    println!("bytecode: {bytecode:?}");
    Ok(())
}

pub fn meta(&self) -> Result<Object<'js>>

Return the import.meta object of a module

pub fn namespace(&self) -> Result<Object<'js>>

Returns the module namespace, an object containing all the module exported values.

pub fn get<N, T>(&self, name: N) -> Result<T>

where N: IntoAtom<'js>, T: FromJs<'js>,

Return exported value by name

pub fn into_declared(self) -> Module<'js, Declared>

Change the module back to being only declared.

This is always safe to do since calling eval again on an already evaluated module is safe.

Trait Implementations

impl<'js, T: Clone> Clone for Module<'js, T>

fn clone(&self) -> Module<'js, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'js, T: Debug> Debug for Module<'js, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'js, T: JsLifetime<'js>> JsLifetime<'js> for Module<'js, T>

type Changed<'to> = Module<'to, <T as JsLifetime<'js>>::Changed<'to>>

The target which has the same type as a Self but with another lifetime 't

impl<'js, T> Trace<'js> for Module<'js, T>

fn trace<'a>(&self, _tracer: Tracer<'a, 'js>)