Introduction à la View Transitions API
La View Transitions API est une nouvelle API native qui permet de créer des transitions fluides entre différents états du DOM ou entre pages entières. Fini les librairies JavaScript complexes pour animer vos changements de page !
Avant cette API, créer des transitions de page nécessitait des solutions comme :
- Barba.js ou Swup pour les transitions SPA
- FLIP animations complexes avec JavaScript
- CSS transitions limitées aux propriétés animables
Avec la View Transitions API, le navigateur géré nativement la capture d'écran, l'interpolation et l'animation entre deux états. Le résultat : des performances optimales et un code beaucoup plus simple.
La View Transitions API fonctionne aussi bien pour les Single Page Applications (SPA) que pour les Multi Page Applications (MPA). Les transitions MPA nécessitent Chrome 126+ avec une meta tag spécifique.
Syntaxe de base : document.startViewTransition()
La méthode principale de l'API est document.startViewTransition(). Elle prend une fonction callback qui effectue les modifications du DOM.
Transition simple
Voici l'implementation la plus basique pour animer un changement de contenu :
// Fonction qui modifie le DOM
function updateContent() {
document.querySelector('.content').innerHTML = newContent;
}
// Verifier le support de l'API
if (!document.startViewTransition) {
// Fallback : mise a jour directe sans animation
updateContent();
return;
}
// Creer une transition animee
document.startViewTransition(() => {
updateContent();
});
Transition avec Promise
La méthode retourne un objet ViewTransition avec plusieurs propriétés utiles :
const transition = document.startViewTransition(async () => {
// Charger le nouveau contenu
const response = await fetch('/api/content');
const html = await response.text();
document.querySelector('.content').innerHTML = html;
});
// Attendre que la transition soit prete
await transition.ready;
console.log('Transition demarree');
// Attendre la fin de l'animation
await transition.finished;
console.log('Transition terminee');
L'objet ViewTransition expose trois promises :
- updateCallbackDone : résolue quand le callback est terminé
- ready : résolue quand l'animation peut commencer
- finished : résolue quand l'animation est terminée
Transitions CSS personnalisées
Par défaut, la View Transitions API applique un simple fondu enchaîné (crossfade). Mais vous pouvez personnaliser entièrement les animations avec des pseudo-éléments CSS.
Les pseudo-éléments de transition
Pendant une transition, le navigateur crée une structure de pseudo-éléments :
::view-transition
::view-transition-group(root)
::view-transition-image-pair(root)
::view-transition-old(root) /* Capture de l'ancien etat */
::view-transition-new(root) /* Capture du nouvel etat */
Animation de fondu personnalisée
Voici comment créer une animation de fondu avec un effet de zoom :
/* Animation de l'ancien etat (sortie) */
::view-transition-old(root) {
animation: 300ms ease-out fade-out-scale;
}
/* Animation du nouvel etat (entree) */
::view-transition-new(root) {
animation: 300ms ease-out fade-in-scale;
}
@keyframes fade-out-scale {
to {
opacity: 0;
transform: scale(0.9);
}
}
@keyframes fade-in-scale {
from {
opacity: 0;
transform: scale(1.1);
}
}
Animation de glissement
Pour une transition de type slide entre pages :
/* Slide vers la gauche (avancer) */
::view-transition-old(root) {
animation: 400ms cubic-bezier(0.4, 0, 0.2, 1) slide-out-left;
}
::view-transition-new(root) {
animation: 400ms cubic-bezier(0.4, 0, 0.2, 1) slide-in-right;
}
@keyframes slide-out-left {
to {
opacity: 0;
transform: translateX(-100px);
}
}
@keyframes slide-in-right {
from {
opacity: 0;
transform: translateX(100px);
}
}
/* Slide inverse (reculer) - ajouter une classe sur html */
html.back-navigation::view-transition-old(root) {
animation-name: slide-out-right;
}
html.back-navigation::view-transition-new(root) {
animation-name: slide-in-left;
}
Demo : cliquez sur les onglets pour voir la transition
Transitions entre pages (MPA)
La fonctionnalité la plus attendue : les transitions entre pages dans les applications multi-pages classiques. Plus besoin de SPA pour avoir des transitions fluides !
Activer les transitions MPA
Ajoutez simplement cette meta tag dans le <head> de chaque page :
<head>
<!-- Activer les transitions entre pages -->
<meta name="view-transition" content="same-origin">
</head>
Les transitions MPA ne fonctionnent qu'entre pages de la même origine (same-origin). Les navigations vers des domaines externes ne déclencheront pas de transition.
Personnaliser la direction de transition
Utilisez JavaScript pour définir la direction selon la navigation :
// Detecter le sens de navigation
window.addEventListener('pageswap', (event) => {
const navigation = performance.getEntriesByType('navigation')[0];
if (navigation.type === 'back_forward') {
document.documentElement.classList.add('back-navigation');
}
});
// Nettoyer apres la transition
window.addEventListener('pagereveal', () => {
document.documentElement.classList.remove('back-navigation');
});
Animations d'éléments partages
La vraie puissance de l'API réside dans les transitions d'éléments partages. Un élément peut "voler" d'une position à une autre entre deux états.
Nommer les éléments de transition
Utilisez la propriété CSS view-transition-name pour identifier les éléments qui doivent avoir leur propre animation :
/* Page liste : carte produit */
.product-card img {
view-transition-name: product-image;
}
.product-card h3 {
view-transition-name: product-title;
}
/* Page detail : memes noms */
.product-hero img {
view-transition-name: product-image;
}
.product-hero h1 {
view-transition-name: product-title;
}
Chaque view-transition-name doit être unique dans le document. Si deux éléments ont le même nom en même temps, la transition échouera silencieusement.
Noms dynamiques avec JavaScript
Pour les listes d'éléments, assignez les noms dynamiquement :
// Au clic sur une carte
card.addEventListener('click', (e) => {
const productId = card.dataset.id;
// Assigner un nom unique a cette carte
card.querySelector('img').style.viewTransitionName = `product-${productId}`;
// Naviguer vers la page detail
window.location.href = `/product/${productId}`;
});
Personnaliser l'animation d'un élément partage
/* Le groupe gere la position et la taille */
::view-transition-group(product-image) {
animation-duration: 500ms;
animation-timing-function: cubic-bezier(0.4, 0, 0, 1);
}
/* L'ancien etat disparait progressivement */
::view-transition-old(product-image) {
animation: 250ms ease-out fade-out;
}
/* Le nouvel etat apparait progressivement */
::view-transition-new(product-image) {
animation: 250ms ease-in 250ms fade-in;
}
Demo : cliquez sur un élément pour simuler une transition partagée
Support navigateurs et fallbacks
La View Transitions API est encore relativement récente. Voici l'état du support actuel :
| Navigateur | SPA (same-document) | MPA (cross-document) | Version minimale |
|---|---|---|---|
| Chrome | Oui | Oui | 111+ / 126+ |
| Edge | Oui | Oui | 111+ / 126+ |
| Opera | Oui | Oui | 97+ / 112+ |
| Safari | Oui | Non | 18+ |
| Firefox | Flag | Non | - |
Détection de fonctionnalité
// Verifier le support JavaScript
const supportsViewTransitions = 'startViewTransition' in document;
// Verifier le support CSS
const supportsCSSViewTransitions = CSS.supports('view-transition-name', 'test');
// Fonction wrapper avec fallback
function navigate(updateFn) {
if (!supportsViewTransitions) {
updateFn();
return;
}
document.startViewTransition(updateFn);
}
CSS avec fallback
/* Styles de transition uniquement si supporte */
@supports (view-transition-name: test) {
.hero-image {
view-transition-name: hero;
}
::view-transition-old(hero),
::view-transition-new(hero) {
animation-duration: 400ms;
}
}
Exemples pratiques
Exemple 1 : Thème switch avec transition
Un classique : le changement de thème clair/sombre avec une animation élégante.
Cliquez sur le toggle pour changer de thème avec transition.
Demo : changement de thème avec View Transitions
const toggle = document.querySelector('#theme-toggle');
toggle.addEventListener('click', async () => {
// Fallback sans animation
if (!document.startViewTransition) {
document.documentElement.classList.toggle('dark');
return;
}
// Avec transition animee
const transition = document.startViewTransition(() => {
document.documentElement.classList.toggle('dark');
});
// Animer depuis le bouton toggle
await transition.ready;
const { top, left, width, height } = toggle.getBoundingClientRect();
const x = left + width / 2;
const y = top + height / 2;
const endRadius = Math.hypot(
Math.max(x, innerWidth - x),
Math.max(y, innerHeight - y)
);
document.documentElement.animate(
{
clipPath: [
`circle(0px at ${x}px ${y}px)`,
`circle(${endRadius}px at ${x}px ${y}px)`
]
},
{
duration: 500,
easing: 'ease-out',
pseudoElement: '::view-transition-new(root)'
}
);
});
Exemple 2 : Navigation SPA
Implémentez des transitions fluides dans votre Single Page Application.
// Router simple avec View Transitions
class Router {
constructor() {
this.routes = new Map();
this.container = document.querySelector('#app');
// Intercepter les clics sur les liens
document.addEventListener('click', (e) => {
const link = e.target.closest('a[href^="/"]');
if (link) {
e.preventDefault();
this.navigate(link.pathname);
}
});
}
register(path, handler) {
this.routes.set(path, handler);
}
async navigate(path) {
const handler = this.routes.get(path);
if (!handler) return;
const updateDOM = async () => {
this.container.innerHTML = await handler();
history.pushState(null, '', path);
};
// Avec View Transition si supporte
if (document.startViewTransition) {
await document.startViewTransition(updateDOM).finished;
} else {
await updateDOM();
}
}
}
// Utilisation
const router = new Router();
router.register('/', () => '<h1>Accueil</h1>');
router.register('/about', () => '<h1>A propos</h1>');
Exemple 3 : Galerie d'images
Transition fluide entre miniature et plein écran.
const gallery = document.querySelector('.gallery');
const modal = document.querySelector('.modal');
const modalImg = modal.querySelector('img');
gallery.querySelectorAll('img').forEach((img, index) => {
img.addEventListener('click', () => {
// Assigner un nom unique
img.style.viewTransitionName = 'gallery-image';
modalImg.style.viewTransitionName = 'gallery-image';
const transition = document.startViewTransition(() => {
modalImg.src = img.src;
modal.classList.add('open');
});
transition.finished.then(() => {
// Nettoyer les noms apres la transition
img.style.viewTransitionName = '';
});
});
});
Les View Transitions utilisent le compositing GPU. L'animation se fait sur des "screenshots" des états, ce qui garantit 60fps même avec des DOM complexes.
Conclusion
La View Transitions API représente une avancée majeure pour l'expérience utilisateur sur le web. Elle permet enfin de créer des transitions de page natives, performantes et faciles à implémenter.
Points clés à retenir :
- Simple à utiliser : une seule méthode
document.startViewTransition() - Entièrement personnalisable avec CSS et les pseudo-éléments dédiés
- Éléments partages : la propriété
view-transition-namepermet des animations "hero" - MPA support : fonctionne aussi entré vraies pages HTML
- Progressive enhancement : facile à implémenter avec fallback
Le support navigateur s'améliore rapidement. C'est le moment idéal pour commencer à expérimenter avec cette API et préparer vos projets pour le futur du web !
Découvrez nos templates premium qui utilisent la View Transitions API pour des expériences utilisateur exceptionnelles.




