Développeur WEB

← Tous les articles
React 2 octobre 2026 6 min de lecture

React 19.3 : browser(), Trusted Types et Context sans Provider

Axel Grégoire

#react #react-19 #server-components #securite #trusted-types

React 19.3 est sorti le 9 septembre 2026, sans aucune breaking change. L'annonce officielle a surtout mis en avant deux nouveautés : ViewTransition et les Fragment Refs, qui passent enfin stables après plusieurs mois en RC. Si tu suis l'actualité React, tu as probablement déjà vu ces deux-là défiler sur X ou dans ta newsletter preferee.

Mais trois autres ajouts de cette même version sont passés beaucoup plus discrètement, alors qu'ils vont changer des choses très concrètes dans ton code au quotidien : la fonction browser() pour gérer proprement le rendu côté client uniquement, le support natif des Trusted Types, et la possibilité de rendre un Context directement depuis un Server Component sans passer par un composant Provider dédié.

On fait le tour de ces trois nouveautés, avec des exemples de code, et on termine par un point sécurité sur les Server Components qu'il ne faut pas zapper si tu es en production.

browser() : sortir du rendu serveur sans bricolage

Jusqu'ici, si un composant dépendait d'une API disponible uniquement dans le navigateur — localStorage, le fuseau horaire local, window.matchMedia — tu devais ruser : un useEffect couplé à un useState pour détecter le montage côté client, avec un rendu "vide" ou un flash de contenu au premier passage. Ce pattern fonctionne, mais il complique le composant et génère souvent un mismatch d'hydratation si on ne fait pas attention.

React 19.3 introduit browser(), une nouvelle API de react-dom à combiner avec use(). Appeler use(browser()) dans un composant indique à React que ce composant ne peut tout simplement pas être rendu côté serveur. Pendant le SSR, React s'arrête à cet appel et écrit directement le fallback du Suspense le plus proche dans le HTML envoyé au client. Après l'hydratation, en revanche, le composant ne suspend plus : il s'affiche normalement dans le navigateur.

