rquickjs_core::loader

Trait Resolver

Source 
pub trait Resolver {
    // Required method
    fn resolve<'js>(
        &mut self,
        ctx: &Ctx<'js>,
        base: &str,
        name: &str,
    ) -> Result<String>;
}
Available on crate feature loader only.
Expand description

Module resolver interface

Required Methods§

Source

fn resolve<'js>( &mut self, ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Normalize module name

The resolving may looks like:

Ok(if !name.starts_with('.') {
    name.into()
} else {
    let mut split = base.rsplitn(2, '/');
    let path = match (split.next(), split.next()) {
        (_, Some(path)) => path,
        _ => "",
    };
    format!("{path}/{name}")
})

Implementations on Foreign Types§

Source§

impl Resolver for ()

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A> Resolver for (A,)
where A: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B> Resolver for (A, B)
where A: Resolver, B: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B, C> Resolver for (A, B, C)
where A: Resolver, B: Resolver, C: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B, C, D> Resolver for (A, B, C, D)
where A: Resolver, B: Resolver, C: Resolver, D: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B, C, D, E> Resolver for (A, B, C, D, E)
where A: Resolver, B: Resolver, C: Resolver, D: Resolver, E: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B, C, D, E, F> Resolver for (A, B, C, D, E, F)
where A: Resolver, B: Resolver, C: Resolver, D: Resolver, E: Resolver, F: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B, C, D, E, F, G> Resolver for (A, B, C, D, E, F, G)
where A: Resolver, B: Resolver, C: Resolver, D: Resolver, E: Resolver, F: Resolver, G: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Source§

impl<A, B, C, D, E, F, G, H> Resolver for (A, B, C, D, E, F, G, H)
where A: Resolver, B: Resolver, C: Resolver, D: Resolver, E: Resolver, F: Resolver, G: Resolver, H: Resolver,

Source§

fn resolve<'js>( &mut self, _ctx: &Ctx<'js>, base: &str, name: &str, ) -> Result<String>

Implementors§