Communitygithub.com

503496348-ops/mischief-production

Padrões de animação prontos para produção em React / Next.js — botão, modal, toast, escalonamento, transições de página, animações de saída, scroll e layout — construídos sobre tokens e molas do motion-foundations.

O que é mischief-production?

Este skill fornece uma coleção de padrões de animação para React e Next.js, projetados especificamente para componentes de UI comuns como botões, modais, notificações toast, listas escalonadas, transições de página no App Router do Next.js, conteúdo revelado pelo scroll e cartões expansíveis. Ele é construído sobre os tokens e molas definidos no `motion-foundations`, garantindo que todas as animações sejam consistentes, acessíveis e seguras para SSR. O skill enfatiza práticas recomendadas como o uso obrigatório do `AnimatePresence` com `key` para animações de saída, definição explícita das propriedades `exit` e modos de transição adequados (`mode="wait"` para páginas). Além disso, ele orienta sobre decisões de design, anti-padrões comuns e restrições, deixando claro o que está fora do escopo deste skill e quais skills relacionados (`motion-foundations` e `motion-advanced`) devem ser usados em conjunto para uma stack de animação completa no ecossistema Framer Motion.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Motion Patterns

Padrões copie-e-cole para as necessidades mais comuns de animação de UI. Cada padrão aqui é construído sobre tokens e molas do motion-foundations. Não defina novos valores de duração ou easing aqui — importe-os.

Quando Ativar

  • Ao animar um botão, cartão, modal ou notificação toast
  • Ao construir entradas de lista com escalonamento (stagger)
  • Ao configurar transições de página no App Router do Next.js
  • Ao adicionar animações de entrada ou saída a conteúdo condicional
  • Ao implementar revelação por scroll, progresso vinculado ao scroll ou seções de história fixas
  • Ao construir cartões expansíveis, acordeões ou transições de elemento compartilhado

Resultados

Este skill produz:

  • Animações acessíveis e seguras para SSR de todos os componentes de UI padrão
  • Renderizações condicionais envolvidas em AnimatePresence com comportamento de saída correto
  • Componente wrapper para transição de página no App Router do Next.js
  • Padrões de revelação por scroll e vinculados ao scroll usando useScroll + useTransform
  • Padrões de animação de layout (layout, layoutId) para elementos que se expandem e se sobrepõem

Princípios

  • Cada padrão importa do motion-foundations. Sem números brutos.
  • Toda renderização condicional é envolvida em AnimatePresence com uma key.
  • Animações de saída são sempre definidas junto com as de entrada — nunca como um pensamento posterior.
  • layout é usado apenas para pequenos deslocamentos isolados. Subárvores grandes recebem transformações explícitas.

Regras

  1. Sempre envolva renderizações condicionais em AnimatePresence com uma key no filho direto. Sem uma key, as animações de saída nunca são executadas.
  2. Sempre defina exit ao definir initial + animate. Uma animação sem saída está incompleta.
  3. Use mode="wait" em transições de página. A entrada não deve começar até que a saída termine.
  4. Nunca use layout em subárvores com mais de ~5 filhos ou DOM profundamente aninhado. Use transformações explícitas de x/y.
  5. O intervalo de escalonamento (stagger) deve ficar entre 0.05s e 0.10s. Abaixo disso parece mecânico; acima parece lento.
  6. Modais devem sempre incluir: foco armadilhado (focus trap), fechamento com tecla Escape, bloqueio de scroll, role="dialog", aria-modal="true".
  7. Revelações por scroll usam viewport={{ once: true }}. Repetir ao sair da tela é distrativo, não informativo.
  8. Todos os valores de tokens são importados do motion-foundations. Sem números inline.

Orientação de Decisão

Escolhendo o padrão certo

