Struct Module 

pub struct Module {

    pub id: ModuleId,
    pub path: PathBuf,
    pub source_type: SourceType,
    pub imports: Arc<Vec<Import>>,
    pub exports: Arc<Vec<Export>>,
    pub has_side_effects: bool,
    pub is_entry: bool,
    pub is_external: bool,
    pub original_size: usize,
    pub bundled_size: Option<usize>,
    pub symbol_table: Arc<SymbolTable>,
    pub module_format: ModuleFormat,
    pub exports_kind: ExportsKind,
    pub has_star_exports: bool,
    pub execution_order: Option<u32>,
}

Resolved module metadata used by graph algorithms and builders.

Heavy collections (imports, exports, symbol_table) are wrapped in Arc to make cloning cheap when returning modules from the graph.

Fields

id: ModuleId

path: PathBuf

source_type: SourceType

imports: Arc<Vec<Import>>

exports: Arc<Vec<Export>>

has_side_effects: bool

is_entry: bool

is_external: bool

original_size: usize

bundled_size: Option<usize>

symbol_table: Arc<SymbolTable>

Symbol table from semantic analysis (intra-file dead code detection)

module_format: ModuleFormat

Module format (ESM vs CJS) from rolldown analysis

exports_kind: ExportsKind

Export structure kind (ESM, CJS, or None)

has_star_exports: bool

True if module has star re-exports (export * from)

execution_order: Option<u32>

Execution order in module graph (topological sort)

Implementations

impl Module

pub fn builder( id: ModuleId, path: PathBuf, source_type: SourceType, ) -> ModuleBuilder

Create a new module builder with sensible defaults.

pub fn mark_entry(&mut self)

Mark the module as an entry module.

pub fn mark_external(&mut self)

Mark the module as an external dependency.

pub fn set_side_effects(&mut self, has_side_effects: bool)

Toggle side-effect tracking on the module.

pub fn set_bundled_size(&mut self, size: Option<usize>)

Update bundled size information (if available).

pub fn imports_iter(&self) -> impl Iterator<Item = &Import>

Get an iterator over imports.

pub fn exports_iter(&self) -> impl Iterator<Item = &Export>

Get an iterator over exports.

pub fn exports_mut(&mut self) -> &mut Vec<Export>

Get mutable access to exports (for external tools like framework rules).

This uses Arc::make_mut to create a mutable copy only when needed.

Example

for export in module.exports_mut() {
    if export.name.starts_with("use") {
        // export.mark_framework_used(); // Method might not exist on Export, check usage
    }
}

pub fn imports_from(&self, target: &ModuleId) -> Vec<&Import>

Get imports that reference a specific module.

Example

use fob_graph::ModuleId;

let react_id = ModuleId::new("node_modules/react/index.js")?;
let imports = module.imports_from(&react_id);
assert_eq!(imports.len(), 0);

pub fn has_import_from(&self, source: &str) -> bool

Check if this module imports from a specific source specifier.

This is useful for framework detection - checking if a module imports from “react”, “vue”, “svelte”, etc.

Example

if module.has_import_from("react") {
    // This is a React module
}

pub fn import_sources(&self) -> Vec<&str>

Get all import sources (for dependency analysis).

Returns a vector of source specifiers that this module imports from.

Example

let sources = module.import_sources();
// sources = ["react", "lodash", "./utils"]

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Module

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Module

fn deserialize<__D>( __deserializer: __D, ) -> Result<Module, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Module

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

where __S: Serializer,

Serialize this value into the given Serde serializer.