Nivel 20 · Teoría

De tus fórmulas a graficas-base.js y graficas-ba.js

Idea: tus niveles (barras/, donut/, calor/…) y las librerías de los OG usan las mismas dos fórmulas: la recta map() y la circunferencia punto(). Las librerías no inventan matemáticas: reordenan las tuyas y añaden unas pocas ideas nuevas (la recta al revés, la curva suave, el ángulo «de reloj», el color por tramos…). Aquí se compara cada gráfica tuya con su versión de la librería y se explica cada diferencia con razonamiento, matemáticas y, cuando hay que despejar, con la balanza.
tus dos fórmulas en graficas-base.js (V) map(x, x0, x1, y0, y1) = y0 + (x−x0)·(y1−y0)/(x1−x0) → V.map, V.escala, V.bandas, V.marcas… punto(r, a) = [cx + r·cos a, cy + r·sin a] → V.punto, V.puntoReloj, V.arco
  1. V.map: la misma recta, con un seguro
  2. escala().invertir: la recta al revés
  3. Barras y líneas: n bandas o n − 1 tramos
  4. V.curva: por qué 1/6
  5. La línea que «se dibuja» y easeInOut
  6. Áreas: el borde de abajo al revés
  7. Agrupadas: el ancho de cada barra
  8. Apiladas: el acumulado y el modo 100 %
  9. Donut: el ángulo también es una recta
  10. puntoReloj y el gauge
  11. Calor: de opacidad a color por tramos
  12. Embudo, ranking y tonos: la recta en %
  13. V.raton: de la pantalla al viewBox
1 · TODAS LAS GRÁFICAS

V.map: tu recta, con un seguro para la división entre 0

tú (todos los niveles)
function map(x, x0, x1, y0, y1) {
    return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
}
graficas-base.js
function map(x, x0, x1, y0, y1) {
    if (x1 === x0) return y0;     // evita dividir entre 0
    return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
}

Razonamiento

En tus niveles los datos los escribes tú y nunca son todos 0. En los OG los datos vienen de GA4, y una tarjeta puede recibir todo ceros (sin tráfico ese mes) o un solo punto (una línea con un mes). Entonces max = 0 o n − 1 = 0, y la recta tiene los dos extremos iguales.

Matemáticas

Si x1 = x0, el denominador vale 0. En JavaScript, 0/0 = NaN y 5/0 = Infinity, y un atributo y="NaN" hace que el SVG no pinte la forma. Geométricamente, con dos puntos en la misma vertical no hay una recta que sea función de x: la pendiente no existe. El seguro devuelve y0, el principio del intervalo: con todo ceros, todas las barras se quedan en la base.
2 · LÍNEAS Y ÁREAS · NUEVO

escala().invertir: del píxel al dato

function escala([d0, d1], [p0, p1]) {
    const f = (dato) => map(dato, d0, d1, p0, p1);         // dato  → píxel  (lo de siempre)
    f.invertir = (pixel) => map(pixel, p0, p1, d0, d1);     // píxel → dato   (NUEVO)
    return f;
}
// en BAC.lines y BAC.area: ¿sobre qué mes está el ratón?
const i = V.limitar(Math.round(x.invertir(V.raton(svg, e).x)), 0, n - 1);

Razonamiento

Tus gráficas solo van en un sentido: del dato sale el píxel. En los OG, al pasar el ratón por una línea se muestra el tooltip del mes más cercano. Ahí el camino es el contrario: del píxel del ratón hay que sacar el mes. Es la función inversa.

Balanza · despejar x en la recta

Partimos de la recta y queremos dejar x sola (ahora conocemos y, el píxel):
y = y0 + (x − x0) · (y1 − y0) / (x1 − x0)
Pesada 1: resto y0 en los dos platos:
y − y0 = (x − x0) · (y1 − y0) / (x1 − x0)
Pesada 2: multiplico los dos platos por (x1 − x0) / (y1 − y0), el inverso de la fracción:
(y − y0) · (x1 − x0) / (y1 − y0) = x − x0
Pesada 3: sumo x0 en los dos platos:
x = x0 + (y − y0) · (x1 − x0) / (y1 − y0) ← ¡es map(y, y0, y1, x0, x1)!
La inversa es la misma map con los intervalos intercambiados. Por eso invertir es una línea.

Con números (BAC.lines, 12 meses, x de 62 a 498)

