Struct ModuleGraph 

pub struct ModuleGraph { /* private fields */ }

Implementations

impl ModuleGraph

pub fn get_exports_info( &self, module_identifier: &ModuleIdentifier, ) -> ExportsInfo

pub fn get_exports_info_data( &self, module_identifier: &ModuleIdentifier, ) -> &ExportsInfoData

pub fn get_exports_info_data_mut( &mut self, module_identifier: &ModuleIdentifier, ) -> &mut ExportsInfoData

pub fn get_prefetched_exports_info_optional<'b>( &'b self, module_identifier: &ModuleIdentifier, mode: PrefetchExportsInfoMode<'b>, ) -> Option<PrefetchedExportsInfoWrapper<'b>>

pub fn get_prefetched_exports_info<'b>( &'b self, module_identifier: &ModuleIdentifier, mode: PrefetchExportsInfoMode<'b>, ) -> PrefetchedExportsInfoWrapper<'b>

pub fn get_prefetched_exports_info_used( &self, module_identifier: &ModuleIdentifier, runtime: Option<&RuntimeSpec>, ) -> PrefetchedExportsInfoUsed

pub fn get_exports_info_by_id(&self, id: &ExportsInfo) -> &ExportsInfoData

pub fn get_exports_info_mut_by_id( &mut self, id: &ExportsInfo, ) -> &mut ExportsInfoData

pub fn set_exports_info(&mut self, id: ExportsInfo, info: ExportsInfoData)

pub fn active_all_exports_info(&mut self)

pub fn reset_all_exports_info_used(&mut self)

impl ModuleGraph

pub fn checkpoint(&mut self)

pub fn reset(&mut self)

impl ModuleGraph

pub fn modules(&self) -> IdentifierMap<&BoxModule>

Return an unordered iterator of modules

pub fn module_graph_modules(&self) -> IdentifierMap<&ModuleGraphModule>

pub fn get_outcoming_connections_by_module( &self, module_id: &ModuleIdentifier, ) -> HashMap<ModuleIdentifier, Vec<&ModuleGraphConnection>>

pub fn get_active_outcoming_connections_by_module( &self, module_id: &ModuleIdentifier, runtime: Option<&RuntimeSpec>, module_graph: &ModuleGraph, module_graph_cache: &ModuleGraphCacheArtifact, ) -> HashMap<ModuleIdentifier, Vec<&ModuleGraphConnection>>

pub fn get_incoming_connections_by_origin_module( &self, module_id: &ModuleIdentifier, ) -> HashMap<Option<ModuleIdentifier>, Vec<&ModuleGraphConnection>>

pub fn revoke_dependency( &mut self, dep_id: &DependencyId, force: bool, ) -> Option<BuildDependency>

Remove dependency in mgm and target connection, return dependency_id and origin module identifier

force will completely remove dependency, and you will not regenerate it from dependency_id

pub fn revoke_module( &mut self, module_id: &ModuleIdentifier, ) -> Vec<BuildDependency>

pub fn add_module_graph_module( &mut self, module_graph_module: ModuleGraphModule, )

pub fn clone_module_attributes( compilation: &mut Compilation, source_module: &ModuleIdentifier, target_module: &ModuleIdentifier, )

Make sure both source and target module are exists in module graph

pub fn move_module_connections( &mut self, old_module: &ModuleIdentifier, new_module: &ModuleIdentifier, filter_connection: impl Fn(&ModuleGraphConnection, &Box<dyn Dependency>) -> bool, )

pub fn copy_outgoing_module_connections<F>( &mut self, old_module: &ModuleIdentifier, new_module: &ModuleIdentifier, filter_connection: F, )

where F: Fn(&ModuleGraphConnection, &BoxDependency) -> bool,

pub fn get_depth(&self, module_id: &ModuleIdentifier) -> Option<usize>

pub fn set_depth_if_lower( &mut self, module_id: &ModuleIdentifier, depth: usize, ) -> bool

pub fn add_module(&mut self, module: BoxModule)

pub fn add_block(&mut self, block: Box<AsyncDependenciesBlock>)

pub fn set_parents( &mut self, dependency_id: DependencyId, parents: DependencyParents, )

pub fn get_parent_module( &self, dependency_id: &DependencyId, ) -> Option<&ModuleIdentifier>

pub fn get_parent_block( &self, dependency_id: &DependencyId, ) -> Option<&AsyncDependenciesBlockIdentifier>

pub fn get_parent_block_index( &self, dependency_id: &DependencyId, ) -> Option<usize>

pub fn block_by_id( &self, block_id: &AsyncDependenciesBlockIdentifier, ) -> Option<&AsyncDependenciesBlock>

pub fn block_by_id_expect( &self, block_id: &AsyncDependenciesBlockIdentifier, ) -> &AsyncDependenciesBlock

pub fn blocks( &self, ) -> &HashMap<AsyncDependenciesBlockIdentifier, Box<AsyncDependenciesBlock>>

pub fn dependencies(&self) -> HashMap<DependencyId, &BoxDependency>

pub fn add_dependency(&mut self, dependency: BoxDependency)

pub fn dependency_by_id(&self, dependency_id: &DependencyId) -> &BoxDependency

Get a dependency by ID, panicking if not found.

PREFERRED METHOD: Use this for ALL internal Rust code including:

• Core compilation logic
• All plugins (rspack_plugin_*)
• Stats generation, code generation, runtime templates
• Chunk graph building, export analysis
• Module graph building operations
• Any internal operations where dependencies should exist

Dependencies should always be accessible in internal operations, so this method enforces that invariant with a clear panic message if violated.

Only the binding layer (rspack_binding_api) should use internal::try_dependency_by_id() for graceful handling of missing dependencies in external APIs.

