Communitygithub.com

503496348-ops/mischief-production

Patrons d'animation prêts pour la production pour React / Next.js — bouton, modal, toast, décalage, transitions de page, animations de sortie, défilement et mise en page — construits sur les tokens et ressorts de motion-foundations.

Qu'est-ce que mischief-production ?

Ce skill fournit un ensemble de modèles d'animation éprouvés et prêts pour la production, spécialement conçus pour les applications React et Next.js. Il couvre les cas d'utilisation les plus courants : animations de boutons, cartes, modales, notifications toast, listes à décalage, transitions de page, révélations au défilement, cartes extensibles et transitions d'éléments partagés. Chaque modèle est construit exclusivement sur les tokens et ressorts provenant de la bibliothèque `motion-foundations`, garantissant une cohérence visuelle, des performances optimales et une accessibilité (SSR-safe). Le skill impose des règles strictes, comme l'encapsulation de tout rendu conditionnel dans `AnimatePresence` avec une `key`, la définition systématique des animations d'entrée et de sortie, et l'utilisation de `mode="wait"` pour les transitions de page. Il est conçu pour fonctionner avec `motion/react` et Next.js App Router, et fournit des extraits de code directement utilisables ainsi qu'un guide de décision pour choisir le bon modèle en fonction de la situation, tout en évitant les anti-patrons explicitement documentés.

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

Demander à votre IA préférée

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

Documentation

Motion Patterns

Modèles copier-coller pour les besoins d'animation UI les plus courants. Tous ces modèles sont construits sur les tokens et ressorts de motion-foundations. Ne définissez pas de nouvelles durées ou courbes d'assouplissement ici — importez-les.

Quand activer ce skill

  • Animer un bouton, une carte, une modale ou une notification toast
  • Construire des entrées de liste avec décalage (stagger)
  • Mettre en place des transitions de page dans le routeur App de Next.js
  • Ajouter des animations d'entrée ou de sortie sur du contenu conditionnel
  • Implémenter des révélations au défilement, une progression liée au défilement ou des sections narratives « sticky »
  • Créer des cartes extensibles, des accordéons ou des transitions d'éléments partagés

Résultats

Ce skill produit :

  • Des animations accessibles et compatibles SSR pour tous les composants d'interface standard
  • Des rendus conditionnels encapsulés dans AnimatePresence avec un comportement de sortie correct
  • Un composant wrapper de transition de page pour le routeur App de Next.js
  • Des motifs de révélation et de progression au défilement utilisant useScroll + useTransform
  • Des animations de mise en page (layout, layoutId) pour les éléments expansibles et les fondus enchaînés

Principes

  • Chaque modèle importe depuis motion-foundations. Pas de valeurs brutes.
  • Chaque rendu conditionnel est encapsulé dans AnimatePresence avec une key.
  • Les animations de sortie sont toujours définies en même temps que les animations d'entrée — jamais après coup.
  • layout est utilisé uniquement pour de petits décalages isolés. Les grandes sous-arbres utilisent des transformations explicites.

Règles

  1. Encapsulez toujours les rendus conditionnels dans AnimatePresence avec une key sur l'enfant direct. Sans key, les animations de sortie ne se déclenchent jamais.
  2. Définissez toujours exit lorsque vous définissez initial + animate. Une animation sans sortie est incomplète.
  3. Utilisez mode="wait" pour les transitions de page. L'entrée ne doit pas commencer avant la fin de la sortie.
  4. N'utilisez jamais layout sur des sous-arbres de plus de ~5 enfants ou avec un DOM profondément imbriqué. Utilisez plutôt des transformations explicites x/y.
  5. L'intervalle de décalage (stagger) doit rester entre 0.05s et 0.10s. En dessous, cela semble mécanique ; au-dessus, cela semble lent.
  6. Les modales doivent toujours inclure : piège de focus (focus trap), fermeture avec la touche Échap, verrouillage du défilement, role="dialog", aria-modal="true".
  7. Les révélations au défilement utilisent viewport={{ once: true }}. Se répéter lors du défilement en arrière est distrayant, pas informatif.
  8. Toutes les valeurs des tokens sont importées depuis motion-foundations. Pas de nombres en ligne.

Guide de décision

Choisir le bon modèle

SituationModèle
Un élément apparaît / disparaîtAnimatePresence
Une liste d'éléments se charge en séquenceVariantes avec décalage (stagger)
Navigation entre les routesWrapper de transition de page
Un élément change de taille sur placePropriété layout
Un même élément se déplace d'un contexte de page à un autrelayoutId
Un élément entre en scène lors du défilementwhileInView
Valeur liée à la position de défilementuseScroll + useTransform

Quand utiliser mode="wait" vs mode="sync"

ModeUtilisation
waitTransitions de page, échanges de contenu (un à la fois)
syncNotifications empilées, éléments de liste (le chevauchement est acceptable)
popLayoutÉléments supprimés d'une liste qui se réorganise