x(i) = map(i, 0, 11, 62, 498) = 62 + i · 39,64 ratón en 300 → invertir(300) = map(300, 62, 498, 0, 11) = (300 − 62) · 11 / 436 = 6,005 Math.round(6,005) = 6 → Jul limitar(…, 0, 11): por si el ratón sale por un lado
3 · BARRAS ↔ LÍNEAS

n bandas o n − 1 tramos: postes y vallas

tu nivel 1 (barras)
map(i, 0, n, x0, x1)          // 0 … 6 → 6 carriles
tu nivel 2 (línea) = V.escala en BAC.lines
map(i, 0, ultimo, x0, x1)     // 0 … 11 → 11 tramos
V.escala([0, n - 1], [m.l + 10, W - m.r - 10])

Razonamiento

Una barra ocupa un espacio (un carril). Una línea pasa por puntos, y el primero y el último deben quedar en los bordes. Es el problema de los postes y la valla: con 12 postes hay 11 tramos de valla. Barras → divides entre n; puntos → entre n − 1. La librería hace lo mismo que tú: V.bandas para las barras y V.escala([0, n−1]) para las líneas.

Matemáticas

barras: paso = (x1 − x0) / n el índice n (que no existe) cae en x1 puntos: paso = (x1 − x0) / (n − 1) el índice n − 1 (el último) cae en x1
Si en la línea usaras map(i, 0, n, …), el último punto quedaría a un paso del borde derecho; si en las barras usaras n − 1, la última barra se saldría.
4 · LÍNEAS Y ÁREAS

V.curva: la curva suave y el misterioso 1/6

// es tu curva() de barras/variantes-lineas.html, línea por línea
const c1 = [p1[0] + (p2[0] - p0[0]) / 6, p1[1] + (p2[1] - p0[1]) / 6];
const c2 = [p2[0] - (p3[0] - p1[0]) / 6, p2[1] - (p3[1] - p1[1]) / 6];
d += `C${c1} ${c2} ${p2}`;

Razonamiento

La polilínea (M … L … L) hace «picos» en cada dato. Una curva que pase por todos los puntos y no tenga picos necesita que, en cada punto, la dirección de llegada y la de salida sean la misma. La regla de Catmull-Rom dice qué dirección usar en p1: la de la cuerda entre sus vecinos, de p0 a p2.

Matemáticas · dos datos de partida

(a) Catmull-Rom: la tangente (velocidad) en p1 es la mitad de la cuerda entre vecinos: T1 = (p2 − p0) / 2.
(b) Bézier cúbica (C): sale de p1 con velocidad B′(0) = 3 · (c1 − p1) y llega a p2 con B′(1) = 3 · (p2 − c2).

Balanza · igualar velocidades y despejar c1

3 · (c1 − p1) = (p2 − p0) / 2 las dos velocidades en p1 son la misma
Pesada 1: divido los dos platos entre 3:
c1 − p1 = (p2 − p0) / 6
Pesada 2: sumo p1 en los dos platos:
c1 = p1 + (p2 − p0) / 6 ✓ (el 6 sale de 2 · 3)
Igual en la llegada: 3 · (p2 − c2) = (p3 − p1)/2 → ÷3 → p2 − c2 = (p3 − p1)/6 → paso c2 a un plato y lo demás al otro → c2 = p2 − (p3 − p1)/6. En los extremos falta un vecino y se usa el propio punto (puntos[i − 1] || puntos[i]).
5 · LÍNEAS · NUEVO

La línea que «se dibuja»: stroke-dashoffset y easeInOut

const largo = trazo.getTotalLength();          // cuánto mide la línea, en unidades del SVG
trazo.style.strokeDasharray = largo;           // una raya tan larga como la línea… y un hueco igual
V.animar(1.4, t => { trazo.style.strokeDashoffset = largo * (1 - t); }, { curva: easeInOut });

Razonamiento

Tus líneas aparecen de golpe. En BAC.lines, la línea se convierte en un discontinuo con una sola raya del largo exacto del trazo. Desplazando esa raya (dashoffset) desde «fuera» (largo) hasta su sitio (0), parece que un lápiz la va dibujando.

Matemáticas

visible = largo − offset = largo − largo·(1 − t) = largo · t (la parte dibujada crece en línea recta con t) easeInOut(t) = t² · (3 − 2t) velocidad = derivada = 6t(1 − t) → velocidad 0 al principio y al final, máxima (1,5) a la mitad
Frente a easeOut (barras), easeInOut también arranca suave: queda mejor en algo que «viaja» por la pantalla.
6 · ÁREAS

