Communitygithub.com

503496348-ops/mischief-production

Patrones de animación listos para producción para React / Next.js — botones, modales, notificaciones, escalonados, transiciones de página, animaciones de salida, scroll y layout — construidos sobre tokens y springs de motion-foundations.

¿Qué es mischief-production?

Esta habilidad proporciona un conjunto completo de patrones de animación listos para copiar y pegar, diseñados específicamente para React y Next.js, con énfasis en la accesibilidad, el rendimiento SSR y una correcta gestión de estados. Todos los patrones se basan exclusivamente en los tokens y springs definidos en `motion-foundations`, evitando el uso de valores numéricos en línea para garantizar consistencia y mantenibilidad. La habilidad cubre desde animaciones simples de botones, modales y notificaciones toast hasta patrones complejos como listas escalonadas con `AnimatePresence`, transiciones entre páginas en Next.js App Router, revelaciones por scroll y animaciones de layout con `layoutId`. Incluye reglas estrictas que obligan al uso de `AnimatePresence` con `key` en renders condicionales, la definición completa de `initial`, `animate` y `exit`, y la adopción de buenas prácticas de accesibilidad (foco, cierre con Escape, bloqueo de scroll) en modales. La habilidad es compatible con cualquier proyecto React o Next.js que tenga configurado `motion-foundations` y `motion/react`, y su documentación incluye ejemplos de código completos, guías de decisión para elegir el patrón correcto y una sección de anti-patrones para evitar errores comunes.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Motion Patterns

Patrones listos para copiar y pegar para las necesidades más comunes de animación UI. Cada patrón está construido sobre los tokens y springs de motion-foundations. No definas nuevos valores de duración o easing aquí — impórtalos.

Cuándo activar

  • Al animar un botón, tarjeta, modal o notificación toast
  • Al construir entradas de listas con escalonado (stagger)
  • Al configurar transiciones de página en Next.js App Router
  • Al agregar animaciones de entrada o salida a contenido condicional
  • Al implementar revelaciones por scroll, progreso vinculado al scroll o secciones de historias sticky
  • Al construir tarjetas expandibles, acordeones o transiciones de elementos compartidos

Salidas

Esta habilidad produce:

  • Animaciones accesibles y seguras para SSR para todos los componentes UI estándar
  • Renders condicionales envueltos en AnimatePresence con comportamiento de salida correcto
  • Componente envolvente de transición de página para Next.js App Router
  • Patrones de revelación por scroll y vinculados al scroll usando useScroll + useTransform
  • Patrones de animación de layout (layout, layoutId) para expandir y difuminar elementos

Principios

  • Cada patrón importa desde motion-foundations. Sin números crudos.
  • Cada render condicional está envuelto en AnimatePresence con un key.
  • Las animaciones de salida siempre se definen junto a las de entrada — nunca como una ocurrencia tardía.
  • layout se usa solo para cambios pequeños y aislados. Los subárboles grandes reciben transforms explícitos.

Reglas

  1. Siempre envuelve los renders condicionales en AnimatePresence con un key en el hijo directo. Sin una key, las animaciones de salida nunca se ejecutan.
  2. Siempre define exit cuando definas initial + animate. Una animación sin salida está incompleta.
  3. Usa mode="wait" en las transiciones de página. La entrada no debe comenzar hasta que la salida haya terminado.
  4. Nunca uses layout en subárboles con más de ~5 hijos o DOM profundamente anidado. Usa transforms explícitos de x/y en su lugar.
  5. El intervalo de escalonado (stagger) debe mantenerse entre 0.05s y 0.10s. Por debajo se siente mecánico; por encima se siente lento.
  6. Las modales siempre deben incluir: trampa de foco, cierre con Escape, bloqueo de scroll, role="dialog", aria-modal="true".
  7. Las revelaciones por scroll usan viewport={{ once: true }}. Repetir al salir del viewport es distractor, no informativo.
  8. Todos los valores de token se importan desde motion-foundations. Sin números en línea.

Guía de decisión

Elegir el patrón correcto

