React · React Native · 16 componentes

Interacciones difíciles, ya terminadas.

Animated Chorus es un conjunto de componentes de animación para las interacciones que cuesta hacer bien a mano: números que ruedan, texto en streaming, cambios que redimensionan, hojas, paginadores, acciones al deslizar y listas que animan solo lo que cambió. Una etiqueta y tus datos. Sin provider ni configuración.

Empezar Ver componentes

Instalar

npm install @kkwaenggwari/animated-chorus

Medido en esta build

Chrome, 2026-09-28. Todas las condiciones y muestras están en la guía de rendimiento. Cómo se midió

28.0KBKB gzip para los 16 exports
Toda la entrada web, minificada. React es la única dependencia peer.
0Callbacks de fotograma de JS mientras anima
Un número, una altura y un resaltado cambiando a la vez: el navegador reproduce las 12 animaciones.
1Commit de React por cambio de valor
MotionNumber se renderiza cuando cambia el valor, nunca mientras rueda.
11Commits de React para 3000 caracteres en streaming
MotionStream añade caracteres directamente y los incorpora a React unas pocas veces por segundo.

01Lo más fácil

Una etiqueta y tus datos

Cada componente funciona por sí solo: sin provider, componente envolvente ni llamada de configuración. Las colecciones reciben items y renderItem, y tu layout, tu texto y tus estilos siguen siendo tuyos.

Importa un componente y pásale un valor. Esa es toda la integración.
Las listas, pestañas y paginadores leen tu array; las keys usan item.id por defecto.
El texto sigue siendo texto real: se ajusta, escala con la fuente y se puede seleccionar.

```
<MotionNumber value={total} />;
```

<MotionSwap value={status}>{label}</MotionSwap>;

<MotionHeight open={open}>{details}</MotionHeight>;

<MotionHighlight items={tabs} value={tab} onValueChange={setTab} />;

<MotionList items={tasks} renderItem={(task) => task.title} />;

```
<ProgressRing value={progress} />;
```

Seis componentes en vivo y la línea de código que hay detrás de cada uno.

Preparando el ejemplo…

JavaScript está desactivado. El código de abajo es el ejemplo completo.

App.jsx

import { useState } from 'react';
import {
  MotionHighlight,
  MotionNumber,
  MotionSwap,
  motionTokens,
} from '@kkwaenggwari/animated-chorus';
import './styles.css';

const plans = [
  { id: 'starter', label: 'Starter', price: 0, points: ['1 project', 'Community support'] },
  {
    id: 'team',
    label: 'Team',
    price: 24,
    points: ['10 projects', 'Shared workspaces', 'Priority support'],
  },
  {
    id: 'scale',
    label: 'Scale',
    price: 196,
    points: ['Unlimited projects', 'Single sign-on', 'Audit log', 'Dedicated support'],
  },
];

export default function App({ hover = true, effect = 'up', spring = 'default' }) {
  const [plan, setPlan] = useState('team');
  const current = plans.find((item) => item.id === plan);
  // "default" is not a preset: undefined keeps the component's own motion.
  const transition = motionTokens.spring[spring];

  return (
    <div className="card">
      <MotionHighlight
        items={plans}
        value={plan}
        onValueChange={setPlan}
        hover={hover}
        transition={transition}
        className="tabs"
        itemClassName="tab"
        highlightClassName="tab-highlight"
        renderItem={(item, { selected }) => (
          <span className={selected ? 'tab-label on' : 'tab-label'}>{item.label}</span>
        )}
      />
      <p className="price">
        <MotionNumber value={current.price} prefix="$" transition={transition} />
        <span className="per">per month</span>
      </p>
      <MotionSwap as="div" inline={false} value={plan} effect={effect} transition={transition}>
        <ul className="points">
          {current.points.map((point) => (
            <li key={point}>{point}</li>
          ))}
        </ul>
      </MotionSwap>
    </div>
  );
}

styles.css

.card {
  display: grid;
  gap: 18px;
  max-width: 420px;
  margin: 24px auto;
  padding: 22px;
  border: 1px solid #cfe8dc;
  border-radius: 18px;
  background: #fff;
}

.tabs {
  display: flex;
  gap: 2px;
  padding: 4px;
  border-radius: 999px;
  background: #eaf6f0;
}

.tab {
  flex: 1;
  min-height: 40px;
  border: 0;
  border-radius: 999px;
  background: none;
  font:
    650 15px system-ui,
    sans-serif;
  color: #0e2e24;
  cursor: pointer;
}

.tab-highlight {
  border-radius: 999px;
  background: #fff;
  box-shadow: 0 0 0 1px #cfe8dc;
}

.tab-label {
  color: #5b616b;
  transition: color 0.2s;
}

.tab-label.on {
  color: #176b52;
}

