Struct ModuleGraph 

pub struct ModuleGraph { /* private fields */ }

In-memory module dependency graph.

This implementation uses HashMaps for fast lookups and is fully synchronous.

Implementations

impl ModuleGraph

pub fn dependency_chains_to( &self, target: &ModuleId, ) -> Result<Vec<DependencyChain>>

Find all dependency chains from entry points to a target module.

This traces all possible paths through the import graph, useful for understanding why a module is included in the bundle and what depends on it.

pub fn analyze_dependency_chains( &self, target: &ModuleId, ) -> Result<ChainAnalysis>

Analyze dependency chains to a module.

Provides comprehensive statistics about all paths leading to a module.

pub fn import_depth(&self, module: &ModuleId) -> Result<Option<usize>>

Get the import depth of a module from entry points.

Returns the shortest distance from any entry point to this module, or None if the module is unreachable.

pub fn modules_by_depth(&self) -> Result<HashMap<usize, Vec<ModuleId>>>

Group modules by their import depth from entry points.

This creates layers of the dependency graph, useful for visualizing the structure and understanding module organization.

pub fn is_reachable_only_through_dead_code( &self, module: &ModuleId, ) -> Result<bool>

Check if a module is only reachable through dead code.

A module is considered “reachable only through dead code” if:

• It has no direct path from any entry point, OR
• All paths to it go through unreachable modules

This is a strong indicator that the module can be safely removed.

impl ModuleGraph

pub fn new() -> Result<Self>

Create a new empty graph.

pub fn from_modules<I>(modules: I) -> Result<Self>

where I: IntoIterator<Item = Module>,

Construct a graph from an iterator of modules (without edges).

pub fn from_collected_data(collection: CollectionState) -> Result<Self>

Create a ModuleGraph from collected module data.

impl ModuleGraph

pub fn unused_exports(&self) -> Result<Vec<UnusedExport>>

Discover unused exports, respecting framework markers and namespace imports.

pub fn compute_export_usage_counts(&self) -> Result<()>

Computes and sets usage counts for all exports in the module graph.

For each export in each module, this counts how many times it’s imported across all dependent modules and updates the usage_count field.

Usage counts are determined by:

• Named imports: Each import { foo } increments the count for export “foo”
• Default imports: Each import foo increments the count for export “default”
• Namespace imports: Each import * as ns increments the count for ALL exports by 1 (except star re-exports which only forward, not consume)
• Re-exports: Counted separately as they create new import paths

After calling this method, each Export will have usage_count set to:

• Some(0) if the export is unused
• Some(n) where n > 0 for the number of import sites

impl ModuleGraph

pub async fn apply_framework_rule( &self, rule: Box<dyn FrameworkRule>, ) -> Result<()>

Apply a custom framework rule.

Framework rules mark exports as framework-used based on naming conventions. This prevents false-positive “unused export” warnings.

Note: FrameworkRule::apply is async, so we use tokio::runtime::Handle::current() to execute it. This maintains compatibility with the async trait while Apply a single framework rule asynchronously.

Platform Availability

This method is only available on native platforms (not WASM) because it requires tokio runtime support.

pub async fn apply_framework_rules( &self, rules: Vec<Box<dyn FrameworkRule>>, ) -> Result<()>

Apply multiple framework rules asynchronously.

Platform Availability

This method is only available on native platforms (not WASM) because it requires tokio runtime support.

pub fn has_dependency(&self, from: &ModuleId, to: &ModuleId) -> Result<bool>

Check if a direct dependency exists between two modules.

pub fn framework_used_exports(&self) -> Result<Vec<(ModuleId, Export)>>

Get all framework-used exports in the graph.

impl ModuleGraph

pub fn side_effect_only_imports(&self) -> Result<Vec<SideEffectImport>>

Get all side-effect-only imports across the graph.

Side-effect imports like import 'polyfill' execute code but don’t bind any values. These are important to track as they can’t be tree-shaken and always contribute to bundle size.

pub fn namespace_imports(&self) -> Result<Vec<NamespaceImportInfo>>

Get all namespace imports and their usage.

Namespace imports (import * as foo) import all exports from a module. This is useful for tracking potential over-imports that could be optimized to named imports.

pub fn type_only_imports(&self) -> Result<Vec<TypeOnlyImport>>

Get all type-only imports (TypeScript).

Type-only imports are erased at runtime and don’t contribute to bundle size. Tracking these helps understand the TypeScript structure without conflating with runtime dependencies.

impl ModuleGraph

pub fn add_module(&self, module: Module) -> Result<()>

Add a module into the graph.

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

Add a dependency edge, creating forward and reverse mappings.

pub fn add_dependencies<I>(&self, from: ModuleId, targets: I) -> Result<()>

where I: IntoIterator<Item = ModuleId>,

Add multiple dependencies from a single module.

pub fn add_entry_point(&self, id: ModuleId) -> Result<()>

Mark a module as an entry point.

pub fn add_external_dependency(&self, dep: ExternalDependency) -> Result<()>

Add an external dependency record.

impl ModuleGraph

pub fn unused_npm_dependencies( &self, package_json: &PackageJson, include_dev: bool, include_peer: bool, ) -> Result<Vec<UnusedDependency>>

Detect unused npm dependencies by cross-referencing package.json with imports.

This identifies dependencies declared in package.json but never actually imported in the codebase. Useful for cleaning up unused packages.

Parameters

• package_json: Parsed package.json file
• include_dev: Whether to check devDependencies
• include_peer: Whether to check peerDependencies