Concepts clés

Contrat AnimatePresence

Trois choses doivent toujours être vraies :

  1. AnimatePresence encapsule la condition
  2. L'enfant direct a une key
  3. L'enfant a une propriété exit

Si l'une de ces conditions n'est pas remplie, l'animation de sortie échoue silencieusement.

layout vs layoutId

  • layout — anime le changement de taille/position propre de l'élément sur place
  • layoutId — relie deux éléments distincts, créant un fondu enchaîné entre eux lors des rendus

Utilisez layout="position" sur le texte à l'intérieur d'un conteneur extensible pour empêcher que le réarrangement du texte ne soit animé.

Exemples de code

Retour visuel d'un bouton

"use client"
import { motion } from "motion/react"
import { springs, motionTokens } from "@/lib/motion-tokens"

<motion.button
  whileHover={{ scale: motionTokens.scale.pop }}
  whileTap={{ scale: motionTokens.scale.press }}
  transition={springs.snappy}
/>

Liste avec décalage (stagger)

"use client"
import { motion } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"

const container = {
  hidden: {},
  visible: {
    transition: {
      staggerChildren: 0.08,   // dans la règle 0.05–0.10
      delayChildren: 0.1,
    },
  },
}

const item = {
  hidden:  { opacity: 0, y: motionTokens.distance.md },
  visible: { opacity: 1, y: 0, transition: springs.gentle },
}

<motion.ul variants={container} initial="hidden" animate="visible">
  {items.map((i) => (
    <motion.li key={i.id} variants={item} />
  ))}
</motion.ul>

Modale

"use client"
import { motion, AnimatePresence } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"

// Encapsuler au point d'appel :
// <AnimatePresence>{isOpen && <Modal key="modal" />}</AnimatePresence>

export function Modal({ onClose }: { onClose: () => void }) {
  return (
    <>
      {/* Fond */}
      <motion.div
        className="fixed inset-0 bg-black/50"
        initial={{ opacity: 0 }}
        animate={{ opacity: 1 }}
        exit={{ opacity: 0 }}
        onClick={onClose}
      />

      {/* Panneau — exigences d'accessibilité : piège de focus, fermeture Échap,
          verrouillage du défilement, role="dialog", aria-modal="true" */}
      <motion.div
        role="dialog"
        aria-modal="true"
        className="fixed inset-x-4 top-1/2 -translate-y-1/2 rounded-xl bg-white p-6"
        initial={{
          opacity: 0,
          scale: motionTokens.scale.press,
          y: motionTokens.distance.sm,
        }}
        animate={{ opacity: 1, scale: 1, y: 0 }}
        exit={{
          opacity: 0,
          scale: motionTokens.scale.press,
          y: motionTokens.distance.sm,
        }}
        transition={springs.gentle}
      />
    </>
  )
}

Pile de toasts

"use client"
import { motion, AnimatePresence } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"

<AnimatePresence mode="sync">
  {toasts.map((t) => (
    <motion.div
      key={t.id}
      layout
      initial={{
        opacity: 0,
        x: motionTokens.distance.xl,
        scale: motionTokens.scale.subtle,
      }}
      animate={{ opacity: 1, x: 0, scale: 1 }}
      exit={{
        opacity: 0,
        x: motionTokens.distance.xl,
        scale: motionTokens.scale.subtle,
      }}
      transition={springs.snappy}
    />
  ))}
</AnimatePresence>

Transition de page (Routeur App Next.js)

// components/page-transition.tsx
"use client"
import { motion, AnimatePresence } from "motion/react"
import { usePathname } from "next/navigation"
import { motionTokens } from "@/lib/motion-tokens"

const variants = {
  initial: { opacity: 0, y: motionTokens.distance.sm },
  enter:   { opacity: 1, y: 0 },
  exit:    { opacity: 0, y: -motionTokens.distance.sm },
}

export function PageTransition({ children }: { children: React.ReactNode }) {
  const pathname = usePathname()
  return (
    <AnimatePresence mode="wait">
      <motion.div
        key={pathname}
        variants={variants}
        initial="initial"
        animate="enter"
        exit="exit"
        transition={{
          duration: motionTokens.duration.normal,
          ease: motionTokens.easing.smooth,
        }}
      >
        {children}
      </motion.div>
    </AnimatePresence>
  )
}

Révélation au défilement

"use client"
import { motion } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"

<motion.div
  initial={{ opacity: 0, y: motionTokens.distance.lg }}
  whileInView={{ opacity: 1, y: 0 }}
  viewport={{ once: true, margin: "-80px" }}   // once: true — règle 7
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Barre de progression au défilement

"use client"
import { motion, useScroll } from "motion/react"

export function ScrollProgress() {
  const { scrollYProgress } = useScroll()
  return (
    <motion.div
      className="fixed top-0 left-0 h-1 bg-indigo-500 origin-left w-full"
      style={{ scaleX: scrollYProgress }}
    />
  )
}

