Communitygithub.com

503496348-ops/mischief-production

Système d'animation UI prêt pour la production pour React/Next.js. À utiliser pour implémenter des animations, transitions ou motifs de mouvement.

Qu'est-ce que mischief-production ?

Ce skill fournit un système de motion UI complet et prêt pour la production, conçu pour les projets React et Next.js. Il est axé sur la performance, l'accessibilité et la convivialité, plutôt que sur la décoration pure. Le skill détaille quand utiliser la motion (pour guider l'attention, communiquer un état, préserver la continuité spatiale) et quand l'éviter (décoration pure, réduction de la lisibilité, impact négatif sur les performances). Il explique comment installer et importer correctement la bibliothèque Motion, en insistant sur l'importance de ne pas mélanger les imports modernes (`motion/react`) et legacy (`framer-motion`) pour éviter des conflits d'ordonnancement. Le skill propose des tokens de motion réutilisables (durées, easings, distances) pour standardiser les animations, ainsi que des règles de performance (privilégier les transformations et l'opacité, éviter les propriétés de layout), une adaptation aux appareils bas de gamme, et des directives d'accessibilité (respect du « reduced motion » via JavaScript, CSS et Tailwind). Il couvre également des patterns architecturaux avancés comme `AnimatePresence` avec différents modes (`wait`, `sync`, `popLayout`), les transitions d'éléments partagés, les animations au scroll, les squelettes de chargement, et fournit des exemples complets (boutons, listes, modales, parallaxe). Enfin, il inclut des bonnes pratiques pour la sécurité SSR, le débogage, l'assurance qualité, et liste les anti-patrons à éviter, le tout résumé par une philosophie centrale : si la motion n'améliore pas l'expérience utilisateur, il faut la supprimer.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/503496348-ops/mischief-production/tree/HEAD/skills/ecc-motion-ui

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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énarioPatron
Retour visuel au survolwhileHover
Retour visuel au toucher / pressionwhileTap
Révélation au défilementwhileInView
Valeur liée au défilementuseScroll + useTransform
Montage/démontage conditionnelAnimatePresence
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 complexesuseAnimate

Pourquoi éviter layout sur les grands conteneurs ? L'animation de mise en page de Framer utilise transform pour 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 avec layoutId uniquement 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 sur mode ci-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.

modeQuand 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é (layoutId partagé)
  • 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 initial explicitement)
  • Encapsuler les composants motion dans "use client" dans le Next.js App Router

Débogage

Vérifiez :

  • Mauvaise importation (mélange de motion/react et framer-motion)
  • Directive "use client" manquante dans le Next.js App Router
  • Propriété key manquante sur les enfants de AnimatePresence
  • Incohérence d'hydratation (l'état initial diffère entre le SSR et le client)
  • Mauvaise utilisation de la propriété layout sur 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 mode dé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 layout sur les conteneurs grands ou couvrant toute la fenêtre
  • Omettre mode sur AnimatePresence (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" />
}

Individual skills in this repo

This repo contains 7 individual skills — each has its own dedicated page.

503496348-ops/mischief-production

Use this skill when inspecting Blender characters, rigs, poses, animation retargeting, ground contact, facing direction, or model-vs-motion alignment where screenshots alone are not enough.

503496348-ops/mischief-production

Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider HCP video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script.

503496348-ops/mischief-production

Advanced motion patterns for React / Next.js — drag & drop, gestures, text animations, SVG path drawing, custom hooks, imperative sequences (useAnimate), loaders, and the full API decision tree. Requires motion-foundations.

503496348-ops/mischief-production

Motion tokens, spring presets, performance rules, device adaptation, accessibility enforcement, and SSR safety for React / Next.js using motion/react. Foundation layer — all other motion skills depend on this.

503496348-ops/mischief-production

Production-ready animation patterns for React / Next.js — button, modal, toast, stagger, page transitions, exit animations, scroll, and layout — built on motion-foundations tokens and springs.

503496348-ops/mischief-production

Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more.

503496348-ops/mischief-production

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

Skills associés