SituaciónPatrón
Elemento aparece / desapareceAnimatePresence
Lista de elementos cargando en secuenciaVariantes con stagger
Navegando entre rutasComponente envolvente de transición de página
Elemento cambia de tamaño en su lugarPropiedad layout
Mismo elemento se mueve entre contextos de páginalayoutId
Elemento entra al hacerse visible en el scrollwhileInView
Valor vinculado a la posición del scrolluseScroll + useTransform

Cuándo usar mode="wait" vs mode="sync"

ModoÚsalo cuando
waitTransiciones de página, intercambios de contenido (uno a la vez)
syncNotificaciones apiladas, elementos de lista (la superposición está bien)
popLayoutElementos eliminados de una lista con reflujo

Conceptos clave

Contrato de AnimatePresence

Tres cosas deben ser siempre ciertas:

  1. AnimatePresence envuelve el condicional
  2. El hijo directo tiene un key
  3. El hijo tiene una propiedad exit

Si falta alguna de estas, la animación de salida falla silenciosamente.

layout vs layoutId

  • layout — anima el cambio de tamaño/posición del propio elemento en su lugar
  • layoutId — vincula dos elementos separados, difuminando entre ellos a través de renders

Usa layout="position" en el texto dentro de un contenedor expandible para evitar que el reflujo de texto se anime.

Ejemplos de código

Retroalimentación de botón

"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}
/>

Lista escalonada

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

const container = {
  hidden: {},
  visible: {
    transition: {
      staggerChildren: 0.08,   // dentro de la regla 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>

Modal

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

// Envuelve en el lugar de uso:
// <AnimatePresence>{isOpen && <Modal key="modal" />}</AnimatePresence>

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

      {/* Panel — requisitos de accesibilidad: trampa de foco, cierre con Escape,
          bloqueo de scroll, 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}
      />
    </>
  )
}

Pila de notificaciones toast

"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>

Transición de página (Next.js App Router)

// 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>
  )
}

Revelación por scroll

"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 — regla 7
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Barra de progreso de scroll

"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 }}
    />
  )
}

Tarjeta expandible

"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" evita que el reflujo de texto se anime */}
      <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>
  )
}

Difuminado de elemento compartido

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

// Contexto de destino (mismo layoutId — motion maneja la transición)
<motion.img layoutId="hero-image" src={src} className="w-full rounded-xl" />

Acordeón

<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>

Ejemplo integral

Una lista escalonada que entra al montarse, maneja presencia condicional y respeta el movimiento reducido — combinando tokens, springs, AnimatePresence y el hook de accesibilidad 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}>Eliminar</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>
  )
}

Restricciones / No objetivos

Esta habilidad no cubre:

  • Definiciones de tokens y springs → ver motion-foundations
  • Interacciones de arrastre, gestos de deslizamiento, listas reordenables → ver motion-advanced
  • Animaciones de texto (revelación de palabras/caracteres, contadores) → ver motion-advanced
  • Dibujo o transformación de rutas SVG → ver motion-advanced
  • Hooks de animación personalizados → ver motion-advanced
  • Transiciones solo CSS que no usen motion/react

Anti-patrones

Anti-patrónRegla violadaSolución
Hijo de AnimatePresence sin keyRegla 1Agrega un key estable al hijo directo
initial + animate sin exitRegla 2Define siempre los tres juntos
Transición de página sin mode="wait"Regla 3Agrega mode="wait" al AnimatePresence
layout en una lista de 50 elementosRegla 4Usa mode="popLayout" o transforms explícitos
staggerChildren: 0.2 en una lista de 10 elementosRegla 5Limita a 0.08–0.10
Modal sin trampa de focoRegla 6Agrega focus-trap-react o Radix Dialog
whileInView sin viewport={{ once: true }}Regla 7Las entradas repetidas distraen, no informan
transition={{ duration: 0.3 }} en líneaRegla 8Usa motionTokens.duration.normal

Habilidades relacionadas

  • motion-foundations — define todos los tokens, springs, el hook useSafeMotion y los guards SSR que cada patrón aquí importa. Debe configurarse primero.
  • motion-advanced — extiende estos patrones con arrastre, gestos, SVG, texto, hooks personalizados y secuenciación imperativa. No redefine ningún patrón de esta habilidad.

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 relacionados