Struct DependencyTrace 

pub struct DependencyTrace {
    pub package_name: String,
    pub imported_by: Vec<PathBuf>,
    pub type_only_imported_by: Vec<PathBuf>,
    pub used_in_scripts: bool,
    pub is_used: bool,
    pub import_count: usize,
    pub peer_of: Vec<String>,
    pub sources: Vec<TraceSource>,
    pub tooling_credit: Option<ToolingCredit>,
    pub unused_in: Vec<PathBuf>,
    pub usage: Option<DependencyUsage>,
}

Result of tracing a dependency: where it is used.

Fields

package_name: String

The dependency name being traced.

imported_by: Vec<PathBuf>

Files that import this dependency, each listed once.

type_only_imported_by: Vec<PathBuf>

Files whose every import of this dependency is type-only, each listed once.

used_in_scripts: bool

Whether the dependency is invoked from package.json scripts, CI configs or git hooks.

is_used: bool

Whether the dependency is used at all: imported, invoked from scripts, or listed as a peer by a used package (peer_of).

import_count: usize

Number of files that import this dependency.

peer_of: Vec<String>

Used packages that list this dependency in their installed peerDependencies, required or optional, sorted by name. The unused-dependency check credits such a peer, because the package that lists it loads it at runtime. Absent when no used package lists it.

sources: Vec<TraceSource>

The configs that declare this name as a Module Federation remote alias under remotes, one per config. A remote alias is provided by a remote container at runtime, not by an npm package. Absent when no Federation config declares the name (issue #2796).

tooling_credit: Option<ToolingCredit>

Why the unused devDependency check credits the dependency as tooling when no file imports it and no script, CI workflow or git hook runs it. When present, is_used is true. Absent otherwise.

unused_in: Vec<PathBuf>

The manifests that the unused-dependency check flags for this name, relative to the project root and sorted. The check reads each declaring manifest on its own. An import credits the nearest manifest that installs the package, so a name that one workspace uses can still be unused in the root manifest or in another workspace. Absent when no manifest is flagged.

usage: Option<DependencyUsage>

How the code uses each imported name of the dependency. Present on fallow trace --dependency, and on the MCP trace_dependency tool when a usage parameter is set. Absent on fallow dead-code --trace-dependency. The object has its own schema_version.

Implementations

impl DependencyTrace

pub fn apply_unused_declarations( &mut self, results: &AnalysisResults, root: &Path, )

Record the manifests that the unused-dependency report flags for this name, so the trace names each declaration that the report lists.

pub fn apply_tooling_credit(&mut self, credit: Option<ToolingCredit>)

Attach the tooling credit of an otherwise unused dependency and count the dependency as used, so the trace agrees with the unused-dependency report. A dependency that an import or a script already uses keeps no credit, because the credit does not decide its status.

Trait Implementations

impl Debug for DependencyTrace

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

Formats the value using the given formatter.

impl Serialize for DependencyTrace

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

where __S: Serializer,

Serialize this value into the given Serde serializer.