Struct AggregatedPluginResult 

pub struct AggregatedPluginResult {

    pub entry_patterns: Vec<(PathRule, 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 script_used_packages: 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>,
}

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).

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 (should not be flagged as unused devDeps).

script_used_packages: FxHashSet<String>

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

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.

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.