Trait rquickjs_core::Resolver

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

This is supported on crate feature loader only.

Module resolver interface

Required methods

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

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

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

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

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>

This is supported on crate feature loader only.

Implementors

impl Resolver for BuiltinResolver

impl Resolver for FileResolver

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

impl<R> Resolver for Compile<R> where
    R: Resolver,