pub fn dependency_by_id_mut( &mut self, dependency_id: &DependencyId, ) -> &mut BoxDependency

Get a mutable dependency by ID, panicking if not found.

PREFERRED METHOD: Use this for ALL internal Rust code when you need to modify dependencies. Dependencies should always be accessible in internal operations, so this method enforces that invariant with a clear panic message.

pub fn module_graph_module_by_dependency_id( &self, id: &DependencyId, ) -> Option<&ModuleGraphModule>

Uniquely identify a module by its dependency

pub fn module_identifier_by_dependency_id( &self, dep_id: &DependencyId, ) -> Option<&ModuleIdentifier>

pub fn get_module_by_dependency_id( &self, dep_id: &DependencyId, ) -> Option<&BoxModule>

pub fn set_resolved_module( &mut self, original_module_identifier: Option<ModuleIdentifier>, dependency_id: DependencyId, module_identifier: ModuleIdentifier, ) -> Result<()>

Add a connection between two module graph modules, if a connection exists, then it will be reused.

pub fn module_by_identifier( &self, identifier: &ModuleIdentifier, ) -> Option<&BoxModule>

Uniquely identify a module by its identifier and return the aliased reference

pub fn module_by_identifier_mut( &mut self, identifier: &ModuleIdentifier, ) -> Option<&mut BoxModule>

pub fn module_graph_module_by_identifier( &self, identifier: &ModuleIdentifier, ) -> Option<&ModuleGraphModule>

Uniquely identify a module graph module by its module’s identifier and return the aliased reference

pub fn module_graph_module_by_identifier_mut( &mut self, identifier: &ModuleIdentifier, ) -> &mut ModuleGraphModule

Get a mutable module graph module by identifier, panicking if not found.

PREFERRED METHOD: Use this for all internal code where the module graph module should exist. This enforces the invariant with a clear panic message if violated.

Only use try_module_graph_module_by_identifier_mut() when you need to handle missing modules.

pub fn get_ordered_outgoing_connections( &self, module_identifier: &ModuleIdentifier, ) -> impl Iterator<Item = &ModuleGraphConnection>

pub fn get_outgoing_deps_in_order( &self, module_identifier: &ModuleIdentifier, ) -> impl Iterator<Item = &DependencyId>

pub fn connection_by_dependency_id( &self, dependency_id: &DependencyId, ) -> Option<&ModuleGraphConnection>

pub fn connection_by_dependency_id_mut( &mut self, dependency_id: &DependencyId, ) -> Option<&mut ModuleGraphConnection>

pub fn get_pre_order_index(&self, module_id: &ModuleIdentifier) -> Option<u32>

pub fn get_post_order_index(&self, module_id: &ModuleIdentifier) -> Option<u32>

pub fn get_issuer(&self, module_id: &ModuleIdentifier) -> Option<&BoxModule>

pub fn is_optional( &self, module_id: &ModuleIdentifier, module_graph_cache: &ModuleGraphCacheArtifact, ) -> bool

pub fn is_async( async_modules_artifact: &AsyncModulesArtifact, module_id: &ModuleIdentifier, ) -> bool

pub fn is_deferred( &self, imported_by_defer_modules_artifact: &ImportedByDeferModulesArtifact, module_id: &ModuleIdentifier, ) -> bool

pub fn set_async( async_modules_artifact: &mut AsyncModulesArtifact, module_id: ModuleIdentifier, is_async: bool, ) -> bool

pub fn get_outgoing_connections( &self, module_id: &ModuleIdentifier, ) -> impl Iterator<Item = &ModuleGraphConnection> + Clone

pub fn get_incoming_connections( &self, module_id: &ModuleIdentifier, ) -> impl Iterator<Item = &ModuleGraphConnection> + Clone

pub fn get_module_hash( &self, module_id: &ModuleIdentifier, ) -> Option<&RspackHashDigest>

pub fn get_dep_meta_if_existing( &self, id: &DependencyId, ) -> Option<&DependencyExtraMeta>

We can’t insert all sort of things into one hashmap like javascript, so we create different hashmap to store different kinds of meta.

pub fn set_dependency_extra_meta( &mut self, dep_id: DependencyId, extra: DependencyExtraMeta, )

pub fn can_update_module( &self, dep_id: &DependencyId, module_id: &ModuleIdentifier, ) -> bool

pub fn do_update_module( &mut self, dep_id: &DependencyId, module_id: &ModuleIdentifier, )

pub fn get_optimization_bailout_mut( &mut self, id: &ModuleIdentifier, ) -> &mut Vec<String>

pub fn get_optimization_bailout(&self, id: &ModuleIdentifier) -> &Vec<String>

pub fn get_condition_state( &self, connection: &ModuleGraphConnection, runtime: Option<&RuntimeSpec>, module_graph_cache: &ModuleGraphCacheArtifact, ) -> ConnectionState

pub fn cache_recovery_connection(&mut self, connection: ModuleGraphConnection)

pub fn batch_set_connections_original_module( &mut self, tasks: Vec<(DependencyId, ModuleIdentifier)>, )

pub fn batch_set_connections_module( &mut self, tasks: Vec<(DependencyId, ModuleIdentifier)>, )

pub fn batch_add_connections( &mut self, tasks: Vec<(ModuleIdentifier, Vec<DependencyId>, Vec<DependencyId>)>, )

pub fn batch_remove_connections( &mut self, tasks: Vec<(ModuleIdentifier, Vec<DependencyId>, Vec<DependencyId>)>, )

pub fn batch_set_export_info_used_name( &mut self, tasks: Vec<(ExportInfo, UsedNameItem)>, )

Trait Implementations

impl Debug for ModuleGraph

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

Formats the value using the given formatter.

impl Default for ModuleGraph

fn default() -> ModuleGraph

Returns the “default value” for a type.