Tu área baja a la base; la de la librería tiene un borde de abajo

tu nivel 3
area = linea +
  'L ' + final[0] + ',' + y0 +
  'L ' + primero[0] + ',' + y0 + 'Z';
BAC.area
const alto = se.values.map((v, i) => bajo[i] + v);
const arriba = alto.map((v, i) => [x(i), y(v)]);
const abajo  = bajo.map((v, i) => [x(i), y(v)]).reverse();
d = V.curva(arriba) + 'L' + abajo.join('L') + 'Z';

Razonamiento

Tu área cierra bajando a la base (y0). En las áreas apiladas, la segunda capa no empieza en la base sino encima de la primera. Por eso la librería guarda dos bordes: bajo (donde empieza la capa) y alto = bajo + valor. Con bajo = 0 es exactamente tu área.
El borde de abajo se recorre al revés (reverse): se va por arriba de izquierda a derecha y se vuelve por abajo de derecha a izquierda. Si se recorrieran los dos en el mismo sentido, el contorno se cruzaría en forma de «Z».

Matemáticas · la animación con clipPath

ancho de la máscara = (W − m.l) · t (la recta de [0, 1] a [0, W − m.l])
Un rectángulo invisible que recorta el área crece de izquierda a derecha y va «destapando» el dibujo, que ya está completo debajo.
7 · AGRUPADAS

El ancho de cada barra del grupo, despejado

tu nivel 5
anchoBarra = (anchoGrupo - separacion * (series.length - 1))
             / series.length;
x = inicioGrupo + si * (anchoBarra + separacion);
BAC.grouped
const anchoBarra = (x.ancho - (k - 1) * HUECO) / k;
barras.push({ x: x.x(i) + si * (anchoBarra + HUECO) });

Razonamiento

Es la misma fórmula con otros nombres: tu anchoGrupo es x.ancho (de V.bandas), tu separacion = 4 es HUECO = 2, y tu inicioGrupo es x.x(i). La única diferencia es que las barras de la librería tienen las esquinas redondeadas y crecen en cascada.

Balanza · ¿cuánto mide cada barra?

En el ancho del grupo caben k barras y k − 1 huecos entre ellas:
k · anchoBarra + (k − 1) · HUECO = ancho
Pesada 1: resto (k − 1) · HUECO en los dos platos:
k · anchoBarra = ancho − (k − 1) · HUECO
Pesada 2: divido los dos platos entre k:
anchoBarra = (ancho − (k − 1) · HUECO) / k ✓ BAC: ancho = 135 · 0,7 = 94,5 → (94,5 − 1 · 2) / 2 = 46,25 tú, con 4 de separación: (94,5 − 1 · 4) / 2 = 45,25
8 · APILADAS

El acumulado, el modo 100 % y el crecimiento

tu nivel 6
var yAbajo  = map(acumulado, 0, max, y0, y1);
var yArriba = map(acumulado + v, 0, max, y0, y1);
acumulado += v;
BAC.stacked
const valor = (o.pct ? v / totales[i] : v) * crecer;
const yAbajo = y(acumulado), yArriba = y(acumulado + valor);
acumulado += valor;

Razonamiento

El corazón es idéntico: cada trozo empieza donde acabó el anterior. La librería añade tres cosas:
Modo 100 % (pct: true): cada valor se divide entre el total de su columna, y el máximo del eje pasa a ser 1. Todas las columnas miden lo mismo y se comparan las proporciones.
Crecer: cada valor se multiplica por escalon(t, i, n). Como todos los trozos de la columna se multiplican por el mismo número, la columna crece entera sin cambiar sus proporciones.
Detalles: 2 px de hueco entre trozos y solo el trozo de arriba con esquinas redondeadas (radio 4; los demás, 0).

Matemáticas · por qué multiplicar todos por t no deforma

t·a + t·b + t·c = t · (a + b + c) (propiedad distributiva)
El total de la columna es el total multiplicado por t, y cada trozo sigue siendo la misma fracción del total: t·a / (t·total) = a / total, porque las t se anulan.
9 · DONUT

El ángulo de cada trozo también es una recta

