DEV Community: Duncan Faulkner

The WCAG AA Checklist Every Angular Component Should Pass Before You Ship

Duncan Faulkner — Sun, 12 Jul 2026 08:00:00 +0000

I've been writing Angular for ten years, and for most of them I treated accessibility the way nearly everyone does: as a thing I'd "get to" once the feature worked. It always lost the race to the deadline.

What changed my mind wasn't guilt — it was realising why a11y keeps getting skipped. It's not neglect. It's that accessibility is genuinely hard to hold in your head while you're also wrangling state, layout, and a ticket that was due yesterday. You can't fix "I forgot" with willpower. You fix it with a checklist.

So here's the one I actually use before a component ships. It's WCAG AA-oriented, Angular-specific, and ordered the way bugs actually show up. One thing up front, because it's the whole reason a list like this exists:

Automated tools catch maybe 30–40% of WCAG issues. AXE, Lighthouse and the rest are brilliant at the mechanical stuff — a missing alt, a contrast ratio, a duplicate id. They cannot tell you whether your tab order makes sense, whether your focus goes somewhere useful after a dialog closes, or whether your aria-live region actually announces anything. A green AXE run is the floor, not the finish line. I've marked each item below with whether a tool will catch it (🤖) or whether it's on you (👤).

1. Keyboard & focus

This is where most "accessible" component libraries quietly fall apart.

Everything interactive works with the keyboard alone. 👤 Unplug your mouse and drive the component. Every action reachable by click must be reachable by Tab/Enter/Space/arrows.
You used native elements where you could. 🤖/👤 A <button> is keyboard-operable, focusable and announced for free. A <div (click)> is none of those. If you're adding role="button" and a keydown handler to a div, stop and use a button.
Focus is always visible. 🤖 Never outline: none without a replacement. Use :focus-visible so keyboard users get a clear ring and mouse users aren't bothered:

  :focus-visible {
    outline: 2px solid var(--ngbr-color-focus);
    outline-offset: 2px;
  }

Tab order follows reading order. 👤 No positive tabindex. Let the DOM order do the work; if the visual order disagrees with the DOM, fix the DOM.
Focus is trapped in modal dialogs and restored to the trigger on close. 👤 Don't hand-roll this — use the CDK:

  <div cdkTrapFocus cdkTrapFocusAutoCapture role="dialog" aria-modal="true" aria-labelledby="title">
    <h2 id="title">Confirm deletion</h2>
    …
  </div>

No keyboard traps anywhere else. 👤 You can always Tab out of a component. The only legitimate trap is an open modal.

2. Focus management on dynamic changes

The single most overlooked area, and almost entirely invisible to tooling.

Route changes move focus. 👤 On navigation, an SPA leaves focus on the old (now-gone) element. Send it to the new page's heading:

  this.router.events.pipe(filter(e => e instanceof NavigationEnd))
    .subscribe(() => {
      const h1 = this.doc.querySelector('main h1') as HTMLElement | null;
      h1?.focus(); // h1 needs tabindex="-1"
    });

Opening a menu/drawer/dialog moves focus into it; closing returns focus to the trigger. 👤
Deleting an item moves focus somewhere sensible (the next row, or the list heading) — never to <body>. 👤
There's a skip link to bypass the nav and jump to <main>. 🤖/👤

3. Semantics & ARIA

The first rule of ARIA is: don't use ARIA if a native element will do.

Landmarks are present: one <main>, plus <nav>, <header>, <footer> as needed. 🤖
One <h1> per page, and headings don't skip levels. 🤖 Heading structure is how screen-reader users navigate — it's a table of contents, not styling.
Custom widgets carry the right role and state — and put them in the host object, not @HostBinding:

  @Component({
    selector: 'ngbr-switch',
    host: {
      'role': 'switch',
      '[attr.aria-checked]': 'checked()',
      '[attr.aria-disabled]': 'disabled() || null',
      'tabindex': '0',
      '(keydown.enter)': 'toggle()',
      '(keydown.space)': 'toggle(); $event.preventDefault()',
    },
  })
  export class NgbrSwitch { /* checked = signal(false) … */ }

Icon-only buttons have an accessible name. 🤖 aria-label="Close" — an icon font or SVG is silent otherwise.
No aria-* attribute references a missing id. 🤖 Dangling aria-describedby/aria-labelledby announce nothing.
You didn't slap ARIA on a native element that already had the semantics. 👤 <button role="button"> is redundant; <nav role="navigation"> is noise.

4. Forms & errors

Every input has a real <label> with a matching for/id — not just a placeholder. 🤖
Required fields expose it programmatically: [required] or aria-required="true", not just an asterisk. 🤖/👤
Errors are linked to their field and announced. 👤 Tie the message in with aria-describedby, flip aria-invalid, and give it role="alert" so it's read on appearance:

  <label for="email">Email</label>
  <input id="email" type="email" formControlName="email"
         [attr.aria-invalid]="showError()"
         [attr.aria-describedby]="showError() ? 'email-error' : null">
  @if (showError()) {
    <p id="email-error" role="alert">Enter a valid email address.</p>
  }

On submit, focus moves to the first error (or an error summary). 👤 Don't make a keyboard user hunt for what went wrong.
Error state isn't signalled by colour alone (see §5). 👤

5. Colour, contrast & motion

Text meets AA contrast — 4.5:1 for body, 3:1 for large text and UI components/focus indicators. 🤖
Information is never conveyed by colour alone. 👤 A red border needs an icon or text too — that's WCAG 1.4.1, and it's invisible to a colour-blind user and to AXE. This bites hardest in charts and status indicators.
The UI survives 200% zoom and 400% reflow without horizontal scrolling or clipping. 👤
You honour prefers-reduced-motion. 🤖/👤 Animations can trigger vestibular disorders:

  @media (prefers-reduced-motion: reduce) {
    *, *::before, *::after {
      animation-duration: 0.01ms !important;
      transition-duration: 0.01ms !important;
    }
  }

It works in both light and dark themes — derive colours from tokens so contrast holds in both, rather than hardcoding. 👤

