Struct farmfe_core::module::module_graph::ModuleGraph

pub struct ModuleGraph {
    pub entries: HashMap<ModuleId, String>,
    /* private fields */
}

Fields

entries: HashMap<ModuleId, String>

entry modules of this module graph. (Entry Module Id, Entry Name)

Implementations

impl ModuleGraph

pub fn new() -> Self

pub fn get_dep_by_source_optional( &self, module_id: &ModuleId, source: &str, kind: Option<ResolveKind>, ) -> Option<ModuleId>

Get the dep module of the specified module which imports the dep module using the specified source. Used to get module by (module, source) pair, for example, for module a:

import b from './b';

we can get module b by (module a, "./b").

Panic if the dep does not exist or the source is not correct

pub fn get_edges_of_module( &self, module_id: &ModuleId, ) -> Vec<&ModuleGraphEdgeDataItem>

pub fn get_dep_by_source( &self, module_id: &ModuleId, source: &str, kind: Option<ResolveKind>, ) -> ModuleId

pub fn update_edge( &mut self, from: &ModuleId, to: &ModuleId, edge_info: ModuleGraphEdge, ) -> Result<()>

pub fn module(&self, module_id: &ModuleId) -> Option<&Module>

pub fn module_mut(&mut self, module_id: &ModuleId) -> Option<&mut Module>

pub fn modules(&self) -> Vec<&Module>

pub fn modules_mut(&mut self) -> Vec<&mut Module>

pub fn has_module(&self, module_id: &ModuleId) -> bool

pub fn update_module(&mut self, module: Module)

pub fn module_ids_by_file(&self, module_id: &ModuleId) -> Vec<ModuleId>

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

pub fn remove_module(&mut self, module_id: &ModuleId) -> Module

pub fn add_edge_item( &mut self, from: &ModuleId, to: &ModuleId, edge_info: ModuleGraphEdgeDataItem, ) -> Result<()>

pub fn add_edge( &mut self, from: &ModuleId, to: &ModuleId, edge_info: ModuleGraphEdge, ) -> Result<()>

pub fn remove_edge(&mut self, from: &ModuleId, to: &ModuleId) -> Result<()>

pub fn has_edge(&self, from: &ModuleId, to: &ModuleId) -> bool

pub fn edge_info( &self, from: &ModuleId, to: &ModuleId, ) -> Option<&ModuleGraphEdge>

pub fn edge_count(&self) -> usize

pub fn dependencies( &self, module_id: &ModuleId, ) -> Vec<(ModuleId, &ModuleGraphEdge)>

get dependencies of the specific module, sorted by the order of the edge. for example, for module a:

import c from './c';
import b from './b';

return ['module c', 'module b'], ensure the order of original imports.

pub fn dependencies_ids(&self, module_id: &ModuleId) -> Vec<ModuleId>

Same as dependencies, but only return the module id.

pub fn dependents( &self, module_id: &ModuleId, ) -> Vec<(ModuleId, &ModuleGraphEdge)>

get dependent of the specific module. don’t ensure the result’s order.

// a.js
import c from './c.js';
// b.js
import c from './c.js';

dependents(“./c.js”) return ['module a', 'module b'], ensure the order of original imports.

pub fn dependents_ids(&self, module_id: &ModuleId) -> Vec<ModuleId>

pub fn toposort(&self) -> (Vec<ModuleId>, Vec<Vec<ModuleId>>)

sort the module graph topologically using post order dfs, note this topo sort also keeps the original import order. return (topologically sorted modules, cyclic modules stack)

Unsupported Situation: if the two entries shares the same dependencies but the import order is not the same, may cause one entry don’t keep original import order, this may bring problems in css as css depends on the order.

pub fn update_execution_order_for_modules(&mut self)

pub fn internal_graph(&self) -> &StableDiGraph<Module, ModuleGraphEdge>

pub fn dfs(&self, entry: &ModuleId, op: &mut dyn FnMut(&ModuleId))

pub fn dfs_breakable( &self, entries: Vec<ModuleId>, op: &mut dyn FnMut(Option<&ModuleId>, &ModuleId) -> bool, )

pub fn bfs(&self, entry: &ModuleId, op: &mut dyn FnMut(&ModuleId))

pub fn take_edge_and_module( &mut self, from: &ModuleId, to: &ModuleId, ) -> (ModuleGraphEdge, Module)

pub fn take_module(&mut self, module_id: &ModuleId) -> Module

pub fn replace_module(&mut self, module: Module)

pub fn is_dynamic(&self, module_id: &ModuleId) -> bool

Trait Implementations

impl Default for ModuleGraph

fn default() -> Self

Returns the “default value” for a type.