tu 07-donut
var angulo = d.valor / total * 2 * Math.PI;
var a0 = inicio, a1 = inicio + angulo;
inicio = a1;                  // empezaba en −π/2
BAC.donut + V.arco
const a0 = V.map(acumulado, 0, total, 0, VUELTA);
acumulado += it.value;
const a1 = V.map(acumulado, 0, total, 0, VUELTA);
V.arco(c, c, R0, R1, a0, a1);  // ángulos «de reloj»

Razonamiento

Tú calculas el tamaño del trozo y lo vas sumando al inicio. La librería calcula directamente dónde empieza y dónde acaba cada trozo, convirtiendo el acumulado de valores en un ángulo con la recta: valor 0 → 0 rad, total → 2π. Se llega al mismo sitio.

Balanza · la recta con origen en 0 es una regla de tres

map(a, 0, total, 0, 2π) = 0 + (a − 0) · (2π − 0) / (total − 0) = a · 2π / total = a / total · 2π
Es tu fórmula, valor / total · 2π, aplicada al acumulado. Y el tamaño del trozo sale restando los dos platos:
a1 − a0 = (acum + v)/total · 2π − acum/total · 2π = v / total · 2π ← tu "angulo"

Matemáticas · la bandera arcoGrande y el hueco

En el comando A de SVG, entre dos puntos de una circunferencia hay dos arcos posibles: el corto y el largo. arcoGrande = 1 si el trozo pasa de media vuelta (π); tú y la librería lo calculáis igual. La librería resta además HUECO = 0,025 rad (≈ 1,4°) al final de cada trozo, en vez de usar un borde blanco como haces tú.
Ocupación 46 → 0,46 · 2π = 2,890 rad (165,6°) < π → arcoGrande 0 acumulados: 0 → 0 · 46 → 2,890 · 78 → 4,901 · 100 → 6,283 (= 2π)
10 · DONUT Y GAUGE

puntoReloj: el ángulo que empieza a las 12

tu donut-medidor
function punto(r, a) {
    return [cx + r * Math.cos(a), cy + r * Math.sin(a)];
}
function angulo(p) { return Math.PI + p / 100 * Math.PI; }
graficas-base.js · BAC.gauge
function puntoReloj(cx, cy, r, a) {
    return punto(cx, cy, r, a - Math.PI / 2);
}
const angulo = (v) => V.map(v, 0, 1, -Math.PI / 2, Math.PI / 2);

Razonamiento

En matemáticas el ángulo 0 está a las 3 (a la derecha). Los donuts y gauges se piensan como un reloj: empiezan a las 12. Tú lo arreglas en cada gráfica (inicio = −π/2 en el donut, π + … en el medidor). La librería lo arregla una vez dentro de puntoReloj, que resta π/2, y así todas las gráficas piensan en «hora de reloj».
Ojo: como en pantalla la y crece hacia abajo, al aumentar el ángulo el punto gira en el sentido del reloj, no al revés como en el papel.

Balanza · tu gauge y el de la librería dan los mismos ángulos

Tu ángulo (matemático) para p % es π + p/100 · π. El de la librería (reloj) es map(v, 0, 1, −π/2, π/2) = −π/2 + v · π, y puntoReloj le resta π/2:
librería en matemático = (−π/2 + v·π) − π/2 = −π + v·π tuyo = π + v·π
La diferencia entre los dos platos es π − (−π) = 2π: una vuelta entera, que en un círculo no cambia nada (cos y sin se repiten cada 2π). Son el mismo punto: v = 0 a las 9, v = 0,5 a las 12, v = 1 a las 3.

Matemáticas · la marca del objetivo

Tu medidor y BAC.gauge la dibujan igual: dos puntos con el mismo ángulo y distinto radio (uno por dentro y otro por fuera del anillo). Al compartir ángulo, la rayita queda en la dirección del centro (radial).
11 · MAPA DE CALOR

De la opacidad a un color por tramos

tu 09-calor
'fill-opacity': map(valor, 0, max, 0.08, 1)
BAC.heat · seqColor
const k = (v) => V.map(v, min, max, 0, 1);
k < .5
  ? `color-mix(in srgb, var(--b-500) ${k * 200}%, var(--b-50))`
  : `color-mix(in srgb, var(--b-800) ${(k - .5) * 200}%, var(--b-500))`

Razonamiento

Con opacidad, un solo azul se mezcla con el fondo: si el fondo cambia (tema oscuro), cambian los colores, y los valores bajos casi no se distinguen entre sí. La librería primero lleva el valor a k entre 0 y 1 (tu misma recta) y luego recorre una escala de tres colores: casi blanco → azul medio → azul oscuro. Son dos rectas, una para cada mitad.
Además, el número de cada celda cambia a blanco cuando k > 0,42, porque el fondo ya es lo bastante oscuro.

