Struct rquickjs::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, Error>

where N: FromAtom<'js>,

Returns the name of the module

impl<'js> Module<'js>

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

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>, Error>

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>, Error>

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>), Error>

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>, Error>

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: unsafe extern "C" fn(_: *mut JSContext, _: *const i8) -> *mut JSModuleDef ) -> Result<Module<'js>, Error>

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>), Error>

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 i8 ) -> *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>(ctx: &Ctx<'js>, specifier: S) -> Result<Promise<'js>, Error>

where S: Into<Vec<u8>>,

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_le(&self) -> Result<Vec<u8>, Error>

Write object bytecode for the module in little endian format.

pub fn write_be(&self) -> Result<Vec<u8>, Error>

Write object bytecode for the module in big endian format.

pub fn write(&self, swap_endianess: bool) -> Result<Vec<u8>, Error>

Write object bytecode for the module.

swap_endianess swaps the endianness of the bytecode, if true, from native to the other kind. Use if the bytecode is meant for a target with a different endianness than the current.

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

Return the import.meta object of a module

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

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

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

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

Return exported value by name

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

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 for Module<'js, T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where T: Debug,

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

Formats the value using the given formatter.

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

type Target<'to> = Module<'to, T>

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>)