Communitygithub.com

503496348-ops/mischief-production

Padrões avançados de animação para React / Next.js — arrastar e soltar, gestos, animações de texto, desenho de caminhos SVG, hooks personalizados, sequências imperativas (useAnimate), carregadores e a árvore de decisão completa da API. Requer motion-foundations.

O que é mischief-production?

Este skill fornece um conjunto abrangente de padrões de animação complexos e interativos para React e Next.js, baseados em física e orientados a gestos. Ele é ativado quando os padrões básicos de animação (motion-patterns) não são suficientes, permitindo a criação de interfaces de usuário sofisticadas com arrastar para descartar, listas reordenáveis, swipe gestures, animações de texto palavra por palavra ou caractere por caractere, e desenho de caminhos SVG. O skill abrange APIs de alto nível como Reorder.Group para listas arrastáveis, hooks personalizados como useScrollReveal , e sequências imperativas com useAnimate para controle preciso de animações multi-etapas. Ele também inclui componentes de carregamento como spinners e shimmer skeletons, e enfatiza princípios como animações baseadas em física com useSpring , uso de useMotionValue e useTransform para computação reativa sem re-renderizações, e a importância de pausar animações infinitas quando a aba do navegador está oculta. O skill é compatível com motion-foundations e fornece regras claras para garantir desempenho, acessibilidade em dispositivos de toque e boas práticas com hooks.

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

Perguntar na sua IA favorita

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

Documentação

Motion Avançado

Padrões de animação complexos, interativos e baseados em física. Requer que motion-foundations esteja configurado primeiro. Use estes quando motion-patterns não for suficiente.

Quando Ativar

  • Construindo folhas de arrastar para descartar, gestos de deslizar ou listas reordenáveis
  • Animando texto palavra por palavra, caractere por caractere, ou como um contador ao vivo
  • Desenhando caminhos SVG, transformando ícones ou animando progresso circular
  • Escrevendo um hook de animação personalizado (useScrollReveal, botão magnético, seguidor de cursor)
  • Sequenciando animações multi-etapas imperativamente com useAnimate
  • Construindo spinners, shimmer skeletons, indicadores de pulso ou estados de botão de carregamento

Saídas

Este skill produz:

  • Interações de arrastar: cartões arrastáveis, folhas de arrastar para descartar, listas Reorder.Group
  • Hooks de gestos: detecção de deslizar, toque longo, contorno de pinça
  • Componentes de animação de texto: revelação de palavras, máquina de escrever de caracteres, contador de números
  • Animações SVG: desenho de caminho, transformação de ícone, anel de progresso de traço
  • Hooks personalizados: useScrollReveal, useHoverScale, useNavigationDirection, useInViewOnce
  • Sequências imperativas via useAnimate com async/await à prova de interrupção
  • Componentes de carregamento: spinner, shimmer, ponto de pulso, barra de progresso, estado de carregamento de botão

Princípios

  • Movimento baseado em física (useSpring, springs.*) sempre parece mais natural que baseado em duração para manipulação direta.
  • useMotionValue + useTransform computa valores derivados sem disparar re-renderizações.
  • Sequências useAnimate são imperativas e à prova de interrupção — chamar animate() durante a execução cancela a animação anterior automaticamente.
  • Valores de movimento (useMotionValue, useSpring) são seguros para SSR e não causam erros de hidratação.

Regras

  1. Interações de arrastar devem ser testadas em dispositivos de toque, não apenas no mouse. A prop drag funciona em ambos, mas a sensação e o limiar diferem.
  2. Animações infinitas devem pausar quando document.visibilityState === "hidden". Abas em segundo plano não devem consumir GPU/CPU.
  3. O limiar de deslize deve ser explícito. Nunca inferir a intenção apenas pela velocidade; combinar verificações de offset + velocity.
  4. A ref de escopo do useAnimate deve ser anexada a um elemento DOM montado. Chamar animate() antes da montagem falha silenciosamente.
  5. Valores de movimento não devem ser recriados na renderização. useMotionValue(0) dentro do corpo do componente é correto; new MotionValue(0) na renderização não é.
  6. Todos os valores de token são importados de motion-foundations. Sem números embutidos.
  7. Hooks personalizados devem lidar com a limpeza. Todo window.addEventListener precisa de um removeEventListener correspondente no retorno do useEffect.
  8. Transformação de SVG requer contagens iguais de comandos de caminho. Caminhos com estruturas de comando diferentes fazem um salto em vez de interpolar.

Orientação de Decisão

Escolhendo a API avançada correta

CenárioAPI
Arrastar com física na solturadrag + dragTransition: springs.release
Lista ordenada de arrastar para reordenarReorder.Group + Reorder.Item
Descartar no deslocamento de arrastardrag="y" + verificação de offset em onDragEnd
Deslizar para esquerda/direitadrag="x" + verificação de offset em onDragEnd
Toque longoHook useLongPress
Valor suavizado ao longo do tempouseSpring
Valor derivado de outrouseTransform
Sequência multi-etapasuseAnimate com async/await
Animação imperativa únicaanimate() do motion
Texto entrando palavra por palavraStagger em spans inline-block
Desenho SVG ativadopathLength 0 → 1
Transformação SVGInterpolação do atributo d (comandos iguais)
Progresso circularInterpolação de strokeDashoffset