import { Suspense, use } from 'react'; import { browser } from 'react-dom'; function SavedDraft() { // Ce composant lit localStorage, impossible à faire côté serveur use(browser('Le brouillon est stocké dans localStorage.')); const draft = localStorage.getItem('draft'); return <p>Brouillon : {draft ?? 'aucun brouillon'}</p>; } export default function Editor() { return ( <Suspense fallback={<p>Chargement du brouillon...</p>}> <SavedDraft /> </Suspense> ); } 

L'avantage par rapport au duo useEffect/useState : le fallback est géré par le mécanisme Suspense existant, pas de state additionnel à maintenir, et surtout pas de risque de mismatch d'hydratation puisque React sait explicitement que ce sous-arbre n'a pas de rendu serveur valide.

Quand l'utiliser

  • Composants qui lisent localStorage, sessionStorage ou IndexedDB
  • Composants qui dépendent du fuseau horaire ou de la locale détectés côté client
  • Widgets tiers qui s'attachent directement au DOM du navigateur (cartes, lecteurs vidéo embarqués, etc.)

À l'inverse, ce n'est pas fait pour contourner un vrai problème de données asynchrones : pour ça, le Suspense classique avec un fetch reste l'outil adapté.

Trusted Types : React ne triche plus avec le navigateur

L'API Trusted Types du navigateur permet de bloquer les injections DOM-based XSS en forçant certaines API sensibles (innerHTML, ou l'attribut src d'une balise exécutable, etc.) à recevoir des objets "de confiance" produits par une policy explicite, plutôt que des chaînes de caractères arbitraires. Le problème, c'est que React convertissait historiquement ces objets en chaînes avant de les passer au DOM — ce qui cassait justement la protection que Trusted Types est censée apporter.

Avec React 19.3, ce n'est plus le cas : React détecte quand une valeur est un objet Trusted Types et la transmet telle quelle, sans coercition. Concrètement, si ton application tourne avec une Content Security Policy qui impose Trusted Types pour les ressources exécutables, tes policies fonctionnent enfin correctement avec du JSX comme dangerouslySetInnerHTML.

// Exemple de policy Trusted Types définie en amont de l'app const policy = trustedTypes.createPolicy('app-html', { createHTML: (input) => sanitize(input), }); function RichContent({ rawHtml }) { const safeHtml = policy.createHTML(rawHtml); // React 19.3 transmet l'objet TrustedHTML sans le repasser en string return <div dangerouslySetInnerHTML={{ __html: safeHtml }} />; } 

Si tu ne connais pas encore Trusted Types, c'est le bon moment pour t'y pencher : Chrome et Edge le supportent nativement depuis plusieurs années, et c'est un des rares mécanismes qui élimine une classe entière de failles XSS côté navigateur plutôt que de simplement les atténuer.

Context dans les Server Components : fini le Provider inutile

Les Server Components ne peuvent pas créer de contexte avec createContext — ils n'ont pas d'état ni de cycle de vie côté client. Jusqu'à présent, pour faire descendre une valeur calculée côté serveur vers des Client Components via Context, il fallait créer un petit composant Provider dédié, marqué 'use client', dont le seul rôle était de relayer la valeur :

// AVANT 19.3 : un wrapper Provider nécessaire // user-context.js 'use client'; import { createContext } from 'react'; export const UserCtx = createContext(null); // user-provider.js 'use client'; import { UserCtx } from './user-context'; export function UserProvider({ user, children }) { return <UserCtx.Provider value={user}>{children}</UserCtx.Provider>; } 

Avec React 19.3, un Server Component peut importer le Context directement depuis un module 'use client' et le rendre lui-même, sans wrapper intermédiaire :

// user-context.js 'use client'; import { createContext } from 'react'; export const UserCtx = createContext(null); // server-layout.js (Server Component, pas de directive 'use client') import { UserCtx } from './user-context'; export async function Layout({ children }) { const currentUser = await getCurrentUser(); return ( <UserCtx value={currentUser}> {children} </UserCtx> ); } 

Les Client Components situés dans l'arbre peuvent toujours lire la valeur avec use(UserCtx) ou useContext(UserCtx), exactement comme avant. On économise juste un fichier et un niveau d'imbrication — un détail, mais qui s'accumule vite sur une grosse base de code avec beaucoup de contextes serveur→client.

Un rappel sécurité qui va avec : les CVE sur les Server Components

Si ton application utilise les Server Components (via Next.js, Parcel ou un bundler webpack/Turbopack avec RSC), il y a un point à vérifier avant de célébrer ces nouveautés : plusieurs vulnérabilités de déni de service ont touché le protocole Flight de React en 2026.

La plus notable, CVE-2026-23869 (score CVSS 7.5, "High"), vient d'une mauvaise gestion des structures de données cycliques pendant la désérialisation des requêtes HTTP entrantes, dans les fonctions createMap, createSet et extractIterator de ReactFlightReplyServer.js. Elle touchait les packages react-server-dom-parcel, react-server-dom-turbopack et react-server-dom-webpack sur les versions 19.0.0 à 19.0.4, 19.1.0 à 19.1.5, et 19.2.0 à 19.2.4. Les correctifs ont été rétroportés en 19.0.5, 19.1.6 et 19.2.5 — et sont bien sûr inclus dans la 19.3.0.

Le réflexe à avoir : vérifie la version exacte de tes packages react-server-dom-* dans ton lockfile, pas seulement celle de react et react-dom. Ce sont des packages séparés qui peuvent se retrouver à une version plus ancienne selon la façon dont ton bundler les résout.

Ce qu'il faut retenir

React 19.3 ne se résume pas à ViewTransition et aux Fragment Refs. Trois chantiers plus discrets méritent ton attention si tu maintiens une application React en production :

  • Remplace tes patterns useEffect + useState de détection "client only" par use(browser()) quand c'est pertinent — moins de code, pas de risque de mismatch d'hydratation.
  • Si ta CSP impose Trusted Types, vérifie que tes policies fonctionnent bien avec dangerouslySetInnerHTML maintenant que React ne les coerce plus en chaînes.
  • Si tu utilises des Server Components avec du Context, tu peux supprimer les composants Provider qui ne faisaient que relayer une valeur.
  • Dans tous les cas, audite les versions de tes packages react-server-dom-* pour t'assurer que tu es au-delà des versions touchées par CVE-2026-23869.

Comme toujours avec React 19.x, la mise à jour vers 19.3 se fait sans breaking change annoncé : un bon moment pour la planifier si tu es encore sur une 19.1 ou 19.2.

À lire aussi

React 6 novembre 2026 6 min

React Foundation : Meta cède la main, ce qui change pour vous

La React Foundation, hébergée par la Linux Foundation, est officiellement lancée. Gouvernance, financement, indépendance : ce qui change pour vous en 2026.

Lire l'article →
React 20 octobre 2026 7 min

ESLint-plugin-react-hooks v7 : le compilateur débarque dans le linter

React Compiler s'invite désormais dans ton éditeur via eslint-plugin-react-hooks v7 : nouvelles règles, presets simplifiés, migration pas à pas.

Lire l'article →
React 15 septembre 2026 7 min

React 19.3 : Fragment Refs et ViewTransition passent stables

React 19.3 (9 septembre 2026) stabilise Fragment Refs, ViewTransition et browser(). Ce qui change concrètement dans ton code, avec exemples.

Lire l'article →