Struct ResolveOptionsContext

pub struct ResolveOptionsContext {

    pub emulate_environment: Option<ResolvedVc<Environment>>,
    pub enable_types: bool,
    pub enable_typescript: bool,
    pub enable_react: bool,
    pub enable_node_native_modules: bool,
    pub enable_mjs_extension: bool,
    pub enable_node_modules: Option<ResolvedVc<FileSystemPath>>,
    pub tsconfig_path: Option<ResolvedVc<FileSystemPath>>,
    pub enable_node_externals: bool,
    pub enable_edge_node_externals: bool,
    pub browser: bool,
    pub module: bool,
    pub custom_conditions: Vec<RcStr>,
    pub custom_extensions: Option<Vec<RcStr>>,
    pub import_map: Option<ResolvedVc<ImportMap>>,
    pub fallback_import_map: Option<ResolvedVc<ImportMap>>,
    pub resolved_map: Option<ResolvedVc<ResolvedMap>>,
    pub rules: Vec<(ContextCondition, ResolvedVc<ResolveOptionsContext>)>,
    pub after_resolve_plugins: Vec<ResolvedVc<Box<dyn AfterResolvePlugin>>>,
    pub before_resolve_plugins: Vec<ResolvedVc<Box<dyn BeforeResolvePlugin>>>,
    pub loose_errors: bool,
    pub placeholder_for_future_extensions: (),
}

Fields

emulate_environment: Option<ResolvedVc<Environment>>

enable_types: bool

enable_typescript: bool

enable_react: bool

enable_node_native_modules: bool

enable_mjs_extension: bool

enable_node_modules: Option<ResolvedVc<FileSystemPath>>

Enable resolving of the node_modules folder when within the provided directory

tsconfig_path: Option<ResolvedVc<FileSystemPath>>

A specific path to a tsconfig.json file to use for resolving modules. If None, one will be looked up through the filesystem

enable_node_externals: bool

Mark well-known Node.js modules as external imports and load them using native require. e.g. url, querystring, os

enable_edge_node_externals: bool

Mark well-known Edge modules as external imports and load them using native require. e.g. buffer, events, assert

browser: bool

Enables the “browser” field and export condition in package.json

module: bool

Enables the “module” field and export condition in package.json

custom_conditions: Vec<RcStr>

custom_extensions: Option<Vec<RcStr>>

import_map: Option<ResolvedVc<ImportMap>>

An additional import map to use when resolving modules.

If set, this import map will be applied to ResolveOption::import_map. It is always applied last, so any mapping defined within will take precedence over any other (e.g. tsconfig.json compilerOptions.paths).

fallback_import_map: Option<ResolvedVc<ImportMap>>

An import map to fall back to when a request could not be resolved.

If set, this import map will be applied to ResolveOption::fallback_import_map. It is always applied last, so any mapping defined within will take precedence over any other.

resolved_map: Option<ResolvedVc<ResolvedMap>>

An additional resolved map to use after modules have been resolved.

rules: Vec<(ContextCondition, ResolvedVc<ResolveOptionsContext>)>

A list of rules to use a different resolve option context for certain context paths. The first matching is used.

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

Plugins which get applied before and after resolving.

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

loose_errors: bool

Warn instead of error for resolve errors

placeholder_for_future_extensions: ()

Implementations

impl ResolveOptionsContext

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

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<ResolveOptionsContext>

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 ResolveOptionsContext

pub fn with_types_enabled( self: Vc<ResolveOptionsContext>, ) -> Vc<ResolveOptionsContext>

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

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

pub fn with_extended_fallback_import_map( self: Vc<ResolveOptionsContext>, fallback_import_map: Vc<ImportMap>, ) -> Vc<ResolveOptionsContext>

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

Trait Implementations

impl Clone for ResolveOptionsContext

fn clone(&self) -> ResolveOptionsContext

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for ResolveOptionsContext

fn default() -> ResolveOptionsContext

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ResolveOptionsContext

fn deserialize<__D>( __deserializer: __D, ) -> Result<ResolveOptionsContext, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ResolveOptionsContext> for Vc<ResolveOptionsContext>

fn from(value: ResolveOptionsContext) -> Vc<ResolveOptionsContext>

Converts to this type from the input type.

impl PartialEq for ResolveOptionsContext

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ShrinkToFit for ResolveOptionsContext

fn shrink_to_fit(&mut self)

impl TraceRawVcs for ResolveOptionsContext

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

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

impl ValueDebug for ResolveOptionsContext

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

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

Like dbg, but with a depth limit.

impl ValueDebugFormat for ResolveOptionsContext

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

impl ValueDefault for ResolveOptionsContext

fn value_default() -> Vc<ResolveOptionsContext>

impl VcValueType for ResolveOptionsContext

type Read = VcDefaultRead<ResolveOptionsContext>

How to read the value.

type CellMode = VcCellSharedMode<ResolveOptionsContext>

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 ResolveOptionsContext

impl NonLocalValue for ResolveOptionsContext

impl StructuralPartialEq for ResolveOptionsContext

impl Upcast<Box<dyn ValueDebug>> for ResolveOptionsContext

impl Upcast<Box<dyn ValueDefault>> for ResolveOptionsContext