Quando usar useSpring vs transição spring

useSpringtransition: springs.*
Use paraSeguidor de cursor, valores rastreados por ponteiroMudanças de estado discretas
AtualizaçõesContínuas, a cada quadroAcionadas por mudança de estado
InterrupçãoSuave — a física pega a partir da velocidadeReinicia a partir do valor atual

Conceitos Principais

useMotionValue + useTransform

Computação reativa sem re-renderizações:

const x = useMotionValue(0)
const opacity = useTransform(x, [-200, 0, 200], [0, 1, 0])
// opacity é atualizado a cada frame conforme x muda — sem setState, sem re-renderização

useAnimate

Retorna [scope, animate]. A ref de escopo deve ser anexada a um elemento DOM. Chamadas animate() são à prova de interrupção — chamar durante a execução cancela a execução anterior.

const [scope, animate] = useAnimate()

async function play() {
  await animate(".step-1", { opacity: 1 }, { duration: 0.3 })
  await animate(".step-2", { x: 0 },       { duration: 0.4 })
        animate(".step-3", { scale: 1 },    { duration: 0.25 })  // dispara e esquece
}

return <div ref={scope}>...</div>

Exemplos de Código

Cartão arrastável

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

<motion.div
  drag
  dragConstraints={{ left: -100, right: 100, top: -100, bottom: 100 }}
  dragElastic={0.1}
  whileDrag={{
    scale: motionTokens.scale.pop,
    boxShadow: "0 16px 40px rgba(0,0,0,0.2)",
  }}
  dragTransition={springs.release}
/>

Folha de arrastar para descartar

"use client"
import { motion, useMotionValue, useTransform } from "motion/react"

export function BottomSheet({ onClose }: { onClose: () => void }) {
  const y = useMotionValue(0)
  const opacity = useTransform(y, [0, 200], [1, 0])

  return (
    <motion.div
      drag="y"
      dragConstraints={{ top: 0 }}
      style={{ y, opacity }}
      onDragEnd={(_, info) => {
        // Regra 3: combinar offset + velocity
        if (info.offset.y > 120 || info.velocity.y > 500) onClose()
      }}
    />
  )
}

Lista reordenável

"use client"
import { Reorder } from "motion/react"

export function SortableList() {
  const [items, setItems] = useState(initialItems)
  return (
    <Reorder.Group axis="y" values={items} onReorder={setItems}>
      {items.map((item) => (
        <Reorder.Item key={item.id} value={item}>
          {item.label}
        </Reorder.Item>
      ))}
    </Reorder.Group>
  )
}

Detecção de deslize

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

const OFFSET_THRESHOLD  = 50
const VELOCITY_THRESHOLD = 300

<motion.div
  drag="x"
  dragConstraints={{ left: 0, right: 0 }}
  onDragEnd={(_, info) => {
    const swipedRight = info.offset.x > OFFSET_THRESHOLD  || info.velocity.x > VELOCITY_THRESHOLD
    const swipedLeft  = info.offset.x < -OFFSET_THRESHOLD || info.velocity.x < -VELOCITY_THRESHOLD
    if (swipedRight) onSwipeRight()
    if (swipedLeft)  onSwipeLeft()
  }}
/>

Hook de toque longo

import { useRef } from "react"

export function useLongPress(callback: () => void, ms = 600) {
  const timerRef = useRef<ReturnType<typeof setTimeout>>()
  return {
    onPointerDown:  () => { timerRef.current = setTimeout(callback, ms) },
    onPointerUp:    () => clearTimeout(timerRef.current),
    onPointerLeave: () => clearTimeout(timerRef.current),
  }
}

Revelação palavra por palavra

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

export function AnimatedText({ text }: { text: string }) {
  return (
    <motion.p
      variants={{ visible: { transition: { staggerChildren: 0.05 } } }}
      initial="hidden"
      animate="visible"
    >
      {text.split(" ").map((word, i) => (
        <motion.span
          key={i}
          className="inline-block mr-1"
          variants={{
            hidden:  { opacity: 0, y: 12 },
            visible: { opacity: 1, y: 0, transition: springs.gentle },
          }}
        >
          {word}
        </motion.span>
      ))}
    </motion.p>
  )
}

Contador de números

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

export function Counter({ to }: { to: number }) {
  const nodeRef = useRef<HTMLSpanElement>(null)

  useEffect(() => {
    const controls = animate(0, to, {
      duration: motionTokens.duration.crawl,
      ease: motionTokens.easing.smooth,
      onUpdate: (v) => {
        if (nodeRef.current) nodeRef.current.textContent = Math.round(v).toString()
      },
    })
    return controls.stop   // Regra 7: limpeza
  }, [to])

  return <span ref={nodeRef} />
}