.price {
  display: flex;
  align-items: baseline;
  gap: 8px;
  margin: 0;
  font:
    800 44px/1 system-ui,
    sans-serif;
  font-variant-numeric: tabular-nums;
  color: #0e2e24;
}

.price .per {
  font-size: 15px;
  font-weight: 500;
  color: #5b616b;
}

.points {
  display: grid;
  gap: 10px;
  margin: 0;
  padding: 0;
  list-style: none;
}

.points li {
  padding: 12px 14px;
  border-radius: 12px;
  background: #f4faf7;
  color: #16181d;
}

02Lo más rápido

Lo reproduce el navegador. React se queda quieto.

En la web no hay librería de animación que cargar: los componentes ceden su movimiento a la Web Animations API, así que un número que rueda o un panel que cambia de tamaño no cuestan JavaScript por fotograma ni renders de React mientras se mueven.

0 callbacks de fotograma de JS mientras se ejecutan 12 animaciones a la vez.
Un commit de React por cambio de valor, no uno por fotograma.
Texto en streaming: 11 commits de React para 3000 caracteres. El ejemplo de abajo cuenta sus propios renders.

Preparando el ejemplo…

JavaScript está desactivado. El código de abajo es el ejemplo completo.

App.jsx

import { useEffect, useRef, useState } from 'react';
import { MotionStream } from '@kkwaenggwari/animated-chorus';
import './styles.css';

const answer =
  'Motion helps people follow change. When a total updates, a rolling number shows which way it moved. ' +
  'When a panel opens, the height that follows its content keeps the reader in place. ' +
  'When an answer arrives in bursts, a steady reveal turns the bursts into reading: nothing waits for the ' +
  'next packet, and nothing is dumped at once. The pace speeds up only when a backlog builds, so the text ' +
  'never falls far behind what the server has already sent.';

// Network-like bursts: long pauses, then a lot of text at once.
const pauses = [300, 1100, 250, 1500, 400, 900];

export default function App({ speed = 90, catchUp = 900, chunk = 160, effect = 'fade' }) {
  const [received, setReceived] = useState(0);
  const [chunks, setChunks] = useState(0);
  const renders = useRef(0);
  renders.current += 1;

  useEffect(() => {
    if (received >= answer.length) return;
    const timer = setTimeout(
      () => {
        setReceived((current) => Math.min(answer.length, current + chunk));
        setChunks((count) => count + 1);
      },
      pauses[chunks % pauses.length],
    );
    return () => clearTimeout(timer);
  }, [received, chunks, chunk]);

  const askAgain = () => {
    setReceived(0);
    setChunks(0);
  };

  return (
    <div className="chat">
      <p className="question">Why does motion help an interface?</p>
      <p className="answer">
        <MotionStream
          text={answer.slice(0, received)}
          speed={speed}
          catchUp={catchUp}
          effect={effect}
        />
      </p>
      <footer>
        <output>
          {chunks} chunks · App rendered {renders.current} times
        </output>
        <button onClick={askAgain}>Ask again</button>
      </footer>
    </div>
  );
}

styles.css

.chat {
  display: grid;
  gap: 16px;
  max-width: 620px;
  margin: 0 auto;
  padding: 24px 20px;
}

.question {
  justify-self: end;
  max-width: 80%;
  margin: 0;
  padding: 10px 16px;
  border-radius: 18px 18px 4px 18px;
  background: #176b52;
  color: #fff;
}

.answer {
  min-height: 180px;
  margin: 0;
  padding: 16px 18px;
  border: 1px solid #cfe8dc;
  border-radius: 18px 18px 18px 4px;
  background: #fff;
  color: #16181d;
  line-height: 1.65;
}

footer {
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  justify-content: space-between;
  gap: 10px;
}

output {
  font:
    600 13px ui-monospace,
    Consolas,
    monospace;
  color: #176b52;
}

footer button {
  min-height: 40px;
  padding: 0 16px;
  border: 1px solid #cfe8dc;
  border-radius: 999px;
  background: #fff;
  font:
    600 14px system-ui,
    sans-serif;
  cursor: pointer;
}

03Lo más estable

Interrumpe lo que sea. Nunca salta.

Cada valor nuevo empieza desde lo que se ve en pantalla y los resortes conservan su velocidad, así que los clics rápidos, las ráfagas de datos y los cambios de sentido parecen intencionados. Cuando termina el movimiento, no queda nada en marcha.

Los números nunca se parten: las cifras que se quedan se desplazan mientras ruedan.
200 valores nuevos con 5 ms de diferencia: después quedan 0 animaciones y el texto final exacto.
Seguro en React StrictMode. En una app de React Native en segundo plano, el movimiento se asienta en su estado final.

Preparando el ejemplo…

JavaScript está desactivado. El código de abajo es el ejemplo completo.

