Struct AggregatedPluginResult 

pub struct AggregatedPluginResult {

    pub entry_patterns: Vec<(PathRule, String)>,
    pub replaced_entry_plugins: FxHashSet<String>,
    pub entry_point_roles: FxHashMap<String, EntryPointRole>,
    pub config_patterns: Vec<String>,
    pub always_used: Vec<(String, String)>,
    pub used_exports: Vec<PluginUsedExportRule>,
    pub used_class_members: Vec<UsedClassMemberRule>,
    pub framework_class_member_contracts: Vec<SemanticFrameworkContract>,
    pub referenced_dependencies: Vec<String>,
    pub package_referenced_dependencies: Vec<(PathBuf, String)>,
    pub discovered_always_used: Vec<(String, String)>,
    pub setup_files: Vec<(PathBuf, String)>,
    pub tooling_dependencies: Vec<String>,
    pub plugin_tooling: Vec<PluginToolingDependencies>,
    pub script_used_packages: FxHashSet<String>,
    pub dependency_binaries: DependencyBinaries,
    pub dev_dependency_names: FxHashSet<String>,
    pub virtual_module_prefixes: Vec<String>,
    pub virtual_package_suffixes: Vec<String>,
    pub generated_import_patterns: Vec<String>,
    pub generated_type_import_prefixes: Vec<String>,
    pub path_aliases: Vec<(String, String)>,
    pub auto_imports: Vec<AutoImportRule>,
    pub active_plugins: Vec<String>,
    pub fixture_patterns: Vec<(String, String)>,
    pub scss_include_paths: Vec<PathBuf>,
    pub static_dir_mappings: Vec<(PathBuf, String)>,
    pub framework_static_dir_mappings: Vec<(PathBuf, String)>,
    pub provided_dependencies: Vec<ProvidedDependencyRule>,
    pub config_diagnostics: Vec<PluginConfigDiagnostic>,
    pub federation_sources: Vec<FederationSource>,
    pub jsx_import_sources: Vec<JsxImportSourceRule>,
    pub jsx_package_credits: Vec<JsxImportSourceRule>,
    pub tsconfig_jsx_dirs: Vec<PathBuf>,
}

Aggregated results from all active plugins for a project.

Fields

entry_patterns: Vec<(PathRule, String)>

All entry point patterns from active plugins: (rule, plugin_name).

replaced_entry_plugins: FxHashSet<String>

Plugins whose config already replaced their static entry patterns. A later config of a plugin that sets accumulate_config_entry_patterns adds to the config patterns and does not remove them.

entry_point_roles: FxHashMap<String, EntryPointRole>

Coverage role for each plugin contributing entry point patterns.

config_patterns: Vec<String>

All config file patterns from active plugins.

always_used: Vec<(String, String)>

All always-used file patterns from active plugins: (pattern, plugin_name).

used_exports: Vec<PluginUsedExportRule>

All used export rules from active plugins.

used_class_members: Vec<UsedClassMemberRule>

Class member rules contributed by active plugins that should never be flagged as unused. Extends the built-in Angular/React lifecycle allowlist with framework-invoked method names, optionally scoped by class heritage.

framework_class_member_contracts: Vec<SemanticFrameworkContract>

Exact framework contracts with plugin and package provenance.

referenced_dependencies: Vec<String>

Dependencies referenced in config files (should not be flagged unused).

package_referenced_dependencies: Vec<(PathBuf, String)>

Dependencies referenced by package.json metadata, scoped to that package.json path.

discovered_always_used: Vec<(String, String)>

Additional always-used files discovered from config parsing: (pattern, plugin_name).

setup_files: Vec<(PathBuf, String)>

Setup files discovered from config parsing: (path, plugin_name).

tooling_dependencies: Vec<String>

Tooling dependencies of every active plugin, whether or not the plugin found evidence that the project uses it. The unlisted-dependency and dev-dependency-in-production checks read this list.

plugin_tooling: Vec<PluginToolingDependencies>

Tooling dependencies grouped by the active plugin that declares them, with the evidence that decides whether an unused devDependency check credits them. See PluginToolingDependencies.

script_used_packages: FxHashSet<String>

Package names discovered as used in package.json scripts (binary invocations).

dependency_binaries: DependencyBinaries

The binary names that the declared dependencies provide. Script analysis fills it for the root result; workspace results keep the default.

dev_dependency_names: FxHashSet<String>

The names that the root and workspace manifests declare in devDependencies. Script analysis fills it for the root result, so the trace credits a dependency only where the unused devDependency check would.

virtual_module_prefixes: Vec<String>

Import prefixes for virtual modules provided by active frameworks. Imports matching these prefixes should not be flagged as unlisted dependencies.

virtual_package_suffixes: Vec<String>

Package name suffixes that identify virtual or convention-based specifiers. Extracted package names ending with any of these suffixes are not flagged as unlisted.

generated_import_patterns: Vec<String>

Import suffixes for build-time generated relative imports. Unresolved imports ending with these suffixes are suppressed.

generated_type_import_prefixes: Vec<String>

Import prefixes for build-time generated type-only relative imports. Unresolved type-only imports starting with these prefixes are suppressed.

path_aliases: Vec<(String, String)>

Path alias mappings from active plugins (prefix → replacement directory). Used by the resolver to substitute import prefixes before re-resolving.

auto_imports: Vec<AutoImportRule>

Convention-based auto-import rules from active plugins (Nuxt components). The resolver matches each file’s captured auto_import_candidates against these and synthesizes a graph edge to the rule’s source. See issue #704.

active_plugins: Vec<String>

Names of active plugins.

fixture_patterns: Vec<(String, String)>

Test fixture glob patterns from active plugins: (pattern, plugin_name).

scss_include_paths: Vec<PathBuf>

Absolute directories contributed by plugins that should be searched when resolving SCSS/Sass @import/@use specifiers. Populated from Angular’s stylePreprocessorOptions.includePaths and equivalent framework settings. See issue #103.

static_dir_mappings: Vec<(PathBuf, String)>

Static directory mappings contributed by plugins.

framework_static_dir_mappings: Vec<(PathBuf, String)>

Mounts a framework serves for the whole project, so any HTML document reaches them, unlike the tool-scoped mounts above.

provided_dependencies: Vec<ProvidedDependencyRule>

File-scoped dependency provider rules from active plugins.

config_diagnostics: Vec<PluginConfigDiagnostic>

Advisories about the config files active plugins read. Converted to workspace diagnostics once, at the end of the plugin run, where the project root is known.

federation_sources: Vec<FederationSource>

Where Module Federation configs expose files and declare remote aliases, for the trace output.

jsx_import_sources: Vec<JsxImportSourceRule>

JSX import sources that bundler and test configs set, with the files each config transforms. The resolver adds the runtime edge to each matching module with jsx_runtime_from_config set.

jsx_package_credits: Vec<JsxImportSourceRule>

Runtime packages that a JSX transform imports when its config sets no import source. The analysis credits a package only when a matching module has jsx_runtime_from_config set. These rules add no graph edge.

tsconfig_jsx_dirs: Vec<PathBuf>

The directories of the tsconfig files that set the JSX runtime of TypeScript files, so Vite does not use the default react runtime for the TypeScript files below them.

Trait Implementations

impl Clone for AggregatedPluginResult

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregatedPluginResult

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

Formats the value using the given formatter.

impl Default for AggregatedPluginResult

fn default() -> Self

Returns the “default value” for a type.