Desenho de caminho SVG

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

<motion.path
  d="M 0 100 Q 50 0 100 100"
  initial={{ pathLength: 0, opacity: 0 }}
  animate={{ pathLength: 1, opacity: 1 }}
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Anel de progresso de traço

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

const CIRCUMFERENCE = 2 * Math.PI * 40   // r=40

export function ProgressRing({ progress }: { progress: number }) {
  return (
    <svg width="100" height="100" viewBox="0 0 100 100">
      <circle cx="50" cy="50" r="40" fill="none" stroke="#e5e7eb" strokeWidth="8" />
      <motion.circle
        cx="50" cy="50" r="40"
        fill="none" stroke="#6366f1" strokeWidth="8"
        strokeLinecap="round"
        strokeDasharray={CIRCUMFERENCE}
        animate={{ strokeDashoffset: CIRCUMFERENCE - (progress / 100) * CIRCUMFERENCE }}
        transition={{ duration: motionTokens.duration.normal, ease: motionTokens.easing.smooth }}
        style={{ rotate: -90, transformOrigin: "center" }}
      />
    </svg>
  )
}

Hook useScrollReveal

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

export function useScrollReveal() {
  const ref = useRef(null)
  const { scrollYProgress } = useScroll({ target: ref, offset: ["start end", "end start"] })
  const opacity = useTransform(scrollYProgress, [0, 0.3], [0, 1])
  const y       = useTransform(scrollYProgress, [0, 0.3], [motionTokens.distance.lg, 0])
  return { ref, style: { opacity, y } }
}

// Uso
const { ref, style } = useScrollReveal()
<motion.section ref={ref} style={style} />

Seguidor de cursor

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

export function CursorFollower() {
  const x = useMotionValue(-100)
  const y = useMotionValue(-100)
  const sx = useSpring(x, springs.gentle)
  const sy = useSpring(y, springs.gentle)

  useEffect(() => {
    const move = (e: MouseEvent) => { x.set(e.clientX); y.set(e.clientY) }
    window.addEventListener("mousemove", move)
    return () => window.removeEventListener("mousemove", move)   // Regra 7
  }, [])

  return (
    <motion.div
      className="fixed top-0 left-0 w-6 h-6 rounded-full bg-indigo-500
                 pointer-events-none -translate-x-1/2 -translate-y-1/2 z-50"
      style={{ x: sx, y: sy }}
    />
  )
}

Shimmer skeleton

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

export function ShimmerSkeleton({ className = "" }: { className?: string }) {
  const controls = useAnimation()

  useEffect(() => {
    const play = () =>
      controls.start({
        x: ["-100%", "100%"],
        transition: {
          repeat: Infinity,
          duration: motionTokens.duration.crawl,
          ease: motionTokens.easing.linear,
        },
      })

    const handleVisibility = () => {
      if (document.visibilityState === "hidden") controls.stop()
      else void play()
    }

    void play()
    document.addEventListener("visibilitychange", handleVisibility)
    return () => {
      controls.stop()
      document.removeEventListener("visibilitychange", handleVisibility)
    }
  }, [controls])

  return (
    <div className={`relative overflow-hidden bg-gray-200 rounded ${className}`}>
      <motion.div
        className="absolute inset-0 bg-gradient-to-r from-transparent via-white/60 to-transparent"
        initial={{ x: "-100%" }}
        animate={controls}
      />
    </div>
  )
}

Estado de carregamento do botão

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

export function LoadingButton({
  loading,
  label,
  onClick,
}: {
  loading: boolean
  label: string
  onClick: () => void
}) {
  return (
    <motion.button
      onClick={onClick}
      animate={{ opacity: loading ? 0.7 : 1 }}
      whileTap={loading ? {} : { scale: motionTokens.scale.press }}
      transition={springs.snappy}
      disabled={loading}
    >
      <AnimatePresence mode="wait">
        {loading ? (
          <motion.span
            key="loading"
            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            …
          </motion.span>
        ) : (
          <motion.span
            key="label"
            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            {label}
          </motion.span>
        )}
      </AnimatePresence>
    </motion.button>
  )
}

Animação infinita com pausa de visibilidade

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

export function PulseDot() {
  const controls = useAnimation()

  useEffect(() => {
    const pulse = () =>
      controls.start({
        scale: [1, 1.4, 1],
        opacity: [1, 0.6, 1],
        transition: { repeat: Infinity, duration: motionTokens.duration.crawl },
      })

    // Regra 2: pausar quando a aba estiver oculta
    const handleVisibility = () => {
      if (document.visibilityState === "hidden") controls.stop()
      else void pulse()
    }

    void pulse()
    document.addEventListener("visibilitychange", handleVisibility)
    return () => {
      controls.stop()
      document.removeEventListener("visibilitychange", handleVisibility)
    }
  }, [controls])

  return (
    <motion.span className="inline-block w-3 h-3 rounded-full bg-indigo-500" animate={controls} />
  )
}

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

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

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