Carte extensible

"use client"
import { useState } from "react"
import { motion, AnimatePresence } from "motion/react"
import { springs, motionTokens } from "@/lib/motion-tokens"

export function ExpandingCard({ title, body }: { title: string; body: string }) {
  const [expanded, setExpanded] = useState(false)

  return (
    <motion.div layout onClick={() => setExpanded(!expanded)} className="cursor-pointer">
      {/* layout="position" empêche l'animation du réarrangement du texte */}
      <motion.h2 layout="position" className="font-semibold">
        {title}
      </motion.h2>

      <AnimatePresence>
        {expanded && (
          <motion.p
            key="body"
            initial={{ opacity: 0 }}
            animate={{ opacity: 1 }}
            exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            {body}
          </motion.p>
        )}
      </AnimatePresence>
    </motion.div>
  )
}

Fondu enchaîné d'élément partagé

// Contexte source
<motion.img layoutId="hero-image" src={src} className="w-16 h-16 rounded" />

// Contexte destination (même layoutId — motion gère la transition)
<motion.img layoutId="hero-image" src={src} className="w-full rounded-xl" />

Accordéon

<motion.div
  initial={false}
  animate={{ opacity: open ? 1 : 0, scaleY: open ? 1 : 0 }}
  style={{ transformOrigin: "top", overflow: "hidden" }}
  transition={{
    duration: motionTokens.duration.normal,
    ease: motionTokens.easing.smooth,
  }}
> {children}
</motion.div>

Exemple complet

Une liste à décalage qui entre en scène au montage, gère la présence conditionnelle, et respecte le paramètre de mouvement réduit — combinant tokens, ressorts, AnimatePresence et le hook d'accessibilité de motion-foundations :

"use client"
import { useState } from "react"
import { motion, AnimatePresence } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"
import { useSafeMotion } from "@/hooks/use-reduced-motion"

const containerVariants = {
  hidden: {},
  visible: {
    transition: { staggerChildren: 0.08, delayChildren: 0.1 },
  },
}

function ListItem({ label, onRemove }: { label: string; onRemove: () => void }) {
  const safe = useSafeMotion(motionTokens.distance.sm)
  return (
    <motion.li
      variants={{
        hidden:  safe.initial,
        visible: safe.animate,
      }}
      exit={safe.exit}
      transition={springs.gentle}
      className="flex items-center justify-between p-3 rounded-lg bg-white shadow-sm"
    >
      <span>{label}</span>
      <button onClick={onRemove}>Supprimer</button>
    </motion.li>
  )
}

export function AnimatedList({ items, onRemove }: {
  items: { id: string; label: string }[]
  onRemove: (id: string) => void
}) {
  return (
    <motion.ul
      variants={containerVariants}
      initial="hidden"
      animate="visible"
      className="space-y-2"
    >
      <AnimatePresence mode="popLayout">
        {items.map((item) => (
          <ListItem
            key={item.id}
            label={item.label}
            onRemove={() => onRemove(item.id)}
          />
        ))}
      </AnimatePresence>
    </motion.ul>
  )
}

Contraintes / Objectifs hors périmètre

Ce skill ne couvre pas :

  • Les définitions de tokens et ressorts → voir motion-foundations
  • Les interactions de glissement, les gestes de balayage, les listes réorganisables → voir motion-advanced
  • Les animations de texte (révélation de mots/caractères, compteurs) → voir motion-advanced
  • Le dessin ou morphing de chemins SVG → voir motion-advanced
  • Les hooks d'animation personnalisés → voir motion-advanced
  • Les transitions CSS uniquement n'utilisant pas motion/react

Anti-patrons

Anti-patronRègle violéeCorrection
Enfant d'AnimatePresence sans keyRègle 1Ajouter une key stable à l'enfant direct
initial + animate sans exitRègle 2Toujours définir les trois ensemble
Transition de page sans mode="wait"Règle 3Ajouter mode="wait" à AnimatePresence
layout sur une liste de 50 élémentsRègle 4Utiliser mode="popLayout" ou des transformations explicites
staggerChildren: 0.2 sur une liste de 10 élémentsRègle 5Limiter à 0.08–0.10
Modale sans piège de focusRègle 6Ajouter focus-trap-react ou Radix Dialog
whileInView sans viewport={{ once: true }}Règle 7Les entrées répétitives distraient, n'informent pas
transition={{ duration: 0.3 }} en ligneRègle 8Utiliser motionTokens.duration.normal

Compétences associées

  • motion-foundations — définit tous les tokens, ressorts, le hook useSafeMotion et les gardes SSR que chaque modèle importe. Doit être configuré en premier.
  • motion-advanced — étend ces modèles avec le glissement, les gestes, le SVG, le texte, les hooks personnalisés et la séquençage impératif. Ne redéfinit aucun modèle de cette compétence.

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 UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

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