Balanza · ¿de dónde sale el × 200?

En la primera mitad quiero llevar k de [0; 0,5] a un porcentaje de [0; 100]:
map(k, 0, 0,5, 0, 100) = 0 + (k − 0) · (100 − 0) / (0,5 − 0) = k · 100 / 0,5 = k · 200
En la segunda, de [0,5; 1] a [0; 100]:
map(k, 0,5, 1, 0, 100) = (k − 0,5) · 100 / 0,5 = (k − 0,5) · 200
Son las dos rectas del código. En k = 0,5 las dos dan el mismo color (azul 500 puro): los tramos empalman sin salto.
tu opacidad (de 0,08 a 1):
seqColor (dos tramos):
12 · EMBUDO, RANKING, TABLA Y TONOS

Cuando la gráfica es HTML, la recta da porcentajes

rellenos.push({ ancho: p.value / max * 100 });             // funnel: % del primer paso
filas.push({ ancho: it.value / max * 100 });               // rank: % del mayor
const k = Math.round(V.map(i, 0, n - 1, 0, gama.length - 1));   // tone: posición → color de la gama

Razonamiento

El embudo, el ranking y la tabla no son SVG: son <div> con width: N%. No hacen falta píxeles, porque el porcentaje ya se adapta al ancho del contenedor. La recta lleva el valor de [0, máximo] a [0, 100]. tone() usa la recta para escoger un color de una lista: de la posición i (0 … n − 1) a un índice de la gama (0 … 4), redondeado porque un índice no puede tener decimales.

Balanza · el porcentaje y la caída del embudo

map(v, 0, max, 0, 100) = v · 100 / max (otra recta con origen en 0 = regla de tres) caída = (anterior − v) / anterior = 1 − v / anterior (se separa la fracción, como en el nivel 19)
El «peor paso» es simplemente el de mayor caída: se recorren los pasos y se guarda el máximo.
13 · TOOLTIP · NUEVO

V.raton: el viewBox también es una recta

function raton(svg, evento) {
    const p = svg.createSVGPoint();
    p.x = evento.clientX; p.y = evento.clientY;
    return p.matrixTransform(svg.getScreenCTM().inverse());   // pantalla → unidades del viewBox
}

Razonamiento

Tu SVG mide 600 unidades, pero en pantalla puede ocupar 320 px (móvil) o 900 px. El ratón da píxeles de pantalla (clientX), y la escala x.invertir espera unidades del viewBox. getScreenCTM() es la conversión que el navegador aplica al dibujar (unidades → pantalla); su inverse() hace el camino de vuelta.

Balanza · la conversión es otra recta

Sin giros, el navegador dibuja así (a = escala, e = dónde empieza el SVG en la pantalla):
pantalla = a · unidad + e (por ejemplo, a = 900/600 = 1,5 y e = 120)
Pesada 1: resto e en los dos platos → pantalla − e = a · unidad
Pesada 2: divido entre a → unidad = (pantalla − e) / a
clientX = 570 → (570 − 120) / 1,5 = 300 unidades → x.invertir(300) = mes 6
Eso es lo que hace .inverse() con la matriz: el mismo despeje para la x y para la y a la vez.

Resumen: qué es tuyo, qué es nuevo

en las libreríasviene de tu…lo nuevo
V.map, V.escalamap() de todos los nivelesseguro x1 = x0 · .invertir (recta al revés)
V.bandas · BAC.barsnivel 1 (hueco, ancho)— (ver nivel 19)
V.linea, V.curva · BAC.linesnivel 2 · variantes-lineasdibujo con dashoffset · easeInOut · tooltip por mes
BAC.areanivel 3borde de abajo (apilado) · clipPath
BAC.groupednivel 5esquinas · cascada
BAC.stackednivel 6modo 100 % · crecer × t
V.punto, V.arco · BAC.donut07-donut · punto()ángulos con map · puntoReloj · hueco en radianes
BAC.gaugedonut-medidorángulo de reloj (mismo resultado)
BAC.heat, seqColor09-calorcolor en dos tramos en vez de opacidad
BAC.funnel, rank, table, tonela rectaen % de HTML en vez de píxeles
V.raton—pantalla → viewBox (matriz inversa)