Que fait Motion System 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 mouvement quand le mouvement :
- Guide l'attention (ex : onboarding, 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 supporter 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 le mouvement quand
- Il est purement décoratif
- Il réduit l'utilisabilité ou la clarté
- Il impacte négativement la performance
Comment ça fonctionne
Principe fondamental
Le mouvement doit :
- Guider l'attention
- Communiquer un état
- Préserver la continuité spatiale
S'il ne fait rien de cela → supprimez-le.
Installation
npm install motion
Version
motion/react- par défaut pour les projets Motion for React actuels (paquet :motion)framer-motion- chemin d'importation hérité pour les projets qui dépendent encore de Framer Motion
Ne pas mélanger. Le mélange provoque des conflits de planificateurs internes et des contextes AnimatePresence cassés — les composants d'un paquet 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 à partir d'une source unique de manière cohérente :
// Correct (moderne)
import { motion, AnimatePresence } from "motion/react"
// Correct (hérité)
import { motion, AnimatePresence } from "framer-motion"
// Ne jamais mélanger les deux dans le même projet
Tokens de mouvement
// motionTokens.ts
export const motionTokens = {
duration: {
fast: 0.18,
normal: 0.35,
slow: 0.6
},
// Utilisez-les comme valeur `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" && (
// Mémoire faible (Chrome/Android uniquement ; undefined ailleurs → traité comme capable)
(navigator.deviceMemory !== undefined && navigator.deviceMemory <= 2) ||
// Peu de cœurs ET pas d'API mémoire (couvre Safari/Firefox sur du 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 & Patterns
Patterns fondamentaux
| Scénario | Pattern |
|---|---|
| Retour visuel au survol | whileHover |
| Retour visuel au tap / appui | whileTap |
| Révélation au défilement | whileInView |
| Valeur liée au défilement | useScroll + useTransform |
| Montage/démontage conditionnel | AnimatePresence |
| Petits décalages de mise en page (élément unique, < ~300px de changement) | Prop layout |
| Grands décalages de mise en page ou reflows de page entière | Éviter layout ; utiliser des transitions CSS ou un routage au niveau de la page à la place |
| Séquences impératives complexes | useAnimate |
Pourquoi éviter
layoutsur les grands conteneurs ? L'animation de mise en page de Framer utilisetransformpour réconcilier les positions, mais sur les éléments qui couvrent toute la zone visible ou qui déclenchent un reflow profond, le coût de mesure provoque un jank visible et une CLS (Cumulative Layout Shift). Préférez les transitions CSS Grid/Flexbox ou coordonnez aveclayoutIduniquement sur des éléments enfants spécifiques.
Mise en page & Transitions
- Transitions d'élément partagé →
layoutId(doit être unique par instance montée) - Transitions d'entrée / sortie →
AnimatePresence(voir les conseils surmodeci-dessous)
Mode AnimatePresence
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 que l'entrée ne commence. Utiliser pour les modales, toasts, transitions de page. |
"sync" (par défaut) | L'entrée et la sortie se chevauchent. Utiliser uniquement lorsque le chevauchement est intentionnel (ex : carrousels en fondu enchaîné). |
"popLayout" | L'élément sortant est immédiatement retiré du flux ; les éléments restants animent pour combler l'espace. Utiliser pour les 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>
Patterns 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 survol/tap)
- Système à ressort (mouvement basé sur la physique)
Essentiels des modales
- Piège à 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) - Envelopper les composants motion dans
"use client"dans App Router de Next.js
Débogage
Vérifiez :
- Mauvaise importation (mélange de
motion/reactetframer-motion) - Directive
"use client"manquante dans App Router de Next.js - Prop
keymanquante sur les enfants deAnimatePresence - Inadéquation d'hydratation (l'état initial diffère entre SSR et client)
- Mauvaise utilisation de la prop
layoutsur de grands conteneurs causant un jank de reflow - Animation pilotée par l'état qui ne se déclenche pas (vérifier 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+ media query CSS) - Aucun avertissement d'hydratation dans Next.js
- Les animations s'arrêtent proprement lors du 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 (toujours se demander : quel état cela communique-t-il ?)
- Échelonner excessivement les listes (garder
staggerChildren≤ 0.1s ; au-delà, cela semble lent) - Ignorer les préférences de mouvement réduit
- Utiliser
layoutsur des conteneurs volumineux ou occupant toute la zone visible - Omettre
modesurAnimatePresence(le défaut"sync"provoque un chevauchement visuel) - Utiliser le mouvement purement pour la décoration
Philosophie
Le mouvement est la conception d'interaction.
Règle finale
Si le mouvement n'améliore pas l'UX → supprimez-le.
Exemples
Interaction de 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 de 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.1s 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, // pulsation 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" />
}