Struct deno_graph::ModuleGraph

pub struct ModuleGraph {
    pub roots: Vec<ModuleSpecifier>,
    pub imports: IndexMap<ModuleSpecifier, GraphImport>,
    pub redirects: BTreeMap<ModuleSpecifier, ModuleSpecifier>,
    pub npm_packages: Vec<PackageNv>,
    pub has_node_specifier: bool,
    pub packages: PackageSpecifiers,
    /* private fields */
}

The structure which represents a module graph, which can be serialized as well as “printed”. The roots of the graph represent the “starting” point which can be located in the module “slots” in the graph. The graph also contains any redirects where the requested module specifier was redirected to another module specifier when being loaded.

Fields

roots: Vec<ModuleSpecifier>

imports: IndexMap<ModuleSpecifier, GraphImport>

redirects: BTreeMap<ModuleSpecifier, ModuleSpecifier>

npm_packages: Vec<PackageNv>

has_node_specifier: bool

packages: PackageSpecifiers

Implementations

impl ModuleGraph

pub fn new(graph_kind: GraphKind) -> Self

pub fn graph_kind(&self) -> GraphKind

pub async fn build<'a>( &mut self, roots: Vec<ModuleSpecifier>, loader: &dyn Loader, options: BuildOptions<'a> ) -> Vec<BuildDiagnostic>

pub fn build_fast_check_type_graph( &mut self, options: BuildFastCheckTypeGraphOptions<'_> )

pub fn segment(&self, roots: &[ModuleSpecifier]) -> Self

Creates a new cloned module graph from the provided roots.

pub fn walk<'a>( &'a self, roots: &'a [ModuleSpecifier], options: WalkOptions ) -> ModuleEntryIterator<'a>

Iterates over all the module entries in the module graph searching from the provided roots.

pub fn contains(&self, specifier: &ModuleSpecifier) -> bool

Returns true if the specifier resolves to a module within a graph, otherwise returns false.

pub fn module_errors(&self) -> impl Iterator<Item = &ModuleError>

Returns any module errors found in the graph.

NOTE: This does not return any resolution errors.

pub fn get(&self, specifier: &ModuleSpecifier) -> Option<&Module>

Get a module from the module graph, returning None if the module is not part of the graph, or if when loading the module it errored. If any module resolution error is needed, then use the try_get() method which will return any resolution error as the error in the result.

pub fn modules(&self) -> impl Iterator<Item = &Module>

Return a vector of references to module objects in the graph. Only modules that were fully resolved are present, as “errors” are omitted. If you need to know what errors are in the graph, walk the graph via .walk or if you just need to check if everything is “ok” with the graph, use the .valid() method.

pub fn resolve(&self, specifier: &ModuleSpecifier) -> ModuleSpecifier

Resolve a specifier from the module graph following any possible redirects returning the “final” module.

pub fn resolve_dependency( &self, specifier: &str, referrer: &ModuleSpecifier, prefer_types: bool ) -> Option<ModuleSpecifier>

Resolve a dependency of a referring module providing the string specifier of the dependency and returning an optional fully qualified module specifier.

The prefer_types flags indicates if a type dependency is preferred over a code dependency. If true, a type dependency will be returned in favor of a code dependency. If false a code dependency will be returned in favor of a type dependency. The value should be set to true when resolving specifiers for type checking, or otherwise false.

pub fn resolve_dependency_from_module( &self, specifier: &str, referring_module: &Module, prefer_types: bool ) -> Option<ModuleSpecifier>

pub fn resolve_dependency_from_dep( &self, dependency: &Dependency, prefer_types: bool ) -> Option<ModuleSpecifier>

pub fn specifiers( &self ) -> impl Iterator<Item = (&ModuleSpecifier, Result<&Module, &ModuleError>)>

Return the entries of the specifiers in the graph, where the first value is a module specifier and the second value is a result that contains a tuple of the module specifier, module kind, and media type, or the module graph error.

pub fn try_get( &self, specifier: &ModuleSpecifier ) -> Result<Option<&Module>, &ModuleError>

Retrieve a module from the module graph. If the module identified as a dependency of the graph, but resolving or loading that module resulted in an error, the error will be returned as the Err of the result. If the module is not part of the graph, or the module is missing from the graph, the result will be Ok with the option of the module.

pub fn try_get_prefer_types( &self, specifier: &ModuleSpecifier ) -> Result<Option<&Module>, &ModuleError>

Similar to try_get, but will prefer resolving to the types dependency if the module has one.

pub fn valid(&self) -> Result<(), ModuleGraphError>

Walk the graph from the root, checking to see if there are any module graph errors on non-type only, non-dynamic imports. The first error is returned as as error result, otherwise ok if there are no errors.

pub fn specifiers_count(&self) -> usize

Gets the approximate number of specifiers in the graph.

This is useful for pre-allocating actions that will take place on the graph.

Trait Implementations

impl Clone for ModuleGraph

fn clone(&self) -> ModuleGraph

Returns a copy 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.

impl Serialize for ModuleGraph

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

where __S: Serializer,

Serialize this value into the given Serde serializer.