Enum ResolverError

pub enum ResolverError {
    UnknownScheme {
        scheme: String,
    },
    UnknownError,
    FileNotFound {
        relative: PathBuf,
        from: PathBuf,
    },
    ModuleNotFound {
        module: String,
    },
    ModuleEntryNotFound {
        module: String,
        entry_path: PathBuf,
        package_path: PathBuf,
        field: &'static str,
    },
    ModuleSubpathNotFound {
        module: String,
        path: PathBuf,
        package_path: PathBuf,
    },
    JsonError(JsonError),
    IOError(IOError),
    PackageJsonError {
        module: String,
        path: PathBuf,
        error: PackageJsonError,
    },
    PackageJsonNotFound {
        from: PathBuf,
    },
    InvalidSpecifier(SpecifierError),
    TsConfigExtendsNotFound {
        tsconfig: PathBuf,
        error: Box<ResolverError>,
    },
}

An error that occcured during resolution.

Variants

UnknownScheme

An unknown URL scheme was found in the specifier.

Fields

scheme: String

UnknownError

An unknown error occurred.

FileNotFound

A file was not found.

Fields

relative: PathBuf

from: PathBuf

ModuleNotFound

A node_modules directory was not found.

Fields

module: String

ModuleEntryNotFound

A package.json entry field pointed to a non-existent file.

Fields

module: String

The node_modules package name.

entry_path: PathBuf

Path of the entry found in package.json.

package_path: PathBuf

Path of the package.json.

field: &'static str

Package.json field name.

ModuleSubpathNotFound

A sub-path could not be found within a node_modules package.

Fields

module: String

The node_modules package name.

path: PathBuf

Path of the non-existent file.

package_path: PathBuf

Path of the package.json.

JsonError(JsonError)

An error parsing JSON.

IOError(IOError)

An I/O error.

PackageJsonError

A sub-path was not exported from a package.json.

Fields

module: String

The node_modules package name.

path: PathBuf

The path of the file that is not exported.

error: PackageJsonError

Reason the path was not exported.

PackageJsonNotFound

A package.json file could not be found above the given path.

Fields

from: PathBuf

InvalidSpecifier(SpecifierError)

Could not parse the specifier.

TsConfigExtendsNotFound

Could not find an extended tsconfig.json file.

Fields

tsconfig: PathBuf

Path of the tsconfig.json with the “extends” field.

error: Box<ResolverError>

Original error resolving the tsconfig.json extends specifier.

Trait Implementations

impl Clone for ResolverError

fn clone(&self) -> ResolverError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ResolverError

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

Formats the value using the given formatter.

impl Display for ResolverError

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

Formats the value using the given formatter.

impl Error for ResolverError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<()> for ResolverError

fn from(_: ()) -> Self

Converts to this type from the input type.

impl From<Error> for ResolverError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<SpecifierError> for ResolverError

fn from(value: SpecifierError) -> Self

Converts to this type from the input type.

impl From<Utf8Error> for ResolverError

fn from(_: Utf8Error) -> Self

Converts to this type from the input type.

impl PartialEq for ResolverError

fn eq(&self, other: &ResolverError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ResolverError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ResolverError