pub fn dependency_coverage( &self, package_json: &PackageJson, ) -> Result<DependencyCoverage>

Get dependency coverage statistics.

Provides detailed metrics about which dependencies are actually used vs declared in package.json.

impl ModuleGraph

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

Retrieve a module by ID.

Returns an owned Module. Internally uses Arc for efficient storage, so this clone is inexpensive (only shared data like Vec are reference-counted).

Example

let module = graph.module(module_id)?.unwrap();
println!("Path: {}", module.path.display());

pub fn module_by_path(&self, path: &Path) -> Result<Option<Module>>

Get module by filesystem path.

Returns an owned Module. Internally uses Arc for efficient storage, so this clone is inexpensive.

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

Get all modules.

Returns owned Module instances. Internally uses Arc for efficient storage, so these clones are inexpensive.

pub fn dependencies(&self, id: &ModuleId) -> Result<Vec<ModuleId>>

Dependencies of a module (forward edges).

pub fn dependents(&self, id: &ModuleId) -> Result<Vec<ModuleId>>

Dependents of a module (reverse edges).

pub fn contains(&self, id: &ModuleId) -> Result<bool>

Whether a module is present.

pub fn entry_points(&self) -> Result<Vec<ModuleId>>

Entry points set.

pub fn len(&self) -> Result<usize>

Return total module count.

pub fn is_empty(&self) -> Result<bool>

Check whether graph is empty.

pub fn imports_for_module(&self, id: &ModuleId) -> Result<Option<Vec<Import>>>

Get imports for a module.

pub fn external_dependencies(&self) -> Result<Vec<ExternalDependency>>

Aggregate external dependencies based on import data.

pub fn unreachable_modules(&self) -> Result<Vec<Module>>

Compute modules with no dependents and no side effects.

Returns owned Module instances. Internally uses Arc for efficient storage, so these clones are inexpensive.

impl ModuleGraph

pub fn to_dot_format(&self) -> Result<String>

Export the graph as DOT format for visualization.

pub fn to_json(&self) -> Result<String>

Export the graph and modules to JSON.

pub fn to_bytes(&self) -> Result<Vec<u8>>

Serialize the graph to binary format using bincode.

This includes a format version for forward compatibility and the full graph state (modules, dependencies, dependents, entry points, external deps).

Format Version

The binary format starts with a u32 version number:

• Version 1: Initial implementation with GraphInner serialization

Errors

Returns an error if serialization fails or if the graph is poisoned.

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserialize the graph from binary format.

Errors

Returns an error if:

• Deserialization fails
• The format version is incompatible with the current implementation

impl ModuleGraph

pub fn statistics(&self) -> Result<GraphStatistics>

Compute statistics snapshot for dashboards.

impl ModuleGraph

pub fn unused_symbols(&self) -> Result<Vec<UnusedSymbol>>

Get all unused symbols across the entire graph.

This queries the symbol table for each module and returns symbols that are declared but never referenced.

pub fn unused_symbols_in_module(&self, id: &ModuleId) -> Result<Vec<Symbol>>

Get unused symbols for a specific module.

Returns an empty vector if the module doesn’t exist.

pub fn all_symbols(&self) -> Result<Vec<UnusedSymbol>>

Get all symbols across the entire graph (not just unused ones).

This is useful for code quality analysis that needs to check all symbols, regardless of whether they’re used or not.

pub fn unreachable_code(&self) -> Result<Vec<UnreachableCode>>

Get unreachable code detected across the graph.

Note: Unreachable code detection must be performed during module analysis (when source code is available) rather than from the graph. Use crate::graph::semantic::detect_unreachable_code() during module building.

This method currently returns an empty vector as a placeholder for graph-level aggregation if unreachable code data is stored in modules in the future.

pub fn symbol_statistics(&self) -> Result<SymbolStatistics>

Compute symbol statistics across the entire graph.

Aggregates symbol information from all modules to provide a high-level view of symbol usage patterns.

pub fn unused_private_class_members( &self, ) -> Result<HashMap<String, Vec<UnusedSymbol>>>

Get all unused private class members across the graph, grouped by class.

Private class members are safe to remove when unused, as they cannot be accessed from outside the class. This method groups results by class name for easier analysis.

pub fn all_class_members(&self) -> Result<Vec<ClassMemberInfo>>

Get all class members (public and private) for comprehensive analysis.

This provides complete visibility into class structure, useful for refactoring and understanding class complexity.

pub fn unused_public_class_members(&self) -> Result<Vec<UnusedSymbol>>

Get unused public class members.

Warning: Removing public members is potentially breaking for library code. Use with caution and only for application code where you control all usage.

pub fn unused_enum_members(&self) -> Result<HashMap<String, Vec<UnusedSymbol>>>

Get all unused enum members across the graph, grouped by enum.

Enum members that are never referenced can often be safely removed, especially in application code. This groups results by enum for easier analysis.

pub fn all_enum_members(&self) -> Result<HashMap<String, Vec<EnumMemberInfo>>>

Get all enum members (used and unused) for comprehensive enum analysis.

This provides complete visibility into enum structure, useful for understanding enum coverage and usage patterns.

impl ModuleGraph

pub fn depends_on(&self, from: &ModuleId, to: &ModuleId) -> Result<bool>

Returns true if from depends on to (directly or transitively).

pub fn transitive_dependencies( &self, id: &ModuleId, ) -> Result<HashSet<ModuleId>>

Collect transitive dependencies of a module.

Trait Implementations

impl Clone for ModuleGraph

fn clone(&self) -> ModuleGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleGraph

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

Formats the value using the given formatter.