SituaçãoPadrão
Elemento aparece / desapareceAnimatePresence
Lista de itens carregando em sequênciaVariantes de escalonamento (stagger)
Navegando entre rotasWrapper de transição de página
Elemento muda de tamanho no lugarPropriedade layout
Mesmo elemento se move entre contextos de páginalayoutId
Elemento entra quando visível no scrollwhileInView
Valor vinculado à posição do scrolluseScroll + useTransform

Quando usar mode="wait" vs mode="sync"

ModoUse quando
waitTransições de página, troca de conteúdo (um de cada vez)
syncNotificações empilhadas, itens de lista (sobreposição é aceitável)
popLayoutItens removidos de uma lista com refluxo

Conceitos Principais

Contrato do AnimatePresence

Três coisas devem ser sempre verdadeiras:

  1. AnimatePresence envolve o condicional
  2. O filho direto tem uma key
  3. O filho tem uma propriedade exit

Faltar qualquer uma delas e a animação de saída falha silenciosamente.

layout vs layoutId

  • layout — anima a própria mudança de tamanho/posição do elemento no lugar
  • layoutId — conecta dois elementos separados, fazendo uma transição suave entre eles durante as renderizações

Use layout="position" no texto dentro de um contêiner em expansão para evitar que o refluxo de texto seja animado.

Exemplos de Código

Feedback de botão

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

// Envolver no local de chamada:
// <AnimatePresence>{isOpen && <Modal key="modal" />}</AnimatePresence>

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

      {/* Painel — requisitos de acessibilidade: foco armadilhado, fechamento com Escape,
          bloqueio 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}
      />
    </>
  )
}

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

Transição 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>
  )
}

Revelação 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 — regra 7
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Barra de progresso do 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 }}
    />
  )
}

Cartão expansível

"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" impede que o refluxo de texto seja animado */}
      <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>
  )
}

Transição de elemento compartilhado (crossfade)

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

// Contexto de destino (mesmo layoutId — o motion gerencia a transição)
<motion.img layoutId="hero-image" src={src} className="w-full rounded-xl" />

Acordeão

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

Exemplo Completo (Ponta a Ponta)

Uma lista escalonada que entra ao montar, lida com presença condicional e respeita movimento reduzido — combinando tokens, molas, AnimatePresence e o hook de acessibilidade do 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}>Remove</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>
  )
}

Restrições / Não Objetivos

Este skill não cobre:

  • Definições de tokens e molas → veja motion-foundations
  • Interações de arraste, gestos de swipe, listas reordenáveis → veja motion-advanced
  • Animações de texto (revelação de palavras/caracteres, contadores) → veja motion-advanced
  • Desenho de caminhos SVG ou morphing → veja motion-advanced
  • Hooks de animação personalizados → veja motion-advanced
  • Transições CSS-only que não usam motion/react

Anti-Padrões

Anti-padrãoRegra violadaCorreção
Filho de AnimatePresence sem keyRegra 1Adicionar key estável ao filho direto
initial + animate sem exitRegra 2Sempre definir todos os três juntos
Transição de página sem mode="wait"Regra 3Adicionar mode="wait" ao AnimatePresence
layout em uma lista de 50 itensRegra 4Usar mode="popLayout" ou transformações explícitas
staggerChildren: 0.2 em uma lista de 10 itensRegra 5Limitar a 0.08–0.10
Modal sem foco armadilhadoRegra 6Adicionar focus-trap-react ou Radix Dialog
whileInView sem viewport={{ once: true }}Regra 7Entradas repetidas distraem, não informam
transition={{ duration: 0.3 }} inlineRegra 8Usar motionTokens.duration.normal

Skills Relacionados

  • motion-foundations — define todos os tokens, molas, o hook useSafeMotion e guardas SSR que cada padrão aqui importa. Deve ser configurado primeiro.
  • motion-advanced — estende estes padrões com arraste, gestos, SVG, texto, hooks personalizados e sequenciamento imperativo. Não redefine nenhum padrão deste skill.

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.

Habilidades Relacionadas