6. Dynamic content & screen-reader UX

The stuff that separates "passes the audit" from "actually usable."

Async updates are announced. 👤 "Showing 12 results," "Saved," "Loading…" — use the CDK's LiveAnnouncer rather than hand-rolling a live region:

  private announcer = inject(LiveAnnouncer);
  // after a filter runs:
  this.announcer.announce(`${count} results`, 'polite');

Loading and busy states are exposed, e.g. aria-busy="true" on the region being updated. 👤
Images have meaningful alt (and decorative ones have alt=""). 🤖 With NgOptimizedImage, alt is mandatory — lean on it.
Data visualisations have a text equivalent. 👤 An SVG chart is invisible to a screen reader. Behind every chart there should be a visually-hidden <table> of the same data — this is the single hardest item on the list, and the one no tool will ever flag.

How to actually run this

Automated pass — wire @axe-core/playwright (or jest-axe) into CI so the 🤖 items can never regress. This is table stakes; it just can't be the whole test.
Keyboard pass — unplug the mouse, Tab through the whole flow. Most 👤 issues surface in 60 seconds.
Screen-reader pass — VoiceOver (⌘+F5 on macOS) or NVDA (free on Windows). You don't need to be an expert; just listen to whether what you hear makes sense.

That's it. None of these are exotic — they're the same dozen things, over and over, which is exactly why a checklist beats good intentions.

I got tired of running this by hand for every component, so I built it into the defaults. NgBracket is a set of Angular component packs where every one of these is handled out of the box — keyboard, focus management, ARIA, contrast, the screen-reader table behind every chart — so AA-by-default is the starting point, not a ticket for later. If accessibility is the part of your build that keeps losing the race to the deadline, that's exactly the problem it's meant to take off your plate. We're launching soon; join the waiting list for early access.

Managing Focus in Angular: Dialogs, Drawers and Route Changes Without Stranding Your Users

Duncan Faulkner — Fri, 10 Jul 2026 19:33:30 +0000

Every accessibility checklist mentions focus management, and then moves on — as if it were one item. It isn't. It's a discipline, and it's the single thing that most often separates an app that technically passes an audit from one a keyboard user can actually get through.

Here's the mental model that fixed it for me: focus is a cursor, and there is only ever one of it. For someone using a keyboard or a screen reader, focus is where they are in your app. Sighted mouse users don't think about it because their eyes and pointer move independently. Everyone else has exactly one position, and every time your UI changes what's on screen, you owe them an answer to one question:

Where does focus go now?

Get that answer wrong and the user is teleported somewhere useless — usually the top of the page, or worse, , from which they have to Tab through your entire chrome to get back. And no automated tool will tell you, because "where focus went after a state change" isn't in a DOM snapshot. Let's go through the four places Angular apps get it wrong.

Route changes: the SPA focus black hole This is the most common and most invisible bug in the entire framework. When you navigate a server-rendered site, the browser loads a new document and puts focus back at the top — predictable. In an SPA, the router swaps some DOM and focus stays on whatever you clicked, which is usually a link that no longer exists. Screen-reader users get no signal that the page changed at all.

The fix is to move focus to the new page's heading on every navigation:

@Component({ /* … */ })
export class App {
private readonly router = inject(Router);
private readonly doc = inject(DOCUMENT);

constructor() {
this.router.events
.pipe(
filter((e) => e instanceof NavigationEnd),
takeUntilDestroyed(),
)
.subscribe(() => {
const heading = this.doc.querySelector('main h1') as HTMLElement | null;
heading?.focus();
});
}
}
Two things make this work: the

needs tabindex="-1" so it's programmatically focusable without joining the tab order, and you want a skip link as the very first focusable element so people can jump past the nav to :

Skip to main content
That's it — one subscription, and every route change now announces itself.

Dialogs: trap it, then give it back A modal has two focus responsibilities, and most hand-rolled dialogs get exactly one of them.

While open, focus must be trapped inside — Tab shouldn't escape to the page behind it. Don't build this yourself; the CDK does it correctly, including the wrap-around:

Delete this project?

When it closes, focus must return to the element that opened it — otherwise it falls to and the user is stranded at the top of the page. This is the half everyone forgets:

private returnFocusTo: HTMLElement | null = null;

open() {
this.returnFocusTo = this.doc.activeElement as HTMLElement;
this.isOpen.set(true);
}

close() {
this.isOpen.set(false);
this.returnFocusTo?.focus();
}
Better still, don't manage overlays by hand at all — @angular/cdk/dialog's Dialog service handles focus trapping and restoration for you (restoreFocus is on by default). If you're opening real modals, reach for it.

Drawers, menus and disclosures: the same rule, smaller A cart drawer, a nav flyout, a filter panel — these are just modals with less drama, and the rule is identical: move focus in when it opens, return it to the trigger when it closes. A drawer that opens but leaves focus behind the overlay is a keyboard trap in reverse — the user is tabbing through content they can't even see.

For menus with arrow-key navigation, the CDK's cdk/a11y ListKeyManager / FocusKeyManager gives you roving focus (arrow keys move between items, Tab leaves the whole widget) without you writing keydown spaghetti.

Destructive actions: don't drop focus into the void Delete the row that currently has focus and — if you do nothing — focus evaporates to . The fix is to send it somewhere sensible: the next row, or if you just deleted the last one, the list heading. The trick in Angular is timing: you have to wait for the signal update to flush to the DOM before the new target exists. Use afterNextRender:

private readonly host = inject(ElementRef);
private readonly injector = inject(Injector);

removeAt(index: number) {
this.items.update((list) => list.filter((_, i) => i !== index));

afterNextRender(
() => {
const rows = this.host.nativeElement.querySelectorAll('[data-row]');
const next = rows[Math.min(index, rows.length - 1)];
(next ?? this.host.nativeElement.querySelector('h2'))?.focus();
},
{ injector: this.injector },
);
}
The same pattern covers "add item" (focus the new input), "load more" (focus the first new result), and "submit failed" (focus the first error).

