Animation Designer
Propósito
Diseñar e implementar animaciones web intencionadas y de alto rendimiento que mejoren la experiencia del usuario sin sacrificar rendimiento ni accesibilidad. Este skill cubre herramientas de animación, patrones y el marco de decisión para elegir el enfoque correcto.
Selección de Herramientas de Animación
Matriz de Decisión
NECESIDAD DE ANIMACIÓN HERRAMIENTA RECOMENDADA
--------------------------------------------------------------
Efectos simples de hover/focus Transiciones CSS
Secuencias de keyframes (carga, etc.) CSS @keyframes
Animaciones de entrada/salida de componentes Framer Motion (React)
Vue <Transition> (Vue)
Revelaciones activadas por desplazamiento Animaciones CSS impulsadas por desplazamiento
(o Intersection Observer)
Secuencias temporales complejas GSAP
Animaciones de rutas SVG GSAP o CSS
Movimiento basado en física/resorte Framer Motion (spring)
Animaciones de diseño (posición/tamaño) Framer Motion (layoutId)
Animaciones basadas en gestos (arrastrar, pellizcar) Framer Motion (drag)
Transiciones de elementos compartidos View Transitions API
Animaciones de visualización de datos Transiciones D3 o GSAP
Micro-interacciones (iconos, interruptores) CSS o Lottie
Transiciones CSS
Fundamentos
/* Atajo de transición: propiedad duración función-de-temporización retraso */
.button {
background: var(--color-marca);
transition: background 200ms ease-out, transform 150ms ease-out;
}
.button:hover {
background: var(--color-marca-hover);
transform: scale(1.02);
}
/* Propiedades individuales */
.card {
transition-property: transform, box-shadow, opacity;
transition-duration: 200ms, 300ms, 200ms;
transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
}
/* Funciones de temporización nombradas */
--ease-in: cubic-bezier(0.4, 0, 1, 1); /* Acelerando */
--ease-out: cubic-bezier(0, 0, 0.2, 1); /* Desacelerando */
--ease-in-out: cubic-bezier(0.4, 0, 0.2, 1); /* Estándar */
--ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Sobreimpulso */
Patrones de Transición Comunes
/* Fundido de entrada/salida */
.fade-enter { opacity: 0; }
.fade-enter-active { opacity: 1; transition: opacity 300ms ease-out; }
.fade-exit { opacity: 1; }
.fade-exit-active { opacity: 0; transition: opacity 200ms ease-in; }
/* Deslizar hacia arriba desde abajo */
.slide-up {
transform: translateY(20px);
opacity: 0;
transition: transform 300ms ease-out, opacity 200ms ease-out;
}
.slide-up.active {
transform: translateY(0);
opacity: 1;
}
/* Brillo de carga de esqueleto */
@keyframes shimmer {
0% { background-position: -200% 0; }
100% { background-position: 200% 0; }
}
.skeleton {
background: linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%);
background-size: 200% 100%;
animation: shimmer 1.5s ease-in-out infinite;
}
CSS @keyframes
/* Spinner */
@keyframes spin {
to { transform: rotate(360deg); }
}
.spinner {
animation: spin 1s linear infinite;
border: 3px solid var(--color-borde);
border-top-color: var(--color-marca);
border-radius: 50%;
width: 24px; height: 24px;
}
/* Pulso (indicador de atención) */
@keyframes pulse {
0%, 100% { opacity: 1; }
50% { opacity: 0.5; }
}
.notification-dot {
animation: pulse 2s ease-in-out infinite;
background: red;
border-radius: 50%;
width: 10px; height: 10px;
display: inline-block;
}
/* Animaciones escalonadas */
@keyframes fadeInUp {
from {
opacity: 0;
transform: translateY(20px);
}
to {
opacity: 1;
transform: translateY(0);
}
}
.list-item {
animation: fadeInUp 300ms ease-out both;
}
.list-item:nth-child(1) { animation-delay: 0ms; }
.list-item:nth-child(2) { animation-delay: calc(1 * 50ms); }
.list-item:nth-child(3) { animation-delay: calc(2 * 50ms); }
/* O con atributo de estilo: style="--i: 3" */
.list-item {
animation-delay: calc(var(--i) * 50ms);
}
Animaciones CSS Impulsadas por Desplazamiento
/* Animar según la posición de desplazamiento */
@keyframes reveal {
from {
opacity: 0;
transform: translateY(40px) scale(0.95);
}
to {
opacity: 1;
transform: translateY(0) scale(1);
}
}
/* Activar cuando el elemento entra en el viewport */
.reveal-on-scroll {
animation: reveal linear both;
animation-timeline: view();
animation-range: entry 0% entry 50%;
}
/* Efecto parallax (ejemplo simplificado) */
@keyframes parallax {
from { transform: translateY(50px); }
to { transform: translateY(-50px); }
}
.parallax-element {
animation: parallax linear;
animation-timeline: scroll();
}
Framer Motion (React)
Patrones Básicos
import { motion, AnimatePresence } from 'framer-motion';
// Animación de entrada
function Card() {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.3, ease: 'easeOut' }}
>
<h2>Card Content</h2>
</motion.div>
);
}
// Animación de salida (requiere AnimatePresence)
function Modal({ isOpen, onClose }: ModalProps) {
return (
<AnimatePresence>
{isOpen && (
<motion.div
initial={{ opacity: 0, scale: 0.9 }}
animate={{ opacity: 1, scale: 1 }}
exit={{ opacity: 0, scale: 0.9 }}
transition={{ duration: 0.2 }}
>
<h2>Título del Modal</h2>
<p>Contenido del modal aquí.</p>
<button onClick={onClose}>Cerrar</button>
</motion.div>
)}
</AnimatePresence>
);
}
// Animaciones de lista escalonada
const listVariants = {
hidden: { opacity: 0 },
visible: {
opacity: 1,
transition: {
staggerChildren: 0.1,
},
},
};
const itemVariants = {
hidden: { opacity: 0, y: 20 },
visible: { opacity: 1, y: 0 },
};
function List({ items }: { items: Item[] }) {
return (
<motion.ul variants={listVariants} initial="hidden" animate="visible">
{items.map((item) => (
<motion.li key={item.id} variants={itemVariants}>
{item.name}
</motion.li>
))}
</motion.ul>
);
}
Física de Resortes
// Animación de resorte (movimiento natural basado en física)
<motion.div
animate={{ x: 100 }}
transition={{
type: 'spring',
stiffness: 300, // Más alto = más rápido
damping: 20, // Más alto = menos rebote
mass: 1, // Más alto = más inercia
}}
/>
// Ajustes predefinidos
const springPresets = {
snappy: { type: 'spring', stiffness: 400, damping: 25 },
bouncy: { type: 'spring', stiffness: 300, damping: 10 },
gentle: { type: 'spring', stiffness: 120, damping: 14 },
molasses: { type: 'spring', stiffness: 60, damping: 20 },
};
// Cuándo usar resorte vs. easing:
// Resorte: elementos interactivos, arrastrar, cambios de diseño (se siente natural)
// Easing: transiciones simples, entrada/salida (se siente predecible)
Animaciones de Diseño
// Animación de diseño automática
function ExpandableCard({ expanded }: { expanded: boolean }) {
return (
<motion.div layout className={expanded ? 'card-expanded' : 'card-collapsed'}>
<motion.h2 layout="position">Título</motion.h2>
{expanded && (
<motion.p
initial={{ opacity: 0 }}
animate={{ opacity: 1 }}
exit={{ opacity: 0 }}
>
Contenido expandido aquí.
</motion.p>
)}
</motion.div>
);
}
// Reordenamiento de lista con layoutId
import { LayoutGroup, motion } from 'framer-motion';
function ReorderGrid({ items }: { items: Item[] }) {
return (
<LayoutGroup>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '1rem' }}>
{items.map((item) => (
<motion.div key={item.id} layout>
{item.title}
</motion.div>
))}
</div>
</LayoutGroup>
);
}
Animaciones de Gestos
// Arrastrar
<motion.div
drag
dragConstraints={{ top: -100, bottom: 100, left: -100, right: 100 }}
dragElastic={0.2}
whileDrag={{ scale: 1.1, cursor: 'grabbing' }}
/>
// Hover y tap
<motion.button
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={springPresets.snappy}
>
Haz clic
</motion.button>
// Activado por desplazamiento (con useInView)
import { useInView } from 'framer-motion';
function FadeInOnScroll({ children }: { children: React.ReactNode }) {
const ref = useRef(null);
const isInView = useInView(ref, { once: true, margin: '-50px' });
return (
<motion.div
ref={ref}
initial={{ opacity: 0, y: 20 }}
animate={isInView ? { opacity: 1, y: 0 } : {}}
transition={{ duration: 0.6, ease: 'easeOut' }}
>
{children}
</motion.div>
);
}
GSAP (Secuencias Temporales Complejas)
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Secuencia de línea de tiempo
const tl = gsap.timeline({ defaults: { ease: 'power2.out', duration: 0.5 } });
tl.from('.hero-title', { y: 60, opacity: 0 })
.from('.hero-subtitle', { y: 40, opacity: 0 }, '-=0.3') // Superposición de 0.3s
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.2')
.from('.hero-image', { x: 100, opacity: 0 }, '-=0.4');
// Animación activada por desplazamiento
gsap.from('.feature-card', {
scrollTrigger: {
trigger: '.features-section',
start: 'top 80%',
end: 'bottom 20%',
toggleActions: 'play none none reverse',
},
opacity: 0,
y: 50,
stagger: 0.15,
duration: 0.6,
ease: 'power2.out',
});
// Animaciones encadenadas con retraso
gsap.to('.box', {
x: 200,
duration: 1,
ease: 'elastic.out(1, 0.3)',
delay: 0.5,
});
// Limpieza de GSAP en React
useEffect(() => {
const ctx = gsap.context(() => {
// Todas las animaciones de GSAP aquí
gsap.from('.item', { opacity: 0, y: 20, stagger: 0.1 });
}, containerRef);
return () => ctx.revert(); // Limpiar todas las animaciones
}, []);
Preferencias de Movimiento Reducido
Implementación
/* CSS: Respetar globalmente la preferencia del usuario */
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
// React: hook useReducedMotion
function useReducedMotion(): boolean {
const [reduced, setReduced] = useState(false);
useEffect(() => {
const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
setReduced(mq.matches);
const handler = (e: MediaQueryListEvent) => setReduced(e.matches);
mq.addEventListener('change', handler);
return () => mq.removeEventListener('change', handler);
}, []);
return reduced;
}
// Uso
function AnimatedCard() {
const reduced = useReducedMotion();
return (
<motion.div
initial={reduced ? {} : { opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={reduced ? { duration: 0 } : { duration: 0.3 }}
>
Contenido
</motion.div>
);
}
// Framer Motion integrado (v6+)
import { useReducedMotion } from 'framer-motion';
Presupuesto de Rendimiento para Animaciones
OBJETIVO: Las animaciones deben mantener 60 fps (16.67 ms por fotograma)
REGLAS:
1. Animar solo transform y opacity (propiedades solo del compositor)
2. Evitar animar width, height, top, left, margin, padding
3. Usar will-change con moderación (añade sobrecarga de memoria)
4. Limitar las animaciones simultáneas a ~10-15 elementos
5. Usar requestAnimationFrame para animaciones controladas por JS
6. Desbancar los controladores de scroll (o usar animaciones CSS impulsadas por desplazamiento)
7. Evitar animar elementos que provocan un reflujo en otros elementos
MEDICIÓN:
- Chrome DevTools > Rendimiento > Gráfico de fotogramas
- Objetivo: Ningún fotograma que supere los 16 ms
- Verificar la presencia de layout thrashing (indicadores de reflujo forzado)
TÉCNICAS DE OPTIMIZACIÓN:
- Usar transform: translateZ(0) o will-change para promover capas
- Usar contain: layout paint para contenedores animados
- Usar content-visibility: auto para contenido animado fuera de pantalla
- Pausar animaciones cuando no son visibles (Intersection Observer)
Principios de Diseño de Animaciones
1. PROPÓSITO: Cada animación debe cumplir una función
- Guiar la atención
- Mostrar relaciones (padre-hijo, antes-después)
- Proporcionar retroalimentación (clic, hover, éxito, error)
- Mantener la orientación espacial (de dónde vino el contenido)
- Reducir el tiempo de espera percibido
2. PAUTAS DE DURACIÓN:
Micro-interacciones (hover, interruptor): 100-200 ms
Animaciones de entrada: 200-400 ms
Animaciones de salida: 150-300 ms (más rápidas que la entrada)
Transiciones de página: 300-500 ms
Secuencias complejas: 500-1000 ms en total
3. EASING:
Entrada: ease-out (desacelerando -- aparece rápido, se asienta)
Salida: ease-in (acelerando -- comienza lento, sale rápido)
Movimiento: ease-in-out (movimiento natural)
Continuo: linear (spinners, progreso)
4. ESCALONADO:
30-80 ms entre elementos de la lista (más rápido para más elementos)
Duración máxima total del escalonado: ~500 ms (incluso para 20+ elementos)
Lista de Verificación de Arquitectura de Animaciones
- Herramienta de animación seleccionada según las necesidades de complejidad
- Transiciones CSS utilizadas para efectos simples de hover/focus
- CSS @keyframes utilizado para animaciones en bucle y de carga
- Framer Motion o equivalente utilizado para animaciones de entrada/salida/diseño
- GSAP reservado para secuencias temporales complejas
- Todas las animaciones mantienen 60 fps (verificado en DevTools)
- Solo se animan transform y opacity (sin propiedades de diseño)
- prefers-reduced-motion respetado globalmente
- Las duraciones de las animaciones siguen las pautas de UX (100-500 ms)
- El tiempo de escalonado está limitado a una duración total razonable
- Cada animación tiene un propósito claro (no decorativo)
- Física de resortes utilizada para animaciones interactivas/de gestos
- Las animaciones impulsadas por desplazamiento usan la API de CSS cuando es compatible
- Las animaciones de GSAP se limpian al desmontar el componente
- will-change usado solo durante la animación activa
Cuándo Usar
Usar este skill cuando:
- Se diseñan o implementan soluciones de animación web
- Se revisan o mejoran enfoques existentes de animación
- Se toman decisiones arquitectónicas o de implementación sobre animación web
- Se aprenden patrones y mejores prácticas de animación
- Se solucionan problemas relacionados con la animación web
NO usar este skill cuando:
- La pregunta trata sobre un dominio tecnológico fundamentalmente diferente
- Un skill hermano más específico cubre exactamente el tema necesario
- El usuario necesita un tutorial práctico completo en lugar de orientación experta
Formato de Salida
# Análisis de Animación Web
## Evaluación del Contexto
[Resumen de la situación y restricciones]
## Enfoque Recomendado
[Recomendación principal con fundamento]
## Pasos de Implementación
1. [Paso con detalles específicos]
2. [Paso con detalles específicos]
3. [Paso con detalles específicos]
## Compensaciones y Consideraciones
- [Compensación clave 1]
- [Compensación clave 2]
## Próximos Pasos
- [Acción inmediata]
- [Acción de seguimiento]
Ejemplo
Entrada: "Ayúdame a implementar animaciones web para una aplicación de producción de mediana escala"
Salida: Un análisis estructurado que cubre la evaluación del estado actual, el enfoque de animación web recomendado con patrones específicos, una hoja de ruta de implementación con hitos y estrategias de mitigación de riesgos adaptadas a la escala y las restricciones de la aplicación.
Casos Extremos
- Integración con sistemas heredados: Cuando la animación web debe coexistir con enfoques heredados, proporcionar una ruta de migración gradual en lugar de una reescritura completa
- Desajuste de escala: Cuando la complejidad de la solución supera la escala del proyecto, recomendar un enfoque más simple y señalar cuándo reconsiderarlo
- Falta de habilidades del equipo: Cuando el equipo carece de experiencia con el enfoque recomendado, incluir recursos de aprendizaje y alternativas más simples
- Requisitos conflictivos: Cuando las restricciones entran en conflicto (por ejemplo, rendimiento vs. mantenibilidad), exponer explícitamente la compensación y recomendar según las prioridades declaradas