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>,
}

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.

type_only_imported_by: Vec<PathBuf>

Files that import this dependency with type-only imports.

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

Total import count.

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.

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<(), Error>

Formats the value using the given formatter.

impl JsonSchema for DependencyTrace

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for DependencyTrace

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.