Struct farmfe_core::module::Module

pub struct Module {

    pub id: ModuleId,
    pub module_type: ModuleType,
    pub module_groups: HashSet<ModuleGroupId>,
    pub resource_pot: Option<ResourcePotId>,
    pub meta: Box<ModuleMetaData>,
    pub side_effects: bool,
    pub source_map_chain: Vec<Arc<String>>,
    pub external: bool,
    pub immutable: bool,
    pub execution_order: usize,
    pub size: usize,
    pub content: Arc<String>,
    pub used_exports: Vec<String>,
    pub last_update_timestamp: u128,
    pub content_hash: String,
    pub package_name: String,
    pub package_version: String,
}

A Module is a basic compilation unit The Module is created by plugins in the parse hook of build stage

Fields

id: ModuleId

the id of this module, generated from the resolved id.

module_type: ModuleType

the type of this module, for example ModuleType::Js

module_groups: HashSet<ModuleGroupId>

the module groups this module belongs to, used to construct crate::module::module_group::ModuleGroupGraph

resource_pot: Option<ResourcePotId>

the resource pot this module belongs to

meta: Box<ModuleMetaData>

the meta data of this module custom by plugins

side_effects: bool

whether this module has side_effects

source_map_chain: Vec<Arc<String>>

the transformed source map chain of this module

external: bool

whether this module marked as external

immutable: bool

whether this module is immutable, for example, the module is immutable if it is from node_modules. This field will be set according to partialBundling.immutable of the user config, default to the module whose resolved_path contains [“/node_modules/”].

execution_order: usize

Execution order of this module in the module graph updated after the module graph is built

size: usize

Source size of this module

content: Arc<String>

Source content after load and transform

used_exports: Vec<String>

Used exports of this module. Set by the tree-shake plugin

last_update_timestamp: u128

last update timestamp

content_hash: String

content(after load and transform) hash

package_name: String

package name of this module

package_version: String

package version of this module

Implementations

impl Module

pub fn new(id: ModuleId) -> Self

Trait Implementations

impl Archive for Module

where ModuleId: Archive, ModuleType: Archive, HashSet<ModuleGroupId>: Archive, Option<ResourcePotId>: Archive, Box<ModuleMetaData>: Archive, bool: Archive, Vec<Arc<String>>: Archive, usize: Archive, Arc<String>: Archive, Vec<String>: Archive, u128: Archive, String: Archive,

type Archived = ArchivedModule

The archived representation of this type.

type Resolver = ModuleResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<__D: Fallible + ?Sized> Deserialize<Module, __D> for Archived<Module>

where ModuleId: Archive, Archived<ModuleId>: Deserialize<ModuleId, __D>, ModuleType: Archive, Archived<ModuleType>: Deserialize<ModuleType, __D>, HashSet<ModuleGroupId>: Archive, Archived<HashSet<ModuleGroupId>>: Deserialize<HashSet<ModuleGroupId>, __D>, Option<ResourcePotId>: Archive, Archived<Option<ResourcePotId>>: Deserialize<Option<ResourcePotId>, __D>, Box<ModuleMetaData>: Archive, Archived<Box<ModuleMetaData>>: Deserialize<Box<ModuleMetaData>, __D>, bool: Archive, Archived<bool>: Deserialize<bool, __D>, Vec<Arc<String>>: Archive, Archived<Vec<Arc<String>>>: Deserialize<Vec<Arc<String>>, __D>, usize: Archive, Archived<usize>: Deserialize<usize, __D>, Arc<String>: Archive, Archived<Arc<String>>: Deserialize<Arc<String>, __D>, Vec<String>: Archive, Archived<Vec<String>>: Deserialize<Vec<String>, __D>, u128: Archive, Archived<u128>: Deserialize<u128, __D>, String: Archive, Archived<String>: Deserialize<String, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<Module, __D::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for Module

where ModuleId: Serialize<__S>, ModuleType: Serialize<__S>, HashSet<ModuleGroupId>: Serialize<__S>, Option<ResourcePotId>: Serialize<__S>, Box<ModuleMetaData>: Serialize<__S>, bool: Serialize<__S>, Vec<Arc<String>>: Serialize<__S>, usize: Serialize<__S>, Arc<String>: Serialize<__S>, Vec<String>: Serialize<__S>, u128: Serialize<__S>, String: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.