~10 min de lecture

Angular 22.3 : une route qui plante n'affiche plus de page blanche

Ta page de détail produit lit une réponse d'API. Un jour, un champ arrive null et le template lève une erreur au premier rendu. Pour le router, tout va bien : la navigation réussit, l'URL passe à /product. Pour ton utilisateur, la page précédente a disparu et la nouvelle est vide. Ton ErrorHandler reçoit l'erreur. Ton utilisateur, lui, reçoit une page blanche.

En septembre, la 22.2 a ajouté @boundary, un bloc de template qui isole un composant qui plante (détail dans l'article sur @boundary). Mais il fallait le poser à la main, bloc par bloc. Angular 22.3, sortie le 18 novembre 2026, monte le même filet d'un étage : la route elle-même peut déclarer un composant d'erreur. Le nom officiel de ce filet : les error boundaries du router.

Tout ce qui suit a été exécuté sur @angular/core et @angular/router 22.3.0, en zoneless, avec Vitest et dans une app bootstrapée. Les error boundaries du router sont marquées @developerPreview 22.3 (developer preview : utilisable, mais l'API peut encore bouger). Côté installation, le 18 novembre au soir, le framework était en 22.3.0 sur le tag latest alors que @angular/cli et @angular/build étaient encore en 22.2.7.


TL;DR

Le cas Avec withErrorBoundaries() et errorComponent
Une expression du template au premier rendu errorComponent affiché, il reçoit l'erreur
ngOnInit ou le constructeur errorComponent affiché
Une expression qui casse après une interaction errorComponent affiché
Un handler (click) Pas attrapé : l'erreur part vers ErrorHandler, la page reste en place
Un RedirectCommand levé pendant le rendu Redirection effectuée (nouveau), et onError appelé avec le RedirectCommand
Ton ErrorHandler maison Plus appelé pour les erreurs attrapées par la route, ni handleError ni onViewError

Et à côté : HttpClient.query() pour la méthode HTTP QUERY, les opérateurs ++ et -- dans les templates, et un nouveau diagnostic qui attrape [style.width]="200".


Avant : une navigation réussie, une page vide

Un composant de route qui lève une erreur dans son template. Rien d'exotique, c'est le null que l'API n'était pas censée renvoyer.

@Component({
  selector: 'app-product-page',
  template: `<h1>{{ title() }}</h1>`,
})
export class ProductPage {
  private readonly product = signal<{ name: string } | null>(null);

  protected title(): string {
    const product = this.product();
    if (product === null) throw new Error('product missing');
    return product.name;
  }
}
export const routes: Routes = [{ path: 'product', component: ProductPage }];

Mesuré dans une app bootstrapée, en 22.2.7 comme en 22.3.0 sans la nouvelle fonctionnalité : router.navigateByUrl('/product') résout true, l'URL change, la page précédente est détruite, et le DOM contient un <h1></h1> vide. L'erreur arrive dans ErrorHandler.handleError. Si l'erreur est levée dans le constructeur, c'est pire : la navigation échoue (NavigationError, et navigateByUrl() rejette avec l'erreur), l'URL revient en arrière, mais l'outlet (la zone où le router affiche le composant de la route) reste vide quand même.

Attention si tu mesures avec RouterTestingHarness : navigateByUrl() y rejette avec product missing. Ce n'est pas le router, c'est le detectChanges() que le harness lance après la navigation, et TestBed relance l'erreur. En vrai, pour une erreur de template, rien ne rejette.

Les seules parades jusqu'ici : mettre chaque bout de template à risque dans un @boundary, ou valider la donnée avant le rendu.


Après : errorComponent sur la route

Deux pièces. D'abord, la fonctionnalité s'active dans provideRouter :

import { provideRouter, withErrorBoundaries } from '@angular/router';

export const appConfig: ApplicationConfig = {
  providers: [provideRouter(routes, withErrorBoundaries())],
};

Ensuite, la route déclare le composant à afficher quand le sien plante. Ce composant reçoit l'erreur dans un input() nommé error, que le router remplit lui-même.

@Component({
  selector: 'app-route-error',
  template: `
    <p role="alert">Cette page n'a pas pu s'afficher.</p>
    <a routerLink="/">Retour à l'accueil</a>
  `,
  imports: [RouterLink],
})
export class RouteError {
  readonly error = input.required<Error>();
}

export const routes: Routes = [
  { path: 'product', component: ProductPage, errorComponent: RouteError },
];

Même navigation, même erreur : cette fois l'outlet affiche RouteError au lieu d'une page vide. Même résultat pour une erreur levée dans ngOnInit, dans le constructeur, et dans une expression qui ne casse qu'après un clic qui change un signal() : les quatre cas finissent sur le composant d'erreur. Et naviguer ensuite vers une autre route affiche cette autre route normalement : la page d'erreur n'est pas un cul-de-sac. En revanche, avec la config par défaut, renaviguer vers la même URL ne relance rien : la navigation est ignorée et le composant d'erreur reste affiché. Pour un bouton "Réessayer", passe l'option à cette navigation : router.navigateByUrl(url, { onSameUrlNavigation: 'reload' }) reconstruit le composant de la route. withRouterConfig({ onSameUrlNavigation: 'reload' }) fait de même, mais pour toutes les navigations de l'app.

Un fallback pour toutes les routes

Tu ne vas pas déclarer errorComponent sur cinquante routes. withErrorBoundaries() accepte un composant par défaut, utilisé par toute route qui n'a pas le sien, et un callback global :

provideRouter(
  routes,
  withErrorBoundaries({
    defaultErrorComponent: RouteError,
    onError: (error, details) => inject(Monitoring).report(error, details),
  }),
);

onError tourne dans le contexte d'injection racine, d'où le inject() direct. Le second argument est l'ErrorDetails introduit en 22.2 avec @boundary : le contexte de l'erreur. Point mesuré : pour une erreur de template ou de ngOnInit, il contient declarationInstance, declarationType et caughtBy. Pour une erreur levée dans le constructeur, il vaut undefined : c'est pour ça que le type est optionnel (details?: ErrorDetails). Ne force jamais details!, sinon c'est ton reporting qui plantera sur ce cas.

Ton ErrorHandler ne voit plus ces erreurs-là

Point mesuré, et c'est le piège de cette release : quand une route attrape l'erreur, ton ErrorHandler n'est pas appelé. Ni handleError, ni onViewError.

C'est différent de @boundary. L'article de la 22.2 te conseillait de brancher onViewError pour repérer les erreurs de rendu attrapées : mesuré en 22.3.0, une erreur attrapée par @boundary arrive bien dans onViewError, une erreur attrapée par la route n'y arrive pas. Si ton monitoring passe par un ErrorHandler maison, ces erreurs-là disparaissent de tes dashboards le jour où tu actives withErrorBoundaries() avec un composant d'erreur.

onError devient le seul point d'entrée global pour les voir. Le composant d'erreur les reçoit aussi, dans son input error, mais c'est un composant par route.


Ce que la route n'attrape pas

Les handlers d'événement

La documentation de withErrorBoundaries cite les handlers d'événement parmi ce qui est attrapé. Mesuré sur la 22.3.0 : un (click) qui lève une erreur ne déclenche pas le composant d'erreur. L'erreur part vers ErrorHandler.handleError, la page reste affichée et utilisable. C'est le même comportement que @boundary en 22.2.

Conséquence pratique : un handler qui appelle une API et peut échouer gère son erreur lui-même. La route ne te sauvera pas.

Le RedirectCommand passe aussi par onError

Le changelog annonce aussi une "gestion des redirections" : un composant routé peut lever un RedirectCommand pendant son rendu (ngOnInit, template), et le router redirige. Sans withErrorBoundaries(), ce cas ne redirige pas : l'URL reste, la page s'affiche à moitié (le HTML statique sans ses bindings) et l'erreur part dans handleError, en 22.2.7 comme en 22.3.0.

@Component({
  selector: 'app-account-page',
  template: `...`,
})
export class AccountPage implements OnInit {
  private readonly session = inject(Session);
  private readonly router = inject(Router);

  ngOnInit(): void {
    if (!this.session.isLoggedIn()) {
      throw new RedirectCommand(this.router.parseUrl('/login'));
    }
  }
}

Avec la fonctionnalité, ça marche : l'URL finit sur /login. Levé dans le constructeur, en revanche, un RedirectCommand redirige déjà sans withErrorBoundaries(), en 22.2 comme en 22.3. Ce que l'activation change pour ce cas, c'est qu'il passe désormais lui aussi par onError.

Dans les deux cas, l'onError global est appelé avec le RedirectCommand. RedirectCommand hérite d'Error, donc le type ne te prévient de rien. Si onError remonte tout vers ton monitoring, chaque redirection devient une alerte. Filtre-le :

onError: (error, details) => {
  if (error instanceof RedirectCommand) return;
  inject(Monitoring).report(error, details);
},

Et pour une redirection d'authentification, le guard reste le bon endroit : il décide avant que le composant soit construit (voir l'article sur les tests de guards).

L'oubli de withErrorBoundaries()

Sans la fonctionnalité, errorComponent est ignoré. En dev, Angular le signale une seule fois :

The route 'product' defines an 'errorComponent', but router error boundaries are not enabled. Add 'withErrorBoundaries()' to 'provideRouter' for it to take effect.

Puis tu retrouves la page vide d'avant. Un warning en console de dev, facile à rater, et rien du tout en prod : ajoute la fonctionnalité en même temps que le premier errorComponent.


HttpClient.query() : un GET qui accepte un corps

La méthode HTTP QUERY a été standardisée par l'IETF en juin 2026 (RFC 10008). L'idée : une lecture qui ne modifie rien côté serveur et qu'on peut rejouer sans changer le résultat, comme un GET (la spec dit "sûre" et "idempotente"), mais dont les critères partent dans le corps de la requête plutôt que dans l'URL. C'est ce que tu fais aujourd'hui avec un POST /search, en mentant sur la nature de l'opération.

type ProductFilter = { tags: string[]; maxPrice: number };

@Injectable({ providedIn: 'root' })
export class ProductSearchAdapter {
  private readonly http = inject(HttpClient);

  search(filter: ProductFilter): Observable<Product[]> {
    return this.http.query<Product[]>('/api/products/search', filter);
  }
}

Mesuré avec HttpTestingController : la requête part en méthode QUERY avec l'objet en corps. Le backend HTTP d'Angular le sérialise ensuite en JSON avec Content-Type: application/json, comme pour un POST. Trois conséquences à connaître :

  1. Le header XSRF n'est pas ajouté, comme pour GET et HEAD (lu dans l'intercepteur XSRF de la 22.3.0). Angular traite QUERY comme une lecture. Si ton backend exige le token XSRF sur tout ce qui n'est pas GET, il rejettera la requête (le mécanisme complet est dans l'article sur le header XSRF).
  2. Le cache de transfert HTTP du SSR la met en cache par défaut, comme un GET (lu dans le code de la 22.3.0). Ce cache, c'est celui qui évite au navigateur de rejouer les requêtes déjà faites pendant le rendu serveur. Un POST en est exclu par défaut. La clé de cache inclut le corps : deux filtres différents donnent deux entrées. Les mêmes exclusions que pour un GET s'appliquent : headers d'authentification, credentials, Cache-Control qui interdit la mise en cache.
  3. Ton serveur doit connaître la méthode. Ça, c'est la spec Fetch, pas Angular : QUERY ne fait pas partie des méthodes qui évitent la requête CORS préalable (le preflight). En cross-origin, le navigateur envoie un OPTIONS d'abord, et le serveur doit autoriser QUERY dans Access-Control-Allow-Methods.

