Trait rquickjs::loader::Resolver

pub trait Resolver {
    // Required method
    fn resolve<'js>(
        &mut self,
        ctx: &Ctx<'js>,
        base: &str,
        name: &str
    ) -> Result<String, Error>;
}

Available on crate feature loader only.

Module resolver interface

Required Methods

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

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

impl Resolver for ()

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

impl<A> Resolver for (A,)

where A: Resolver,

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

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

where A: Resolver, B: Resolver,

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

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

where A: Resolver, B: Resolver, C: Resolver,

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

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

where A: Resolver, B: Resolver, C: Resolver, D: Resolver,

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

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

where A: Resolver, B: Resolver, C: Resolver, D: Resolver, E: Resolver,

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

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,

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

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,

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

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,

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

Implementors

impl Resolver for BuiltinResolver

impl Resolver for FileResolver

impl<D> Resolver for Bundle<&'static Map<&'static str, D>>

impl<D> Resolver for Bundle<&'static [(&'static str, D)]>

impl<R> Resolver for Compile<R>

where R: Resolver,