Enum ImportLoadKind 

#[repr(u8)]
pub enum ImportLoadKind {
    Static = 0,
    Dynamic = 1,
    DynamicPattern = 2,
    OutOfThread = 3,
    PathReference = 4,
    AssetReference = 5,
}

When the target of an import edge loads, relative to the importing module.

The startup weight report follows only Static edges to find the code that loads before the entry module runs. The other kinds load later, or outside the importing thread, except PathReference and AssetReference. These two edges keep their target in use but do not run it: see Self::loads_target. Only an asset reference also stops reachability: see Self::runs_target_code.

Variants

Static = 0

The target loads before the importer runs: import, export ... from, require(), require.context and import.meta.glob(..., { eager: true }).

Dynamic = 1

The target loads on demand through import('./literal').

DynamicPattern = 2

The target is one match of an on-demand pattern: a template import() or a lazy import.meta.glob.

OutOfThread = 3

The target runs on another thread or in another process: a new URL(..., import.meta.url) reference (for example a worker URL), a webpack worker loader request (worker-loader!./work.js), child_process.fork, a pino transport or a module.register hook.

PathReference = 4

The importer gets only the path of the target and does not load it: require.resolve('./file') or require.resolve(`./file`). The edge keeps the target in use. The consumer of the path can run the target later, so the imports of the target stay reachable.

AssetReference = 5

The importer reads the target as text, bytes or a URL through a webpack asset loader, such as raw-loader!./file.js. The bundle never runs the target as code, so the imports of the target are not reachable through this edge. The graph sets this kind; extraction never records it.

Implementations

impl ImportLoadKind

pub const fn is_eager(self) -> bool

Whether the target loads before the importing module runs.

pub const fn is_deferred(self) -> bool

Whether the target loads on demand on the importing thread.

pub const fn loads_target(self) -> bool

Whether the edge runs its target. A path reference and an asset reference keep the target in use but do not run it, so the edge does not close a cycle, is not in the entry load closure, does not cross an architecture boundary and does not carry server code into a client bundle.

pub const fn runs_target_code(self) -> bool

Whether the target can run as code at all, through this edge or through the consumer of a path reference. Only an asset reference never runs its target, so reachability does not continue through it.

pub const fn is_eager_value(self, is_type_only: bool) -> bool

Whether an import with this load kind puts a runtime value of the target on the startup path: the target loads before the importer runs and the import is not type-only.

Trait Implementations

impl Clone for ImportLoadKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ImportLoadKind

impl Debug for ImportLoadKind

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

Formats the value using the given formatter.

impl<'__de> Decode<'__de> for ImportLoadKind

where '__de:,

impl Default for ImportLoadKind

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ImportLoadKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for ImportLoadKind

impl Eq for ImportLoadKind

impl Hash for ImportLoadKind

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 Ord for ImportLoadKind

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for ImportLoadKind

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ImportLoadKind

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ImportLoadKind

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 ImportLoadKind