Bref, query() ne sert que si ton API accepte QUERY. Côté Angular, c'est prêt.


++ et -- dans les templates

Jusqu'en 22.2.7, (click)="clicks++" cassait la compilation :

NG5002: Parser Error: Unexpected end of expression: clicks++ at the end of the expression [clicks++] ...

En 22.3, ça compile, et deux clics donnent bien 2. Utile pour une propriété de classe ordinaire. Avec un signal(), rien ne change : on écrit toujours count.update(n => n + 1). count++ sur un signal est refusé à la compilation (TS2356: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type.).


NG8119 : [style.width]="200" ne fait rien

Nouveau diagnostic étendu (les vérifications optionnelles du compilateur sur les templates), en warning par défaut :

<div [style.width]="200"></div>
NG8119: Binding a number to the CSS property 'width' will have no effect. CSS requires units for length values. For example, use [style.width.px]="200" or [style.width]="'200px'" instead.

Il vise les propriétés de longueur (width, height, margin-top, font-size, gap...) mais pas opacity, line-height ni z-index, qui acceptent un nombre. Il attrape aussi la chaîne '200'. Il ne regarde que les littéraux : [style.width]="size()" qui renvoie un nombre passe sans warning. 0 est accepté, puisqu'il n'a pas besoin d'unité.