App.jsx

import { useEffect, useState } from 'react';
import { MotionNumber, motionTokens } from '@kkwaenggwari/animated-chorus';
import './styles.css';

const burst = [12, 37, 85, 140, 9, 260, 48, 530, 21, 1100, 75, 2300];

export default function App({ mode = 'roll', direction = 'auto', spring = 'default' }) {
  const [value, setValue] = useState(1280);
  const [changes, setChanges] = useState(0);
  const [bursting, setBursting] = useState(false);

  const change = (next) => {
    setValue(next);
    setChanges((count) => count + 1);
  };

  // Twelve rising values, 90 ms apart, like a live counter: each arrives mid-motion.
  useEffect(() => {
    if (!bursting) return;
    let step = 0;
    const timer = setInterval(() => {
      const delta = burst[step];
      setValue((current) => Math.max(0, current + delta));
      setChanges((count) => count + 1);
      step += 1;
      if (step === burst.length) {
        clearInterval(timer);
        setBursting(false);
      }
    }, 90);
    return () => clearInterval(timer);
  }, [bursting]);

  return (
    <div className="counter">
      <MotionNumber
        className="value"
        value={value}
        intl
        locale="en-US"
        mode={mode}
        direction={direction}
        transition={motionTokens.spring[spring]}
      />
      <p className="changes">{changes} changes, no jumps</p>
      <div className="buttons">
        <button onClick={() => change(Math.max(0, value - 100))}>−100</button>
        <button onClick={() => change(value + 1)}>+1</button>
        <button onClick={() => change(value + 250)}>+250</button>
        <button onClick={() => change(value * 10)}>×10</button>
        <button onClick={() => change(Math.round(value / 10))}>÷10</button>
        <button className="burst" onClick={() => setBursting(true)} disabled={bursting}>
          Burst ×12
        </button>
      </div>
    </div>
  );
}

styles.css

.counter {
  display: grid;
  justify-items: center;
  gap: 14px;
  padding: 36px 20px 28px;
}

.value {
  font:
    800 clamp(48px, 12vw, 88px)/1.05 system-ui,
    sans-serif;
  font-variant-numeric: tabular-nums;
  letter-spacing: -0.03em;
  color: #0e2e24;
}

.changes {
  margin: 0;
  color: #5b616b;
  font-size: 14px;
}

.buttons {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
  gap: 8px;
}

.buttons button {
  min-width: 64px;
  min-height: 44px;
  padding: 0 16px;
  border: 1px solid #cfe8dc;
  border-radius: 999px;
  background: #fff;
  font:
    650 15px system-ui,
    sans-serif;
  color: #0e2e24;
  cursor: pointer;
}

.buttons button:hover {
  border-color: #176b52;
}

.buttons .burst {
  border-color: #176b52;
  background: #176b52;
  color: #fff;
}

.buttons .burst:disabled {
  opacity: 0.5;
}

16 componentes, agrupados por lo que hacen

Números y texto, contenido que cambia de tamaño, selección, listas, gestos, superposiciones y progreso. Cada uno tiene un banco de pruebas en vivo con sus props al lado.

Todos los componentes

Combinados

Pantallas completas que combinan varios componentes, cada una con sus ajustes fuera del ejemplo.

Todos los ejemplos

El mismo import en la web y en React Native

Metro elige la implementación nativa y los bundlers web, la del DOM. Cada plataforma reproduce el movimiento como mejor sabe.

App.jsx

// Web and React Native: the same import.
import { MotionNumber, MotionList } from '@kkwaenggwari/animated-chorus';

export function Score({ points, players }) {
  return (
    <>
      <MotionNumber value={points} />
      <MotionList items={players} renderItem={(player) => player.name} />
    </>
  );
}

Parte	Web	React Native
Transforms y opacidad	Web Animations API, resortes muestreados analíticamente	`Animated` con el driver nativo
Ancho y alto	Web Animations API	`Animated` con el driver de JS, porque es layout
Texto en streaming	Caracteres añadidos con fundido; unos pocos renders de React por segundo	Un `Text` real, que aparece sin fundido
Hojas y zoom	Un `dialog` nativo en la capa superior	Un `Modal` transparente; el botón de retroceso lo cierra

Empieza en dos minutos

Instala, importa un componente y pásale un valor.

npm install @kkwaenggwari/animated-chorus

Interacciones difíciles, ya terminadas.

Medido en esta build

Una etiqueta y tus datos

Lo reproduce el navegador. React se queda quieto.

Interrumpe lo que sea. Nunca salta.

16 componentes, agrupados por lo que hacen

Números y texto

Contenido y tamaño

Selección y paginación

Listas

Gestos

Superposiciones

Progreso

Combinados

El mismo import en la web y en React Native

Empieza en dos minutos

Buscar