Struct ResolveOptions

pub struct ResolveOptions {

    pub fully_specified: bool,
    pub prefer_relative: bool,
    pub extensions: Vec<RcStr>,
    pub modules: Vec<ResolveModules>,
    pub into_package: Vec<ResolveIntoPackage>,
    pub in_package: Vec<ResolveInPackage>,
    pub default_files: Vec<RcStr>,
    pub import_map: Option<ResolvedVc<ImportMap>>,
    pub fallback_import_map: Option<ResolvedVc<ImportMap>>,
    pub resolved_map: Option<ResolvedVc<ResolvedMap>>,
    pub before_resolve_plugins: Vec<ResolvedVc<Box<dyn BeforeResolvePlugin>>>,
    pub after_resolve_plugins: Vec<ResolvedVc<Box<dyn AfterResolvePlugin>>>,
    pub enable_typescript_with_output_extension: bool,
    pub loose_errors: bool,
    pub parse_data_uris: bool,
    pub placeholder_for_future_extensions: (),
}

Fields

fully_specified: bool

When set, do not apply extensions and default_files for relative request. But they are still applied for resolving into packages.

prefer_relative: bool

When set, when resolving a module request, try to resolve it as relative request first.

extensions: Vec<RcStr>

The extensions that should be added to a request when resolving.

modules: Vec<ResolveModules>

The locations where to resolve modules.

into_package: Vec<ResolveIntoPackage>

How to resolve packages.

in_package: Vec<ResolveInPackage>

How to resolve in packages.

default_files: Vec<RcStr>

The default files to resolve in a folder.

import_map: Option<ResolvedVc<ImportMap>>

An import map to use before resolving a request.

fallback_import_map: Option<ResolvedVc<ImportMap>>

An import map to use when a request is otherwise unresolvable.

resolved_map: Option<ResolvedVc<ResolvedMap>>

before_resolve_plugins: Vec<ResolvedVc<Box<dyn BeforeResolvePlugin>>>

after_resolve_plugins: Vec<ResolvedVc<Box<dyn AfterResolvePlugin>>>

enable_typescript_with_output_extension: bool

Support resolving *.js requests to *.ts files

loose_errors: bool

Warn instead of error for resolve errors

parse_data_uris: bool

Whether to parse data URIs into modules (as opposed to keeping them as externals)

placeholder_for_future_extensions: ()

Implementations

impl ResolveOptions

pub fn cell(self) -> Vc<Self>

Places a value in a cell of the current task.

Cell is selected based on the value type and call order of cell.

pub fn resolved_cell(self) -> ResolvedVc<Self>

Places a value in a cell of the current task. Returns a ResolvedVc.

Cell is selected based on the value type and call order of cell.

impl ResolveOptions

pub fn with_extended_import_map( self: Vc<Self>, import_map: Vc<ImportMap>, ) -> Vc<Self>

Returns a new Vc with its import map extended to include the given import map.

pub fn with_extended_fallback_import_map( self: Vc<Self>, extended_import_map: Vc<ImportMap>, ) -> Vc<Self>

Returns a new Vc with its fallback import map extended to include the given import map.

pub fn with_extensions(self: Vc<Self>, extensions: Vec<RcStr>) -> Vc<Self>

Overrides the extensions used for resolving

pub fn with_fully_specified(self: Vc<Self>, fully_specified: bool) -> Vc<Self>

Overrides the fully_specified flag for resolving

Trait Implementations

impl Clone for ResolveOptions

fn clone(&self) -> ResolveOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ResolveOptions

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

Formats the value using the given formatter.

impl Default for ResolveOptions

fn default() -> ResolveOptions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ResolveOptions

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ResolveOptions> for Vc<ResolveOptions>

fn from(value: ResolveOptions) -> Self

Converts to this type from the input type.

impl PartialEq for ResolveOptions

fn eq(&self, other: &ResolveOptions) -> 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 ResolveOptions

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ShrinkToFit for ResolveOptions

fn shrink_to_fit(&mut self)

impl TraceRawVcs for ResolveOptions

fn trace_raw_vcs(&self, __context__: &mut TraceRawVcsContext)

fn get_raw_vcs(&self) -> Vec<RawVc>

impl ValueDebug for ResolveOptions

fn dbg(self: Vc<Self>) -> Vc<ValueDebugString>

fn dbg_depth(self: Vc<Self>, depth: usize) -> Vc<ValueDebugString>

Like dbg, but with a depth limit.

impl ValueDebugFormat for ResolveOptions

fn value_debug_format<'a>(&'a self, depth: usize) -> ValueDebugFormatString<'a>

impl VcValueType for ResolveOptions

type Read = VcDefaultRead<ResolveOptions>

How to read the value.

type CellMode = VcCellSharedMode<ResolveOptions>

How to update cells of this value type.

fn get_value_type_id() -> ValueTypeId

Returns the type id of the value type.

impl Eq for ResolveOptions

impl NonLocalValue for ResolveOptions

impl StructuralPartialEq for ResolveOptions

impl Upcast<Box<dyn ValueDebug>> for ResolveOptions