Aussi dans la 22.3

Router

  • withViewTransitions() sort de la developer preview, où elle était depuis la 19.0 : la fonction et ses options sont marquées @publicApi 22.3. Les pièges de mise en place, eux, n'ont pas changé (voir l'article sur les View Transitions).
  • RouterLink prend un input scroll, 'manual' ou 'after-transition'. En 'manual', le router ne scrolle pas après cette navigation précise, même si la restauration de scroll est activée. Pratique pour des onglets qui changent un query param.
  • Les router resources de la 22.2 deviennent chaînables. Pour rappel, la propriété resources d'une route (developer preview, activée par withRouterResources()) déclare des resource() chargées pendant la navigation. En 22.3, son contexte reçoit les resources des routes parentes, sous forme de signal : une route enfant peut charger ses données à partir de celles du parent, à condition de lire ce signal dans un contexte réactif (le params de sa resource), pas directement dans le corps de la fonction.
  • focusReset rejoint les options de navigation, en @experimental. Il décide si le navigateur replace le focus en fin de navigation : en 'manual', un champ de recherche qui met à jour un query param garde le focus. Uniquement avec la Navigation API du navigateur (withExperimentalPlatformNavigation).
  • RouterTestingHarness.navigate() accepte des commandes, comme Router.navigate().

