Enum SubpathValue

pub enum SubpathValue {
    Alternatives(Vec<SubpathValue>),
    Conditional(Vec<(RcStr, SubpathValue)>),
    Result(RcStr),
    Excluded,
}

The result an “exports”/“imports” field describes. Can represent multiple alternatives, conditional result, ignored result (null mapping) and a plain result.

Variants

Alternatives(Vec<SubpathValue>)

Alternative subpaths, defined with "path": ["other1", "other2"], allows for specifying multiple possible remappings to be tried. This may be that conditions didn’t match, or that a particular path wasn’t found.

Conditional(Vec<(RcStr, SubpathValue)>)

Conditional subpaths, defined with "path": { "condition": "other"}, allow remapping based on certain predefined conditions. Eg, if using ESM import syntax, the import condition allows you to remap to a file that uses ESM syntax. Node defines several conditions in https://nodejs.org/api/packages.html#conditional-exports TODO: Should this use an enum of predefined keys?

Result(RcStr)

A result subpath, defined with "path": "other", remaps imports of path to other.

Excluded

An excluded subpath, defined with "path": null, prevents importing this subpath.

Implementations

impl SubpathValue

pub fn add_results<'a>( &'a self, conditions: &BTreeMap<RcStr, ConditionValue>, unspecified_condition: &ConditionValue, condition_overrides: &mut FxHashMap<&'a str, ConditionValue>, target: &mut Vec<(&'a str, Vec<(&'a str, bool)>)>, ) -> bool

Walks the SubpathValue and adds results to the target vector. It uses the conditions to skip or enter conditional results. The state of conditions is stored within condition_overrides, which is also exposed to the consumer.

Trait Implementations

impl AliasTemplate for SubpathValue

type Output<'a> = Result<ReplacedSubpathValue, Error> where Self: 'a

The type of the output of the replacement.

fn convert(&self) -> Result<ReplacedSubpathValue>

Turn self into a Self::Output

fn replace(&self, capture: &Pattern) -> Result<ReplacedSubpathValue>

Replaces capture within self.

impl Clone for SubpathValue

fn clone(&self) -> SubpathValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SubpathValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubpathValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SubpathValue

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SubpathValue

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SubpathValue

impl StructuralPartialEq for SubpathValue