And the flip side: don't steal focus
Managing focus doesn't mean grabbing it constantly. Two anti-patterns to avoid:

autofocus on load. Yanking focus into a search box on every page load fights people who navigate by heading or landmark. Only autofocus inside a modal or a deliberate single-purpose page.
Focusing on scroll or hover. Focus should follow intent (a click, a key, an explicit action), never an incidental event.
And whatever you do, keep the focus ring visible. :focus-visible gives keyboard users a clear indicator without bothering mouse users:

:focus-visible {
outline: 2px solid var(--ngbr-color-focus);
outline-offset: 2px;
}
Never outline: none without a replacement. A focus you can't see is a focus you can't manage.

How to test it in two minutes
Put your mouse down. Now drive the whole flow with Tab, Enter, Space and arrows, and after every interaction ask the one question: where did my focus go? Open a dialog — is focus inside it? Close it — did it come back to the button? Change routes — are you on the new heading? Delete something — are you on a real element, or lost at the top?

You'll find your bugs in about ninety seconds. That's the whole reason focus management gets skipped: not because it's hard, but because it's invisible until you actually try to use the thing without a pointer.

This is the kind of detail that's genuinely tedious to get right on every component — so we got it right once. NgBracket is a set of accessible-by-default Angular component packs where focus trapping, restoration and route-change handling are built in, not bolted on. We're launching soon; join the waiting list for early access.*

Why I Built an Angular Component Library Where Accessibility Isn't a Backlog Item

Duncan Faulkner — Sun, 05 Jul 2026 17:31:39 +0000

I've been building with Angular for ten years, and in that time I've watched the same thing happen on nearly every project. A component gets built, it works with a mouse, it ships. Accessibility — keyboard support, focus, ARIA, contrast, the screen-reader story — becomes a line in the backlog called something like "a11y pass". And that ticket sits there. It gets groomed, re-estimated, pulled into a sprint, bumped out of the sprint, and eventually closed as "we'll come back to it." We never came back to it.

For a long time I thought that was a discipline problem. If we just cared more, tested more, remembered more, we'd get it right. I don't believe that anymore. Accessibility keeps losing the race to the deadline not because people don't care, but because it's genuinely hard to hold in your head while you're also wrangling state, layout, data and a ticket that was due yesterday. You cannot fix a systemic problem with individual willpower. You fix it by changing the default.

That realisation is the whole reason I built what I built. This is the story of the problem I was actually trying to solve, and how I went about it.

The problem isn't "not enough components"

Let me be clear about what I was not trying to do, because it matters. I wasn't trying to make another component library. There are plenty. A few new ones have appeared just in the last few months, and they're perfectly good — nicely styled, well documented, quick to drop in.

But open the accessibility story on almost any of them and it's the same shape every time: a compliance checkbox, bolted on near the end, covering the third of WCAG that an automated tool can see. aria-label is present, contrast is fine on the light theme, AXE is green. And then you drive it with a keyboard and the dialog swallows your focus, the custom select doesn't respond to arrow keys, the chart is a blank rectangle to a screen reader, and the dark theme quietly fails contrast because nobody checked.

That's the gap. It's not a shortage of components — it's that in almost every library, accessibility is a feature you're expected to finish yourself, and modern Angular is something the library will get to eventually. I didn't want to add to the pile of components. I wanted to close that gap.

So I made two bets, and the whole thing is built on them.

Bet one: accessibility is a first-class citizen, not a compliance pass

The rule I set myself is simple to state and annoying to keep: no component ships until it works by keyboard and by screen reader. Not "until AXE is green" — AXE is a regression net for the easy third, and I run it in CI on every component, but it is not the test. The test is a human putting the mouse down and driving the whole thing with Tab, Enter, Space and arrows, then turning on VoiceOver or NVDA and listening to whether what they hear matches what's on screen.

In practice that meant solving, once and properly, all the things that normally get skipped:

Focus management as a discipline — trap it in dialogs and drawers, restore it to the trigger on close, move it to the heading on route change, send it somewhere sane after you delete the row it was sitting on. One position, always accounted for.
State that's communicated, not just coloured — aria-invalid and aria-describedby wiring errors to fields, role="alert" so they announce, live regions that actually exist in the DOM before the text arrives so a screen reader speaks them.
The hardest case, data visualisation — every chart is keyboard-navigable and carries a visually-hidden data table behind the SVG as the screen-reader source of truth, because "this picture holds information that exists nowhere else" is the single biggest blind spot in automated testing. (There's even optional audio sonification for trends, which was two weeks of my life and worth every day.)
Contrast that survives theming — every colour is a token that re-tones for dark mode and holds AA on both surfaces, verified with an automated contrast pass across every component in light and dark, not eyeballed once on white.

None of that is exotic. It's all well-understood. The point was never to invent new accessibility techniques — it was to do the known-correct thing every single time, so that the person consuming the library never has to file that "a11y pass" ticket, because it's already done.

Bet two: signals-first, because reactive accessibility is better accessibility

The second bet is that this had to be built the modern Angular way — and not for fashion. Standalone components, signals, OnPush everywhere, Material 3 tokens, strict TypeScript, zero NgModules.

Signals aren't just a nicer state primitive here; they turn out to make accessibility easier to get right. When your aria-live announcement, your aria-invalid state, your aria-current and your focus targets are all derived from signals, the accessible state can't drift out of sync with the visual state — they're computed from the same source. Reactive accessibility is more correct accessibility, almost for free. Building on the old change-detection model, you're forever remembering to keep two representations in step. With signals you compute one and both fall out of it.

It also means the library is built the way you're already building in Angular v20+ — so it drops into a modern app without dragging a NgModule-era mental model back in with it. A component library that fights your architecture isn't saving you time.

How I actually went about it

Two bets are easy to write on a slide. Holding them across a real, sellable product took some machinery:

AXE wired into CI as the automated floor, plus a structural accessibility test suite — the regression net for the third that tools can catch, so nothing slips backwards.
A browser-driven contrast harness that walks every component in both themes and fails the build on a single AA violation. That's how I know dark mode holds, rather than hoping.
A token architecture where every surface, text and semantic colour chains through shared design tokens, so theming and dark-mode contrast cascade instead of being re-hardcoded per component.
Dogfooding, relentlessly. I built the marketing site itself, its FAQ, and three complete example apps — an admin dashboard, a storefront, and a booking diary — entirely out of the packs. If a component was awkward to use or quietly inaccessible, I found out by living in it, not by reading my own docs.

Eight packs, a hundred-and-six components, all held to the same line. Built solo, which is terrifying to admit and also exactly why the defaults had to carry the weight — I can't manually re-check accessibility on a hundred components by hand every release, so it had to be baked in and enforced by tooling.

Why I'm banging this drum

I'm writing this partly because the space is getting busier, and I think the distinction is worth being loud about. More component libraries is good for Angular. But "accessible by default" and "modern by default" are not the headline feature on most of them — they're the footnote. For me they're the entire product. If a green CI check is going to tell you the truth about whether a real person can use what you shipped, the two-thirds that automated tools can't see have to already be handled. That's the thing I built, and it's the thing I'll keep making noise about.

If accessibility is the part of your build that always loses the race to the deadline — the ticket that never gets picked up — that's precisely the problem this is meant to take off your plate.

And it's not finished. Eight packs is where it starts, not where it stops — there are more in the pipeline, on a steady cadence, each held to the same line. Which is also where you come in: I'd genuinely rather build the components you're about to write by hand than guess. So if there's a widget you keep re-implementing, a pack you wish existed, or a gnarly accessibility case you've never seen a library get right — tell me. A lot of what's here started as exactly that kind of "someone should just build this properly" itch, and I'm very open to the next one being yours.

I got tired of watching accessibility lose the race, so I built the defaults instead. NgBracket is a set of Angular component packs — 8 packs, 106 components — where WCAG AA, AXE-passing, keyboard and screen-reader support are the baseline, and everything is signals-first, standalone, OnPush, Material 3 themeable, zero NgModules. We're launching soon; join the waiting list for early access.

AXE Passes, But It's Still Unusable: The Accessibility Bugs Automated Tools Can't Catch

Duncan Faulkner — Thu, 02 Jul 2026 07:10:33 +0000

There's a particular kind of false confidence that comes from a green accessibility report. The CI check passes, the Lighthouse score says 100, the AXE panel is all ticks. You ship it. And somewhere, a person using a screen reader hits your component and simply can't.

I've shipped that component. More than once. Here's what I learned the hard way: automated accessibility testing checks whether your HTML is well-formed, not whether your interface is usable. Those are very different questions, and the gap between them is where real users get stranded.

AXE is genuinely excellent — wire it into CI today if you haven't. But it works by inspecting a static snapshot of the DOM and checking it against a ruleset. It can see that an attribute is present. It cannot see whether the attribute is true, whether the sequence makes sense, or whether anything actually happens when you press a key. It catches roughly a third of WCAG issues. The other two-thirds need a human.

Let me show you the gap, with five components that all pass AXE clean.

1. The modal that swallows your focus

A dialog opens, you confirm, it closes. AXE is delighted: role="dialog", aria-modal, labelled heading, focus trapped while open. All correct.

confirm() {
  this.save();
  this.open.set(false); // ✅ AXE passes. ❌ focus just fell to <body>.
}

Here's what a keyboard user experiences: the dialog vanishes and their focus lands on <body>, at the top of the page. They've lost their place entirely and have to Tab back through the whole UI. AXE can't catch this, because where focus goes after a state change isn't in the DOM snapshot — it's in time.

The fix is to remember the trigger and restore to it:

private trigger: HTMLElement | null = null;

openDialog() {
  this.trigger = this.doc.activeElement as HTMLElement;
  this.open.set(true);
}
close() {
  this.open.set(false);
  this.trigger?.focus(); // put them back where they were
}

2. The error you can only see if you can see

A form field fails validation. A red border appears. AXE checks the label is present and the border colour has enough contrast — both fine. Green.

But the only signal that something went wrong is colour. A colour-blind user sees nothing. A screen-reader user hears nothing, because the message was never wired to the field or announced:

<!-- passes AXE, communicates nothing -->
<input formControlName="email" class="error">
<p class="error-text">Enter a valid email</p>

Nothing connects that <p> to the input, and nothing tells assistive tech it appeared. The fix is to make the error programmatic:

<input formControlName="email"
       [attr.aria-invalid]="showError()"
       [attr.aria-describedby]="showError() ? 'email-error' : null">
@if (showError()) {
  <p id="email-error" role="alert">Enter a valid email.</p>
}

Now aria-invalid states the field is wrong, aria-describedby ties the explanation to it, and role="alert" makes it announce the moment it renders. None of those three things is something AXE will ever require — it only knows the label exists.

3. The toggle that looks operable and isn't

This one is sneaky, because the ARIA is perfect:

@Component({
  host: {
    'role': 'switch',
    '[attr.aria-checked]': 'checked()',
    'tabindex': '0',
    // …no keyboard handler.
  },
})

AXE sees a valid switch with a valid aria-checked state and a tabindex. It has no way to know that pressing Space does absolutely nothing, because "is this control actually operable by keyboard" requires running it, not reading it. A mouse user toggles it happily; a keyboard user can focus it and then... nothing.

host: {
  'role': 'switch',
  '[attr.aria-checked]': 'checked()',
  'tabindex': '0',
  '(keydown.space)': 'toggle(); $event.preventDefault()',
  '(keydown.enter)': 'toggle()',
}

(Or — better — wrap a native <button> and skip the role entirely. The native element can't have this bug.)

4. The live region that never speaks

You added an aria-live region for "12 results" after filtering. Textbook. Except you did it like this:

@if (announcement()) {
  <p aria-live="polite">{{ announcement() }}</p>
}

AXE sees a valid live region and approves. But screen readers only announce changes to a live region that was already in the DOM when the change happened. By @if-ing the whole element in at the same moment as the text, you've defeated the mechanism — the region and its content arrive together, and nothing is announced. The region has to exist empty, then receive text:

<p class="sr-only" aria-live="polite">{{ announcement() }}</p>

Or skip the footgun and use the CDK's LiveAnnouncer, which maintains a persistent region for you:

private announcer = inject(LiveAnnouncer);
this.announcer.announce(`${count} results`, 'polite');

This is my favourite example because the code looks more correct than the version that works. Tooling can't tell the difference; a screen reader tells you immediately.

5. The chart that doesn't exist

You render a beautiful SVG line chart. Contrast is AA, there's a <title>, AXE is satisfied. To a screen-reader user, it is a blank rectangle. SVG internals aren't exposed as data, and "this picture conveys information that exists nowhere else on the page" is not a rule any automated tool can express.

The only real fix is to provide the same data in a form assistive tech can read — a visually-hidden table behind the visual:

<figure>
  <svg aria-hidden="true">…</svg>
  <table class="sr-only">
    <caption>Monthly revenue, Jan–Dec</caption>
    <tr><th>Month</th><th>Revenue</th></tr>
    <!-- one row per point -->
  </table>
</figure>

This is the single biggest blind spot in automated testing, and it's why data visualisation is the hardest thing in front-end accessibility.

The only test that actually works

Notice the pattern across all five: AXE was right every time. The HTML was well-formed. The bug was always in something a snapshot can't see — sequence, interaction, timing, meaning.

So keep AXE in CI. It's a brilliant regression net for the third of issues it covers, and it's free. Just don't mistake it for the test. The real test takes two minutes:

Put the mouse down and Tab through it. Can you reach and operate everything? Does focus go somewhere sane after every action?
Turn on a screen reader — VoiceOver (⌘+F5) or NVDA — and listen. Does what you hear match what's on screen?

If those two passes are clean, you've covered the two-thirds that matter most. If you only run the automated check, you've verified your HTML is tidy and learned almost nothing about whether a real person can use what you built.

This gap is exactly why I built NgBracket the way I did — every component is driven by keyboard and screen reader before it ships, not just run through AXE. Accessible-by-default means the two-thirds the tools can't see are already handled, so a green CI check is telling you the truth for once.

Introduction to Vitest and Angular

Duncan Faulkner — Sun, 13 Oct 2024 21:49:59 +0000

The Angular team deprecated Karma a few versions ago and are currently working on ways to provide an alternative 3rd party unit testing frameworks. Currently the options talked about so far are Web Test Runner (likely to be the default), this is a browser based unit test runner similar in many ways to Karma. The other option being discussed is Jest, this can be installed now but can be a little tricky sometimes to get set up and some known issues when Angular is set up to use ES builds (the default in Angular 18 onward).

The Angular team are looking at using the CLI for the installation process of these unit testing frameworks, similar to when selecting a CSS framework when creating a new project. This is all still very early on in the development cycle and may be a little way off before it becomes developer preview (currently still experimental) and no mention (as yet) of how this would work with an existing project.

Now that newer versions of Angular use Vite as a development build server and the default in Angular 18, it is now possible to use Vitest in our Angular projects. The installation process is straight forward to set up and feels less problematic than setting up Jest from my recent experience. The great news here is that Vitest has a similar syntax to Karma and Jest, so the learning curve should be fairly small.

In this post I'm going to walk through setting up and configuring Vitest in an Angular 18 application and replacing Karma . I won't be writing unit tests in this post, I'll leave that for another post, this post is about setting up Angular to use Vitest.

I'm going to start a new project for this post but this will also work on an existing project.

In a directory type the following in the terminal:

ng new my-vitest-app  && cd my-vitest-app && npm i

This will create a new Angular application called my-vitest-app, it'll change into that directory and then run npm install with our application created we can now remove Karma.

From the terminal, type:

npm uninstall karma karma-chrome-launcher karma-coverage karma-jasmine karma-jasmine-html-reporter

We don't need to uninstall @types/jasmine and jasmine-core as Vitest uses Jasmine under the hood, we can use it and describe from Jasmine so we don't need to import anything in our test files. It is possible to use it and describe from Vitest but in doing so we won't be able to use functions like fakeAysnc in our unit tests.

The easiest way to get Vitest installed in our project is to use a plugin and AnalogJS has just what we need to setup and configure Vitest for us.

From the terminal type:

npm i @analogjs/platform -D

Followed by:

ng g @analogjs/platform:setup-vitest --project my-vitest-app

Once complete the following files will be generated:

// vite.config.mts
/// <reference types="vitest" />
import angular from '@analogjs/vite-plugin-angular';
import { defineConfig } from 'vite';

// https://vitejs.dev/config/
export default defineConfig(({ mode }) => {
  return {
    plugins: [
      angular(),
    ],
    test: {
      globals: true,
      environment: 'jsdom',
      setupFiles: ['src/test-setup.ts'],
      include: ['**/*.spec.ts'],
      reporters: ['default'],
    },
    define: {
      'import.meta.vitest': mode !== 'production',
    },
  };
});

vite.config.mts will be in the root of the project, this sets up the configuration for Vitest, what environment to use, the default is jsdom, you can change this to happy-dom (you will need to install happy-dom). The test-setup.ts will be in the src directory and this sets up the test environment.

import '@analogjs/vitest-angular/setup-zone';
import {
  BrowserDynamicTestingModule,
  platformBrowserDynamicTesting,
} from '@angular/platform-browser-dynamic/testing';
import { getTestBed } from '@angular/core/testing';

getTestBed().initTestEnvironment(
  BrowserDynamicTestingModule,
  platformBrowserDynamicTesting()
);

If you are using azoneless application then the test-setup.ts will be slightly different:

import '@analogjs/vitest-angular/setup-snapshots';

import {
  BrowserDynamicTestingModule,
  platformBrowserDynamicTesting,
} from '@angular/platform-browser-dynamic/testing';
import { getTestBed } from '@angular/core/testing';

getTestBed().initTestEnvironment(
  BrowserDynamicTestingModule,
  platformBrowserDynamicTesting()
);

In angular.json the test section will be replaced with:

 "test": {
    "builder": "@analogjs/vitest-angular:test"
 }

And finally the tsconfig.spec.json will be update to:

{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "outDir": "./out-tsc/spec",
    "types": [
      "jasmine",
      "vitest/globals" // added
    ],
    "target": "es2016" // added
  },
  "include": [
    "src/**/*.spec.ts",
    "src/**/*.d.ts"
  ],
  "files": [
    "src/test-setup.ts" // added
  ]
}

To run Vitest tests we need to change the scripts section, in our applications package.json file add:

{
 // other scripts
 "test" : "vitest"   
}

Using npm run test will run all of our test files our project.

If you don't want to install Volta you can skip this section.

To run Vitest from the terminal we need to install Vitest, we have a couple of options, globally using npm i -g vitest, I tend to use Volta, this is a tool chain manager, similar to Node Version Manager (NVM) but Volta handles other JavaScript tooling other than just Node.

If you currently have a version of node installed, you will need to uninstall this first before install Volta, once Volta is installed we can install multiple versions of node without removing the previous versions.

To install Volta head over to https://volta.sh/ and get the appropriate installer package for your operating system, I'm using Ubuntu and all we need for this is:

# install volta
curl https://get.volta.sh | bash
# install node
volta install node@20.15.0

As a side note, one of the nice features of Volta, is the ability to pin the version of node we are using to our package.json file, meaning that Volta will always select the correct version of Node, this is real handy when working in a team of developers, to pin a version of Node to our package.json file run volta pin node@20.15.0.

With volta and node installed we can now install Vitest:

volta install vitest

With Vitest installed we can run volta ls this will show a list of the tooling that we have installed.

# example listing from Volta
⚡️ Currently active tools:

    Node: v20.15.1 (default)
    Tool binaries available:
        vitest (current @ /home/repo/vitest-app/package.json)

With everything installed we can now run our unit tests, if we want to run a selection of tests (or a specific test) then we need to use the terminal and pass in an additional parameter, this parameter will run any test file that contains this parameter.

# run a range of unit tests
vitest dashboard

We can also specify a file, this will only run a unit test that matches the file name, note that this doesn't support regex or glob patterns.

# run a specific unit test
vitest app.component

The above will run the unit tests and watch for changes, to run the unit test once and not watch for changes we can change the command to:

# run unit test(s) once then stop
vitest run [optionally specify an additional parameter]

If we want to run our unit tests in a CI environment we don't need for them to be in watch mode, so add a test:ci to the script section of the package.json file.

{
 // other scripts
 "test" : "vitest",
 "test:ci" : "vitest run"
}

We need to set up our build pipelines to run our tests, setting up build pipelines is out of scope for this post, so I will assume you know how to do this, if not they are plenty of posts on how to do this.

The next part I want to cover is code coverage, so we've written our unit tests for our various features in our project, but have we written enough? Have we covered the important parts that need testing? This is where code coverage comes to the rescue. Code Coverage tell us how much of our feature is covered by unit tests, whether we've missed a path, for example we've covered the if condition but not the else condition.

Let's add a new script to the scripts section of our package.json file.

{
// other scripts    
"coverage":"vitest run --coverage"
}

With this we can run npm run coverage locally and will create a coverage directory for us in the root of the project and we'll get a table of files along with their code coverage:

File	% Stmts	% Branch	% Funcs	% Lines	Uncovered Line #s
All files	100	100	100	100
app.component.ts	100	100	100	100

When we run this it might prompt to install a supporting package this can be either coverage-v8 (the default) or coverage-instanbul package, if not we can install them manually using:

# For v8
npm i -D @vitest/coverage-v8

# For istanbul
npm i -D @vitest/coverage-istanbul

We can set the provider type in the coverage section in the vite.config.mts file:

export default defineConfig(({ mode }) => {
  return {
    plugins: [angular()],
    test: {
      globals: true,
      environment: "jsdom",
      setupFiles: ["src/test-setup.ts"],
      include: ["**/*.spec.ts"],
      reporters: ["default"],
      coverage: {
        provider: "v8",
        reporter: ["text", "json", "html"],
      },
    },
    define: {
      "import.meta.vitest": mode !== "production",
    },
  };
});

To run code coverage in our CI environment we need to adjust our test:ci script to include a reporter, here I've used junit and junit.xml and there is a handy plugin for Azure Devops to read the junit.xml file which will import the file and create a nice dashboard for us.

script:{
// other scripts
"test:ci": "vitest run --reporter=default --reporter=junit --outputFile=reports/junit.xml",
}

In Azure devops we can add the PublishTestResults task in our build pipelines and would have the task run after our unit tests have completed.

When we run our unit tests the results will be displayed in the terminal (unless running in a CI environment), but if you prefer to see the results in a browser this is also possible, first we need to install the ui tooling:

npm i @vitest/ui

You will need to match the version of @vitest/ui to the same version of vitest installed on your system, once installed we can start it by running vitest --ui from the terminal, if we add the html to the reporters array in our vite.config.ts file, this will create an html directory with all the files.

export default defineConfig(({ mode }) => {
  return {
    plugins: [angular()],
    test: {
      globals: true,
      environment: "jsdom",
      setupFiles: ["src/test-setup.ts"],
      include: ["**/*.spec.ts"],
      reporters: ["default", "html"], // add html into this array.
      coverage: {
        provider: "v8",
        reporter: ["text", "json", "html"],
      },
    },
    define: {
      "import.meta.vitest": mode !== "production",
    },
  };
});

Conclusion

In this post we looked at installing and setting up Vitest, a unit test runner in for Angular applications based on Vite, we also added code coverage to our test runs to see how much code coverage our unit tests cover, we also learnt how we can set this up in our CI in Azure Devops.

Using Mat-Icon Component – Part Two

Duncan Faulkner — Mon, 27 Jan 2020 13:27:00 +0000

Blog Post #002

Duncan Faulkner – January 2020

I hadn’t intended to write about this just yet, but I got a chance to investigate this sooner than I had thought. I was refactoring part of a project that was using the Mat-Icon component, with an icon.module.ts file as I’d discussed in the previous post.

I wanted to see if I could improve on the code and reduce the amount of repeated code by iterating over a file and registering the icons.

I started with a JSON file and populated it with some image names and added the HttpClientModule to use an http.get() method to read the JSON file. All good so far, the file is reading and looping with image names being returned and passed into the matIconRegistery.addSvgIcon() method.

I thought I might get some issues, but it all seemed to work fine, except the application was erroring, the issue was that the application was loading before the call to the JSON file had returned with the results, so even though I was getting images and registering icons, the app had already tried to use the icons and they weren’t there at that point, and the images were being returned after the app had started.

OK, so may be this is a timing issue and it doesn’t work in the icon.module.ts file, so I moved code to the app.component.ts file. Nope, the results were the same. This was not the result I was expecting and it was a little odd because the icon.module.ts file was loading images before.

I’m going to revisit this at a later date, as I would like to understand what the issue is and why it was behaving the way it did, my guess is it has something to do with the http.get() request and the timing around that.

But as I needed to get this refactoring completed I needed to look for another solution.

After a bit of research I found an answer and that was to create a service to handle the iterating and registering of icons. Instead of a JSON file to store a list of images the solution was an enum, with a key value structure.

export enum Icons {
    add = 'add',
    power = 'power',
    save = 'save'
}

To keep things simple I’ve made the key and the image name the same.

The service is quite simple:

// imports
import { Icons } from '../image.enum';

@Injectable({ providedIn: 'root'})
export class IconService {
  constructor(
     private matIconRegistry: MatIconRegistry,
     private sanitizer: Domsanitizer
){}

registerIcons(): void {
   this.load(Object.values(Icons), 'assets/images/icons');
}

private load(key: string[], url: string): void {
   key.forEach(icon => {
     this.matIconRegistry.addSvgIcon(
       icon, 
       this.sanitizer.bypassSecurityTrustResourceUrl(`${url}/${icon}.svg`)
   ); 
 });
 }
}

And on the app.component.ts file call the registerIcons() function.

// imports
import { IconService } from './icon.service';

export class AppComponent implements OnInit {
   constructor(private iconService: IconService) {
      this.iconService.registerIcons();
   }

}

And that’s it, not what I had in mind when I started this, but it does deliver what I wanted to do, and that was to reduce the amount of code to register icons. Though I guess the enum could get pretty lengthy if there are a lot of images.

I have to thank Stefanos Kouroupis -dev.to – for his article and code on this as I wouldn’t have thought about using a service for this and this has changed my thinking. I wanted to include here it as a follow up to my previous post for completeness, you can see his full article here https://dev.to/elasticrash/using-custom-made-svg-icons-through-the-angular-material-library-2pif.

I will add a github repo of the code in a day or two.

Original article published at: https://anglebrackets.io/index.php/2020/01/25/using-mat-icon-component-part-two/

Angular Materials Mat-Icon component

Duncan Faulkner — Thu, 14 Nov 2019 18:34:22 +0000

Using local SVG images.

Blog post #001

Duncan Faulkner - October 2019

When developing an Angular application with Angular Material, there comes a point when we need to add icons on our components, or buttons etc... Angular Material has the Mat-Icon component for doing this. This component works with web fonts like Font-Awesome for instance, simply by adding the name of the image required and an image is displayed.

For example:

<mat-icon>home</mat-icon>

Note: Requires Angular application and Angular Material is installed/configured and a reference to a web font like Font-Awesome library is all set up

But what about if you have custom icons that are not part of a web font? And would like to makes changes to the icon, for example: change the colour on hover or on a specific condition at run time?

In a recent project I had a bespoke set of SVG icons, the Angular web application was to be installed on a server that didn't have access to the internet, so the images had to be local. I wanted to use the Mat-Icon component out of the box (in an early version of the project I had a custom icon component). I still wanted to be able to change the colours of the icons at various stages throughout the application based on certain conditions as well as on hover. This post covers how I achieved that.

SVG Icons

There are a number of different ways to register an icon with the Mat-Icon component, this post discusses addSvgIcon, the others are addSvgIconInNamespace, addSvgIconLiteral or addSvgIconLiteralInNamespace and are all methods of MatIconRegistry and I might cover these in more detail in a future post.

Setting up an Angular project

Note In this post, I'm not going to step through the creation of an Angular application as there are so many already online. Plus I tend to create Nx workspaces for all my Angular projects as I prefer this project layout. I plan to do a blog post on this very soon, for the moment though see Getting started with Narwhal's Nx Workspaces.

In the newly created Angular project, create a shared directory and add a new file named material.module.ts. I like to separate Angular Material imports into their own module, I also create a separate module for other 3rd party components, just makes it easier to import later, especially using the Nx workspace layout and feature folders.

In the material.module.ts

// Material Module example.
// All other Angular Material component imports here
// but the important ones are...
import {MatIconModule, MatIconRegistry} from '@angular/material/icon';

@NgModule({
    declarations: [],
    imports: [
    // Other material imports removed for brevity,
    MatIconModule],
    exports: [
    // Other material exports removed for brevity,
    MatIconModule, MatIconRegistry
    ],
    entryComponents: [],
    providers: [MatIconRegistry]
})
export  class  MaterialModule  {}

MatIconModule is the module for the component, and the MatIconRegistry is a service to register and display icons. Add a reference to the material.module.ts in the app.module.ts. Don't forget to export it as well, otherwise it won't be available and Angular will not know anything about the Angular Material components.

// Include the material module in app.module.ts
import  {  BrowserModule  }  from  '@angular/platform-browser';
import  {  NgModule  }  from  '@angular/core';
import  {  AppComponent  }  from  './app.component';
import  {  BrowserAnimationsModule  }  from  '@angular/platform-browser/animations';
import  {  MaterialModule  }  from  './shared/material.module';

@NgModule({
declarations:  [AppComponent],
imports:  [BrowserModule,  BrowserAnimationsModule,  MaterialModule],
providers:  [],
bootstrap:  [AppComponent]
})
export  class  AppModule  {}

Now we have the Angular Material components set up and configured we need to register the icons, before we can use them. For the moment we are just going to add these to the app.component.ts to get up and running, we'll look at a better method later on.

// First Example
@Component({
    selector: 'app-root',
    templateUrl: './app.component.html',
    styleUrls: ['./app.component.scss']
})
export class AppComponent {
    constructor (
        private matIconRegistry: MatIconRegistery
    ){
    this.matIconRegistry.addSvgIcon('home','assets/img/icon/home.svg');
    this.matIconRegistry.addSvgIcon('add','assets/img/icon/add.svg');
    }
    // or we could do this, and chain the addsvgIcon methods.
    // we'll use this method going forward in this post
    // {
    //      this.matIconRegistry.addSvgIcon('home','assets/img/icon/home.svg')
    //      .addSvgIcon('add','assets/img/icon/add.svg');
    // }
}

Add this to the app.component.html page, we'll discuss this in more detail in a bit.

<!-- First HTML example -->
<div>
    <mat-icon svgIcon="home"></mat-icon>
    <mat-icon svgIcon="add"></mat-icon>
</div>

At this point we are not going to see much in the browser as we have an issue with the image URL. If you open the browsers console section, you will see the following error:

Error: unsafe value used in a resource URL context.

So what does this error mean? A brief explanation from the Angular Material website says:

To prevent an Cross Site Scripting (XSS), SVG URL's and HTML strings passed to MatIconRegistry must be marked as trusted by the Angular's DomSanitizer service. Icons are fetched via XmlHttpRequest and must have their URL's on the same domain as the containing page or configured to allow cross-domain access.

So lets add the DomSanitizer and fix this issue.

// Second Example - with the DomSanitizer
@Component({
    selector: 'app-root',
    templateUrl: './app.component.html',
    styleUrls: ['./app.component.scss']
})
export class AppComponent {
    constructor (
        private domSanitizer: DomSanitizer, 
        private matIconRegistry: MatIconRegistery
    ){
    this.matIconRegistry
    .addSvgIcon('home',this.domSanitizer.bypassSecurityTrustResourceUrl('assets/img/icon/home.svg')
    .addSvgIcon('add',this.domSanitizer.bypassSecurityTrustResourceUrl('assets/img/icon/add.svg')
    // add other icons here....;
    }
}

The call to bypassSecurityTrustResourceUrl takes a URL as a parameter and sanitizes it so that an attacker cannot inject a 'JavaScript:` URL for example, see official documentation on DomSanitizer.
Now that we have this in place we should now see two icons in the browser.

If we have a lot of icons to add this means lots of typing and lots of repetitive code, so lets refactor this some more. Start by removing all of this code (including the constructor) from the app.component.ts. This shouldn't really be in the app.component.ts file. Lets create another new module in the shared directory and call it icon.module.ts and then add the following:

typescript // Third Example - icon module import { NgModule } from '@angular/core'; import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser'; import { MaterialModule } from '../shared/material.module'; import { MatIconRegistry } from '@angular/material/icon'; @NgModule({ declarations: [], imports: [MaterialModule], exports: [], providers: [] }) export class IconModule { private path: string = '../../assets/images'; // change this constructor( private domSanitizer: DomSanitizer, public matIconRegistry: MatIconRegistry ) { this.matIconRegistry .addSvgIcon('home', this.setPath(${this.path}/home.svg)) .addSvgIcon('add', this.setPath(${this.path}/file-plus.svg)); } private setPath(url: string): SafeResourceUrl { return this.domSanitizer.bypassSecurityTrustResourceUrl(url); } }
Overall, that's not too bad, we are only writing out the domSanitizer code once in the private method but more importantly, all the code is out of the app.component.ts file and is now a self contained module. If there are a lot of icons to add then this file will get a bit long, but the typing has gotten shorter (well, a little shorter at least). You could change the constructorto iterate through a .json file of image names, the path wouldn't change and could be a const, which would only mean maintaining a .json file with any new images. I might look at doing that in a follow up post.

Note: Don't forget to add this new icon.module.ts to the app.module.ts otherwise it won't work.

Using the Mat-Icon component

So how do we use the mat-icon component? As seen earlier in this post we add the following code to our app.components.html page.

`html

`
This is a very simple example is showing how to put a home and an add icon on a page/component. This is not too dissimilar to how we would use this component with web fonts, but we are now using the svgIcon input property. The value we give to this input is the first parameter used in our call to register the .addSvgIcon('home', ...) in this case home.

Now we have an icon in place, how do we change the colour of the icon when someone hovers over it for example.

Change the icon colour

A Home icon.
Example icon copy this into a file with the SVG extension.
svg <svg version="1.1" width="24" height="24" viewBox="0 0 24 24"><path d="M10,20V14H14V20H19V12H22L12,3L2,12H5V20H10Z" fill="#00FFFF" /></svg>
In the above XML, I've removed all the namespaces etc... The main part here is the fill="#00FFFF" this sets the colour for the image, in this case to AquaMarine.

If the fill="#00..." property is not there and you want a different colour to the default black, then you can add it to the path as above, it's optional.

I usually add the fill property and set it to white and then change them in SCSS as and when required (but because this example had a white the background I used another colour).

`html
!<-- Second HTML example -->

!&lt;-- other code omitted for brevity --&gt; 
<a>

</a>

`
Add a class to the mat-icon html tag, as above and then add the SCSS, for the class. So when a user hovers over the button the colour of the icon changes.

scss .btn-icon { &:hover { path { fill: rgba(#00ffff, 1); } } }
Note One thing I did forget to add to the app.component.ts above, was the following line:
encapsulation: ViewEncapsulation.None, without this then the hover affect doesn't work.

typescript @Component({ selector: 'mat-icon-demo-root', templateUrl: './app.component.html', styleUrls: ['./app.component.scss'], encapsulation: ViewEncapsulation.None, }) export class AppComponent { title = 'mat-icon-demo'; }
Enjoy!

There is a github repo for this blog post at:
https://github.com/Anglebrackets-io/mat-icon-demo