Core, compilateur et outillage

  • @defer (on viewport(...)) prend en charge scrollMargin, l'option d'IntersectionObserver qui agrandit la zone de détection dans les conteneurs scrollables. La clé compilait déjà en 22.2.7, mais deux blocs qui ne différaient que par scrollMargin partageaient le même observer. Ce n'est plus le cas.
  • Le language service ajoute la sélection intelligente dans les templates : l'extension de sélection de ton éditeur suit la structure du template.

Récap actionnable

  1. Ajoute withErrorBoundaries({ defaultErrorComponent }) : une page qui plante affiche un écran d'erreur au lieu d'une page blanche. L'API est en developer preview.
  2. Ajoute ton reporting dans onError, en plus de ton ErrorHandler : ni handleError ni onViewError ne reçoivent les erreurs attrapées par la route, mais ils restent le seul point global pour les autres (handlers (click), @boundary).
  3. Filtre RedirectCommand dans onError, sinon chaque redirection devient une alerte.
  4. Ne force jamais details! : details vaut undefined pour une erreur de constructeur.
  5. N'adopte HttpClient.query() qu'avec un backend qui accepte QUERY, et vérifie la protection CSRF de ces endpoints.
  6. Gère les erreurs dans tes handlers (click) : ni la route ni @boundary ne les attrapent.

📧 Reste informé(e) !

Reçois les derniers articles et conseils EasyAngularKit directement dans ta boîte mail.

S'inscrire gratuitement

AngularKit

Suite d'outils pour développeurs Angular francophones. Apprends, modernise tes réflexes, audite ta codebase.

Produits

Contact

Légal

© 2026 AngularKit. Tous droits réservés.