Système de Motion v4.2
Système d'animation UI prêt pour la production pour React / Next.js.
Axé sur la performance, l'accessibilité et l'utilisabilité — pas la décoration.
Quand l'utiliser
Utilisez ce système de motion lorsque la motion :
- Guide l'attention (p. ex., intégration, actions clés)
- Communique un état (chargement, succès, erreur, transitions)
- Préserve la continuité spatiale (changements de mise en page, navigation)
Scénarios appropriés
- Composants interactifs (boutons, modales, menus)
- Transitions d'état (chargement → chargé, ouvert → fermé)
- Navigation et continuité de mise en page (éléments partagés, fondu enchaîné)
Considérations
- Accessibilité : Toujours prendre en charge le mouvement réduit
- Adaptation aux appareils : Ajuster pour les appareils bas de gamme
- Compromis de performance : Privilégier la réactivité à la fluidité visuelle
Éviter d'utiliser la motion quand
- Elle est purement décorative
- Elle réduit l'utilisabilité ou la clarté
- Elle impacte négativement les performances
Comment ça fonctionne
Principe fondamental
La motion doit :
- Guider l'attention
- Communiquer un état
- Préserver la continuité spatiale
Si elle ne fait rien de cela → supprimez-la.
Installation
npm install motion
Version
motion/react- par défaut pour les projets Motion for React actuels (package :motion)framer-motion- chemin d'importation legacy pour les projets qui dépendent encore de Framer Motion
Ne pas mélanger. Le mélange provoque des conflits d'ordonnancement internes et des contextes AnimatePresence cassés — les composants d'un package ne coordonneront pas les animations de sortie avec les composants de l'autre.
Pour vérifier quelle version votre projet utilise :
cat package.json | grep -E '"motion"|"framer-motion"'
Importez toujours depuis une seule source de manière cohérente :
// Correct (moderne)
import { motion, AnimatePresence } from "motion/react"
// Correct (legacy)
import { motion, AnimatePresence } from "framer-motion"
// Ne jamais mélanger les deux dans le même projet
Tokens de Motion
// motionTokens.ts
export const motionTokens = {
duration: {
fast: 0.18,
normal: 0.35,
slow: 0.6
},
// Utilisez ces valeurs comme `ease` dans un objet `transition` :
// transition={{ duration: motionTokens.duration.normal, ease: motionTokens.easing.smooth }}
easing: {
smooth: [0.22, 1, 0.36, 1] as [number, number, number, number],
sharp: [0.4, 0, 0.2, 1] as [number, number, number, number]
},
distance: {
sm: 8,
md: 16,
lg: 24
}
}
Exemple d'utilisation :
import { motionTokens } from "@/lib/motionTokens"
<motion.div
initial={{ opacity: 0, y: motionTokens.distance.md }}
animate={{ opacity: 1, y: 0 }}
transition={{
duration: motionTokens.duration.normal,
ease: motionTokens.easing.smooth
}}
/>
Règles de Performance
Sûr
- transform
- opacity
À éviter
- width / height
- top / left
Règle : réactivité > fluidité
Adaptation aux Appareils
L'heuristique combine le nombre de cœurs CPU et la mémoire disponible pour un signal plus fiable. deviceMemory est disponible sur Chrome/Android ; le fallback couvre Safari et Firefox.
const isLowEnd =
typeof navigator !== "undefined" && (
// Faible mémoire (Chrome/Android seulement ; undefined ailleurs → considéré comme capable)
(navigator.deviceMemory !== undefined && navigator.deviceMemory <= 2) ||
// Peu de cœurs ET pas d'API mémoire (couvre Safari/Firefox sur matériel faible)
(navigator.deviceMemory === undefined && navigator.hardwareConcurrency <= 4)
)
const duration = isLowEnd ? 0.2 : 0.4
Accessibilité
JS (useReducedMotion)
import { motion, useReducedMotion } from "motion/react"
export function FadeIn() {
const reduce = useReducedMotion()
return (
<motion.div
initial={{ opacity: 0, y: reduce ? 0 : 24 }}
animate={{ opacity: 1, y: 0 }}
/>
)
}
CSS
@media (prefers-reduced-motion: reduce) {
.motion-safe-transition {
transition: opacity 0.2s;
}
.motion-reduce-transform {
transform: none !important;
}
}
Tailwind
<div class="motion-safe:animate-fade motion-reduce:opacity-100"></div>
Architecture et Patrons
Patrons Fondamentaux
| Scénario | Patron |
|---|---|
| Retour visuel au survol | whileHover |
| Retour visuel au toucher / pression | whileTap |
| Révélation au défilement | whileInView |
| Valeur liée au défilement | useScroll + useTransform |
| Montage/démontage conditionnel | AnimatePresence |
| Petits déplacements de mise en page (élément unique, < ~300px de changement) | Propriété layout |
| Grands déplacements de mise en page ou reflows de page entière | Éviter layout ; utiliser les transitions CSS ou le routage au niveau de la page |
| Séquences impératives complexes | useAnimate |
Pourquoi éviter
layoutsur les grands conteneurs ? L'animation de mise en page de Framer utilisetransformpour concilier les positions, mais sur les éléments qui couvrent toute la fenêtre ou déclenchent un reflow profond, le coût de mesure provoque un saccade visible et un CLS. Privilégiez les transitions CSS Grid/Flexbox ou coordonnez aveclayoutIduniquement sur des éléments enfants spécifiques.
Mise en Page et Transitions
- Transitions d'éléments partagés →
layoutId(doit être unique par instance montée) - Transitions d'entrée / sortie →
AnimatePresence(voir les conseils surmodeci-dessous)
AnimatePresence mode
Spécifiez toujours mode explicitement — la valeur par défaut ("sync") exécute l'entrée et la sortie simultanément, ce qui provoque un chevauchement visuel dans la plupart des motifs d'interface.
mode | Quand l'utiliser |
|---|---|
"wait" | La sortie se termine avant le début de l'entrée. À utiliser pour modales, toasts, transitions de page. |
"sync" (défaut) | Entrée et sortie se chevauchent. À utiliser uniquement lorsque le chevauchement est intentionnel (p. ex., carrousels avec fondu enchaîné). |
"popLayout" | L'élément qui sort est immédiatement retiré du flux ; les éléments restants s'animent pour combler l'espace. À utiliser pour listes, onglets, cartes dismissibles. |
// Modale — toujours utiliser "wait"
<AnimatePresence mode="wait">
{open && <Modal key="modal" />}
</AnimatePresence>
// Élément de liste dismissible — utiliser "popLayout"
<AnimatePresence mode="popLayout">
{items.map(item => <Card key={item.id} />)}
</AnimatePresence>
Patrons Avancés (Concepts)
- Parallaxe (transformations liées au défilement)
- Narration par défilement (sections collantes)
- Inclinaison 3D (transformations basées sur le pointeur)
- Fondu enchaîné (
layoutIdpartagé) - Révélation progressive (clip-path)
- Chargement squelette (opacité en boucle)
- Micro-interactions (retour visuel survol/toucher)
- Système de ressort (motion basée sur la physique)
Essentiels d'une Modale
- Piège de focus
- Fermeture avec Échap
- Verrouillage du défilement
- Rôles ARIA
- Utiliser
AnimatePresence mode="wait"pour que l'animation de sortie se termine avant que la prochaine modale n'entre
Exemple Complet
import React, { useEffect, useRef, useState } from "react"
import { motion, AnimatePresence } from "motion/react"
function useFocusTrap(ref: React.RefObject<HTMLDivElement | null>, active: boolean) {
useEffect(() => {
if (!active || !ref.current) return
const el = ref.current
const focusable = el.querySelectorAll<HTMLElement>(
'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
)
const first = focusable[0]
const last = focusable[focusable.length - 1]
function handleKey(e: KeyboardEvent) {
if (e.key !== "Tab") return
if (e.shiftKey && document.activeElement === first) {
e.preventDefault()
last?.focus()
} else if (!e.shiftKey && document.activeElement === last) {
e.preventDefault()
first?.focus()
}
}
el.addEventListener("keydown", handleKey)
first?.focus()
return () => el.removeEventListener("keydown", handleKey)
}, [active, ref])
}
function useScrollLock(active: boolean) {
useEffect(() => {
if (!active) return
const prev = document.body.style.overflow
document.body.style.overflow = "hidden"
return () => { document.body.style.overflow = prev }
}, [active])
}
function Modal({ open, closeModal }: { open: boolean; closeModal: () => void }) {
const ref = useRef<HTMLDivElement>(null)
useFocusTrap(ref, open)
useScrollLock(open)
useEffect(() => {
function onKey(e: KeyboardEvent) {
if (e.key === "Escape") closeModal()
}
if (open) window.addEventListener("keydown", onKey)
return () => window.removeEventListener("keydown", onKey)
}, [open, closeModal])
return (
// mode="wait" garantit que l'animation de sortie se termine avant qu'une nouvelle modale n'entre
<AnimatePresence mode="wait">
{open && (
<motion.div
role="dialog"
aria-modal="true"
aria-labelledby="modal-title"
initial={{ opacity: 0 }}
animate={{ opacity: 1 }}
exit={{ opacity: 0 }}
transition={{ duration: 0.2 }}
className="fixed inset-0 flex items-center justify-center bg-black/40"
>
<motion.div
ref={ref}
initial={{ scale: 0.95, opacity: 0 }}
animate={{ scale: 1, opacity: 1 }}
exit={{ scale: 0.95, opacity: 0 }}
transition={{ duration: 0.2, ease: [0.22, 1, 0.36, 1] }}
className="bg-white p-6 rounded"
>
<h2 id="modal-title">Titre de la Boîte de Dialogue</h2>
<button onClick={closeModal}>Fermer</button>
</motion.div>
</motion.div>
)}
</AnimatePresence>
)
}
export function Example() {
const [open, setOpen] = useState(false)
return (
<>
<button onClick={() => setOpen(true)}>Ouvrir</button>
<Modal open={open} closeModal={() => setOpen(false)} />
</>
)
}
Sécurité SSR
- Faire correspondre les états initiaux entre les rendus serveur et client
- Éviter les origines d'animation implicites (toujours définir
initialexplicitement) - Encapsuler les composants motion dans
"use client"dans le Next.js App Router
Débogage
Vérifiez :
- Mauvaise importation (mélange de
motion/reactetframer-motion) - Directive
"use client"manquante dans le Next.js App Router - Propriété
keymanquante sur les enfants deAnimatePresence - Incohérence d'hydratation (l'état initial diffère entre le SSR et le client)
- Mauvaise utilisation de la propriété
layoutsur les grands conteneurs provoquant des saccades de reflow - Animation pilotée par l'état qui ne se déclenche pas (vérifiez les tableaux de dépendances)
Assurance Qualité
- Pas de CLS
- Le clavier fonctionne
- Focus piégé dans les modales
- Rôles ARIA corrects (
role="dialog",aria-modal="true") - Mouvement réduit respecté (
useReducedMotion+ requête média CSS) - Pas d'avertissements d'hydratation dans Next.js
- Les animations s'arrêtent proprement au démontage (pas de fuites mémoire)
AnimatePresence modedéfini explicitement sur tous les sites d'utilisation
Anti-patrons
- Animer les propriétés de mise en page (
width,height,top,left) - Animations infinies sans but (demandez toujours : quel état cela communique-t-il ?)
- Échelonnement excessif des listes (gardez
staggerChildren≤ 0.1 s ; au-delà, cela semble lent) - Ignorer les préférences de mouvement réduit
- Utiliser
layoutsur les conteneurs grands ou couvrant toute la fenêtre - Omettre
modesurAnimatePresence(le défaut"sync"provoque un chevauchement visuel) - Utiliser la motion purement pour la décoration
Philosophie
La motion est une conception d'interaction.
Règle Finale
Si la motion n'améliore pas l'UX → supprimez-la.
Exemples
Interaction d'un Bouton
import { motion } from "motion/react"
export function Button() {
return (
<motion.button
whileHover={{ scale: 1.02 }}
whileTap={{ scale: 0.97 }}
transition={{ duration: 0.15, ease: [0.4, 0, 0.2, 1] }}
>
Cliquez-moi
</motion.button>
)
}
Exemple avec Mouvement Réduit
import { motion, useReducedMotion } from "motion/react"
export function FadeIn() {
const reduce = useReducedMotion()
return (
<motion.div
initial={{ opacity: 0, y: reduce ? 0 : 24 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: reduce ? 0.1 : 0.35, ease: [0.22, 1, 0.36, 1] }}
/>
)
}
Liste Échelonnée
import { motion } from "motion/react"
const container = {
hidden: {},
visible: {
transition: { staggerChildren: 0.08 } // garder ≤ 0.1 s pour éviter la lenteur
}
}
const item = {
hidden: { opacity: 0, y: 10 },
visible: { opacity: 1, y: 0, transition: { duration: 0.3, ease: [0.22, 1, 0.36, 1] } }
}
export function List() {
return (
<motion.ul variants={container} initial="hidden" animate="visible">
{[1, 2, 3].map(i => (
<motion.li key={i} variants={item}>Élément {i}</motion.li>
))}
</motion.ul>
)
}
Modale avec AnimatePresence
import { motion, AnimatePresence } from "motion/react"
export function Modal({ open }: { open: boolean }) {
return (
<AnimatePresence mode="wait">
{open && (
<motion.div
initial={{ opacity: 0, scale: 0.95 }}
animate={{ opacity: 1, scale: 1 }}
exit={{ opacity: 0, scale: 0.95 }}
transition={{ duration: 0.2, ease: [0.22, 1, 0.36, 1] }}
/>
)}
</AnimatePresence>
)
}
Parallaxe au Défilement
import { useScroll, useTransform, motion } from "motion/react"
export function Parallax() {
const { scrollYProgress } = useScroll()
const y = useTransform(scrollYProgress, [0, 1], [0, -80])
return <motion.div style={{ y }} />
}
Chargement Squelette
import { motion } from "motion/react"
export function Skeleton() {
return (
<motion.div
className="bg-gray-200 h-6 w-full rounded"
animate={{ opacity: [0.5, 1, 0.5] }}
transition={{
duration: 1.5, // impulsion confortable — était manquant, provoquait un flash rapide
repeat: Infinity,
ease: "easeInOut"
}}
/>
)
}
Mise en Page Partagée (Fondu Enchaîné)
import { motion } from "motion/react"
// layoutId doit être unique par instance montée.
// Si plusieurs instances peuvent exister simultanément, ajoutez un identifiant unique :
// layoutId={`shared-${item.id}`}
export function Shared() {
return <motion.div layoutId="shared" />
}