Struct CssAnalyticsReport 

pub struct CssAnalyticsReport {

    pub files: Vec<CssFileAnalytics>,
    pub summary: CssAnalyticsSummary,
    pub scoped_unused: Vec<ScopedUnusedClasses>,
    pub unreferenced_keyframes: Vec<UnreferencedKeyframes>,
    pub undefined_keyframes: Vec<UndefinedKeyframes>,
    pub duplicate_declaration_blocks: Vec<CssDuplicateBlock>,
    pub tailwind_arbitrary_values: Vec<TailwindArbitraryValue>,
    pub unused_at_rules: Vec<UnusedAtRule>,
    pub unresolved_class_references: Vec<UnresolvedClassReference>,
    pub unreferenced_css_classes: Vec<UnreferencedCssClass>,
    pub unused_font_faces: Vec<UnusedFontFace>,
    pub unused_theme_tokens: Vec<UnusedThemeToken>,
    pub font_size_unit_mix: Option<CssNotationConsistency>,
}

Structural CSS analytics surfaced by fallow health --css.

Fields

files: Vec<CssFileAnalytics>

Stylesheets with at least one structurally notable rule, in scan order.

summary: CssAnalyticsSummary

Project-wide CSS aggregates across every analyzed stylesheet.

scoped_unused: Vec<ScopedUnusedClasses>

Vue SFCs whose <style scoped> defines classes used nowhere else in the component (cleanup candidates).

unreferenced_keyframes: Vec<UnreferencedKeyframes>

@keyframes defined but referenced via no animation / animation-name in any stylesheet, with the stylesheet that defines them (cleanup candidates; an animation name can still be applied from JavaScript). The “defined-but-unused” direction.

undefined_keyframes: Vec<UndefinedKeyframes>

Animation references (animation / animation-name) to a @keyframes name that is defined in NO stylesheet anywhere in the project, with the first stylesheet that references them. The “used-but-undefined” direction (the inverse of unreferenced_keyframes): usually a typo or a removed animation, occasionally a @keyframes defined in CSS-in-JS (which the CSS parser never sees). Conservative candidates, never gated findings.

duplicate_declaration_blocks: Vec<CssDuplicateBlock>

Groups of style rules across the project that share an identical declaration block (4+ declarations, sorted and !important-aware), grouped by content: copy-paste consolidation candidates (fallow’s duplication signal applied to CSS). Sorted by estimated savings descending.

tailwind_arbitrary_values: Vec<TailwindArbitraryValue>

Tailwind arbitrary-value utilities (w-[13px], bg-[#abc]) found in markup, which hardcode a one-off value instead of a configured scale token (design-token bypass). Present only when the project uses Tailwind. Sorted by use count descending. Candidates, not findings: an arbitrary value is sometimes the right call.

unused_at_rules: Vec<UnusedAtRule>

Unused CSS at-rule entities: an @property registered but never read via var() in any stylesheet, or an @layer declared but never populated by a block. Cleanup candidates (an @property can be read from JS; a layer can be populated via @import layer()). Located by first definition.

unresolved_class_references: Vec<UnresolvedClassReference>

Static class / className tokens in markup that match no CSS class defined anywhere in the project AND are one edit away from a class that IS defined (a likely typo or stale rename, with the suggested class). The CSS analogue of an unresolved import; the near-miss restriction keeps it near-zero false-positive (Tailwind utilities and third-party classes are not one edit from an authored class). Candidates, never gated: the token could be defined in CSS-in-JS or an external stylesheet the parser never sees. Sorted by (path, line, class).

unreferenced_css_classes: Vec<UnreferencedCssClass>

Global CSS classes (defined in a plain .css/.scss rule) whose literal name is referenced by NO in-project markup, static or dynamic (the CSS analogue of an unused export). Heavily gated to stay near-zero-false- positive: emitted only when the project is plain-CSS-dominant, the stylesheet is locally consumed (not a published design-system surface), and the whole project is in scope. Candidates, never gated findings: the class may be used by an HTML email, server template, CMS, or Markdown the parser never scans. Sorted by (path, line, class).

unused_font_faces: Vec<UnusedFontFace>

@font-face families declared in a stylesheet but referenced by no font-family anywhere in the project: a dead web-font payload (the font file is downloaded but never applied). Located at the declaring stylesheet. Cleanup candidates: the family could be applied from inline styles or set via JavaScript. Sorted by (path, family).

unused_theme_tokens: Vec<UnusedThemeToken>

Tailwind v4 @theme design tokens (--color-brand, --radius-card) defined in a stylesheet but used by no generated utility, var() read, @apply, or arbitrary value anywhere in the project: dead design tokens (the unused-export of the token era). Present only when the project is Tailwind v4 (a tailwindcss dependency plus at least one @theme block) and not a plugin / published-library / partial-scope run. Candidates, never gated findings: the token may be consumed by a Tailwind plugin or a downstream repo. Sorted by (path, line, token).

font_size_unit_mix: Option<CssNotationConsistency>

The project authors font-size values in several units (px, rem, em, %), with a per-unit distinct-value count: a type-scale inconsistency smell (mixing px and rem for type works against user-zoom accessibility). Present only above a conservative floor. Advisory candidate, never gated: the spread can be intentional (fixed chrome in px, body type in rem).

Color-notation mixing (hex vs rgb vs hsl) is deliberately NOT surfaced: the CSS parser canonicalizes every legacy sRGB notation to hex before fallow sees the value, so the authored distinction is already gone and cannot be recovered without a separate raw-token pass.

Trait Implementations

impl Clone for CssAnalyticsReport

fn clone(&self) -> CssAnalyticsReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CssAnalyticsReport

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

Formats the value using the given formatter.

impl Serialize for CssAnalyticsReport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.