plotagents 0.0.0-stage → 0.7.0

package/src/charts/pyramid.js

@@ -0,0 +1,177 @@
+// Pirámide de población: barras horizontales espalda con espalda desde un eje
+// central, con los tramos de edad en la columna del medio (sin ejes repetidos).
+// Opcional: comparación con otro periodo como contorno escalonado.
+import { el, g, text, tip, barPath } from '../svg.js';
+import { measure } from '../text.js';
+import { makeFormat, formatNumber } from '../format.js';
+import { niceStep, linear } from '../scale.js';
+import { colorMap, readable } from '../theme.js';
+import { ensureData, requireField, num, uniq, fieldsOf, fieldKind, PlotError } from '../data.js';
+import { createFrame } from '../frame.js';
+
+const T = (en, es, locale) => (String(locale || 'es').startsWith('en') ? en : es);
+const lead = (s) => { const m = /^\s*(\d+)/.exec(String(s)); return m ? +m[1] : NaN; };
+
+export function pyramid(spec, theme) {
+  const locale = spec.locale || 'es';
+  const data = ensureData(spec);
+  const fields = fieldsOf(data);
+  const cats = fields.filter((f) => fieldKind(data, f) !== 'number' || /edad|age|grupo|tramo/i.test(f));
+  const nums = fields.filter((f) => fieldKind(data, f) === 'number');
+  const ageF = spec.age ?? spec.y ?? cats.find((f) => /edad|age|tramo|grupo/i.test(f)) ?? cats[0];
+  const sideF = spec.sex ?? spec.series ?? spec.hue ?? (typeof spec.color === 'string' && !spec.color.startsWith('#') ? spec.color : null) ?? cats.find((f) => f !== ageF && /sexo|sex|gender|género|genero/i.test(f)) ?? cats.find((f) => f !== ageF);
+  const valF = spec.value ?? spec.x ?? nums.find((f) => f !== ageF && f !== sideF);
+  requireField(data, ageF, 'age');
+  requireField(data, sideF, 'series');
+  requireField(data, valF, 'value');
+
+  // Comparación: otra tabla (compareData) o un valor de un campo (compare + compareField).
+  // Con `time` el núcleo ya filtró los datos y entrega el periodo de comparación en _prev.
+  let rows = data, cmpRows = spec.compareData ? ensureData({ data: spec.compareData }) : spec._prev && spec.compare !== undefined && spec.compare !== false ? spec._prev.data : null;
+  const cmpField = spec.compareField ?? spec.time;
+  if (!cmpRows && spec.compare !== undefined && cmpField && fields.includes(cmpField)) {
+    cmpRows = data.filter((r) => String(r[cmpField]) === String(spec.compare));
+    rows = data.filter((r) => String(r[cmpField]) !== String(spec.compare));
+    const periods = uniq(rows.map((r) => String(r[cmpField])));
+    if (periods.length > 1) { const last = spec.current ?? periods.sort().at(-1); rows = rows.filter((r) => String(r[cmpField]) === String(last)); }
+  }
+
+  const sides = spec.sides ?? uniq(rows.map((r) => String(r[sideF])));
+  if (sides.length !== 2) throw new PlotError(T(`A population pyramid needs exactly 2 groups in "${sideF}" (found ${sides.length}).`, `La pirámide necesita exactamente 2 grupos en "${sideF}" (hay ${sides.length}).`, locale), T('Filter the data to two groups, e.g. men and women.', 'Filtra los datos a dos grupos, por ejemplo hombres y mujeres.', locale));
+  let ages = uniq([...rows, ...(cmpRows || [])].map((r) => String(r[ageF])));
+  if (ages.every((a) => Number.isFinite(lead(a)))) ages.sort((a, b) => lead(a) - lead(b));
+  if (spec.ageOrder) ages = spec.ageOrder.map(String);
+  const top = [...ages].reverse(); // los mayores arriba
+
+  const sumBy = (rs) => {
+    const m = new Map();
+    for (const r of rs) {
+      const k = String(r[ageF]) + '\u0000' + String(r[sideF]);
+      const v = num(r[valF]);
+      if (Number.isFinite(v)) m.set(k, (m.get(k) || 0) + Math.abs(v));
+    }
+    return m;
+  };
+  const cur = sumBy(rows), cmp = cmpRows ? sumBy(cmpRows) : null;
+  const total = [...cur.values()].reduce((a, b) => a + b, 0) || 1;
+  const cmpTotal = cmp ? [...cmp.values()].reduce((a, b) => a + b, 0) || 1 : 1;
+  const pct = spec.percent === true || spec.format === 'percent' || spec.format?.type === 'percent';
+  const val = (m, a, s, tot) => { const v = m.get(a + '\u0000' + s) || 0; return pct ? v / tot : v; };
+  const V = (a, s) => val(cur, a, s, total);
+  const C = (a, s) => (cmp ? val(cmp, a, s, cmpTotal) : NaN);
+
+  const allV = ages.flatMap((a) => sides.flatMap((s) => [V(a, s), C(a, s)])).filter(Number.isFinite);
+  const vmax = Math.max(...allV, 1e-9);
+  const fmt = pct ? makeFormat({ type: 'percent', scale: 100, decimals: spec.format?.decimals }, locale) : makeFormat(spec.format, locale, allV);
+  const share = (v) => formatNumber((v / total) * 100, (v / total) * 100 < 10 ? 1 : 0, locale, true) + '%';
+
+  const cmap = colorMap(sides, theme, spec.colors);
+  const colorOf = (s) => cmap.get(s);
+  const cmpLabel = spec.compareLabel ?? spec._prev?.label ?? (spec.compare !== undefined ? String(spec.compare) : T('Comparison', 'Comparación', locale));
+  const legend = cmp && spec.legend !== false ? [{ label: cmpLabel, color: theme.ink, shape: 'line' }] : [];
+
+  const frame = createFrame(spec, theme, { height: 420 });
+  let area = frame.layout(legend);
+  const n = ages.length;
+  const headerH = 24, axisH = 24;
+  const step = spec.barHeight ? spec.barHeight + 2 : Math.max(14, Math.min(26, frame.width < 480 ? 17 : 21));
+  if (spec.height === undefined) {
+    frame.setHeight(area.y + headerH + n * step + axisH + frame.chrome);
+    area = { ...area, h: frame.bottom - area.y };
+  }
+  const ageSize = theme.type?.axis ?? 11.5;
+  const centerW = Math.max(...ages.map((a) => measure(a, ageSize, 500))) + 18;
+  const labelsOn = spec.labels === true;
+  const sample = fmt(vmax);
+  const endPad = labelsOn ? measure(sample, 11, 600) + 8 : 4;
+  const halfW = (area.w - centerW) / 2;
+  const cx0 = area.x + halfW, cx1 = cx0 + centerW; // bordes de la columna central
+  const plotTop = area.y + headerH;
+  const plotH = area.h - headerH - axisH;
+  const st = plotH / n;
+  const bh = Math.max(4, Math.min(spec.barHeight ?? 24, st - 2));
+  // Escala ajustada al dato (sin aire vacío), marcas "bonitas" dentro de ella.
+  const nd = { step: niceStep(vmax, Math.max(2, Math.round((halfW - endPad) / 85))) };
+  const dmax = spec.xDomain ? spec.xDomain[1] : vmax * 1.02;
+  const len = linear(0, dmax, 0, halfW - endPad);
+  const yOf = (i) => plotTop + i * st + (st - bh) / 2;
+
+  const body = [];
+  // Grilla vertical simétrica y marcas absolutas abajo.
+  const tf = fmt.tick(nd.step);
+  const tsize = theme.type?.axis ?? 11.5;
+  const ticks = len.ticks(nd.step).filter((t) => t <= dmax + 1e-9 && len(t) + measure(tf(t), tsize) / 2 <= halfW + 2);
+  const gridParts = [];
+  for (const t of ticks) {
+    for (const [x, anchor] of [[cx0 - len(t), 'middle'], [cx1 + len(t), 'middle']]) {
+      const px = Math.round(x) + 0.5;
+      gridParts.push(el('line', { x1: px, x2: px, y1: plotTop - 4, y2: plotTop + plotH, stroke: t === 0 ? theme.axis : theme.grid, strokeWidth: 1, shapeRendering: 'crispEdges' }));
+      if (t === 0 && anchor) continue;
+      gridParts.push(text(px, plotTop + plotH + 16, tf(t), { fill: theme.muted, fontSize: theme.type?.axis ?? 11.5, textAnchor: anchor }));
+    }
+  }
+  body.push(g({ class: 'pa-grid' }, gridParts));
+
+  // Encabezados: nombre de cada lado en su color (legible) y su participación.
+  const sideTot = (s) => ages.reduce((a, ag) => a + (cur.get(ag + '\u0000' + s) || 0), 0);
+  sides.forEach((s, k) => {
+    const lab = s;
+    const sh = share(sideTot(s)) ;
+    const hx = k === 0 ? cx0 - 2 : cx1 + 2;
+    const anchor = k === 0 ? 'end' : 'start';
+    const tw = measure(lab, 13, 600);
+    body.push(text(hx, area.y + 14, lab, { fill: readable(colorOf(s), theme), fontSize: 13, fontWeight: 600, textAnchor: anchor }));
+    body.push(text(k === 0 ? hx - tw - 6 : hx + tw + 6, area.y + 14, sh, { fill: theme.muted, fontSize: 12, textAnchor: anchor }));
+  });
+
+  // Barras
+  top.forEach((a, i) => {
+    const y = yOf(i);
+    // Etiqueta de edad en la columna central.
+    body.push(text((cx0 + cx1) / 2, y + bh / 2 + ageSize * 0.36, a, { fill: theme.lede, fontSize: ageSize, fontWeight: 500, textAnchor: 'middle' }));
+    sides.forEach((s, k) => {
+      const v = V(a, s);
+      const w = len(Math.min(v, dmax));
+      const c = colorOf(s);
+      const x = k === 0 ? cx0 - w : cx1;
+      const d = barPath(x, y, w, bh, k === 0 ? 'left' : 'right', Math.min(3.5, bh / 2));
+      const cv = C(a, s);
+      const lines = [`${a} · ${s}`, fmt(v) + (pct ? '' : ` · ${share(v)}`)];
+      if (Number.isFinite(cv)) lines.push(`${cmpLabel}: ${fmt(cv)}`);
+      const parts = [el('rect', { x: k === 0 ? area.x : cx1, y: plotTop + i * st, width: halfW, height: st, fill: 'transparent' })];
+      if (d) parts.push(el('path', { d, fill: c }));
+      if (labelsOn && v > 0) {
+        const lab = fmt(v);
+        parts.push(text(k === 0 ? x - 5 : x + w + 5, y + bh / 2 + 4, lab, { fill: theme.lede, fontSize: 11, fontWeight: 500, textAnchor: k === 0 ? 'end' : 'start' }));
+      }
+      body.push(g({ class: 'pa-m', 'data-tip': tip(...lines) }, parts));
+    });
+  });
+
+  // Comparación: contorno escalonado por lado.
+  if (cmp) {
+    sides.forEach((s, k) => {
+      let d = '';
+      top.forEach((a, i) => {
+        const cv = C(a, s);
+        if (!Number.isFinite(cv)) return;
+        const x = k === 0 ? cx0 - len(Math.min(cv, dmax)) : cx1 + len(Math.min(cv, dmax));
+        const y0 = plotTop + i * st, y1 = y0 + st;
+        d += (d ? `L${x.toFixed(1)},${y0.toFixed(1)}` : `M${(k === 0 ? cx0 : cx1).toFixed(1)},${y0.toFixed(1)}L${x.toFixed(1)},${y0.toFixed(1)}`) + `L${x.toFixed(1)},${y1.toFixed(1)}`;
+      });
+      if (d) {
+        d += `L${(k === 0 ? cx0 : cx1).toFixed(1)},${(plotTop + n * st).toFixed(1)}`;
+        body.push(el('path', { d, fill: 'none', stroke: theme.ink, strokeWidth: 1.5, strokeLinejoin: 'round', opacity: 0.85, class: 'pa-compare' }));
+      }
+    });
+  }
+
+  // Descripción
+  const en = String(locale).startsWith('en');
+  let big = null;
+  for (const a of ages) for (const s of sides) { const v = cur.get(a + '\u0000' + s) || 0; if (!big || v > big[2]) big = [a, s, v]; }
+  const desc = (en ? 'Population pyramid. ' : 'Pirámide de población. ')
+    + sides.map((s) => `${s} ${share(sideTot(s))}`).join(', ') + '. '
+    + (big ? (en ? `Largest group: ${big[0]} (${big[1]}), ${fmt(pct ? big[2] / total : big[2])}.` : `Grupo más numeroso: ${big[0]} (${big[1]}), ${fmt(pct ? big[2] / total : big[2])}.`) : '');
+  return frame.finish(body, { desc, type: 'pyramid' });
+}

package/src/charts/radar.js

@@ -0,0 +1,158 @@
+// Radar (araña): perfil de una o más series en varios ejes comparables.
+// Formato largo { eje, valor, serie } o ancho (una fila por serie + `axes`).
+import { el, g, text, tip } from '../svg.js';
+import { measure, wrap } from '../text.js';
+import { makeFormat } from '../format.js';
+import { niceDomain, niceStep, linear } from '../scale.js';
+import { colorMap } from '../theme.js';
+import { ensureData, requireField, uniq, num, fieldsOf, fieldKind, humanize, aggregate, PlotError } from '../data.js';
+import { createFrame } from '../frame.js';
+
+export function radar(spec, theme) {
+  const data = ensureData(spec);
+  const fields = fieldsOf(data);
+  const kinds = Object.fromEntries(fields.map((f) => [f, fieldKind(data, f)]));
+  const locale = spec.locale || 'es';
+  const en = String(locale).startsWith('en');
+  let series = spec.hue ?? spec.series ?? (typeof spec.color === 'string' && !spec.color.startsWith('#') ? spec.color : undefined);
+  let axes, seriesKeys;
+  const values = new Map(); // serie → Map(eje → valor)
+
+  if (Array.isArray(spec.axes) && spec.axes.length) {
+    // Formato ancho: cada fila es una serie; las columnas `axes` son los ejes.
+    axes = spec.axes.map(String);
+    axes.forEach((a) => requireField(data, a, 'axes'));
+    const labelF = spec.label ?? series ?? fields.find((f) => kinds[f] === 'category' && !axes.includes(f));
+    if (labelF) requireField(data, labelF, 'label');
+    seriesKeys = data.map((r, i) => (labelF ? String(r[labelF]) : `${en ? 'Series' : 'Serie'} ${i + 1}`));
+    data.forEach((r, i) => values.set(seriesKeys[i], new Map(axes.map((a) => [a, num(r[a])]))));
+    series = labelF;
+  } else {
+    const axisF = spec.axis ?? spec.x ?? fields.find((f) => kinds[f] === 'category' && f !== series);
+    const valueF = spec.value ?? spec.y ?? fields.find((f) => kinds[f] === 'number' && f !== series);
+    requireField(data, axisF, 'axis (x)');
+    requireField(data, valueF, 'value (y)');
+    if (series) requireField(data, series, 'series');
+    axes = uniq(data.map((r) => String(r[axisF])));
+    seriesKeys = series ? uniq(data.map((r) => String(r[series]))) : [humanize(valueF)];
+    const acc = new Map();
+    for (const r of data) {
+      const s = series ? String(r[series]) : seriesKeys[0];
+      const k = s + '\u0000' + String(r[axisF]);
+      if (!acc.has(k)) acc.set(k, []);
+      acc.get(k).push(num(r[valueF]));
+    }
+    for (const s of seriesKeys) values.set(s, new Map(axes.map((a) => [a, aggregate(acc.get(s + '\u0000' + a) || [], spec.aggregate || 'mean')])));
+  }
+  const n = axes.length;
+  const raw = [...values.values()].flatMap((m) => [...m.values()]).filter(Number.isFinite);
+  if (!raw.length) {
+    const vf = Array.isArray(spec.axes) && spec.axes.length ? axes.join('`, `') : (spec.value ?? spec.y ?? 'value');
+    throw en
+      ? new PlotError(`No numeric values in \`${vf}\`.`, 'A radar needs a number per axis and series (empty, null and non-finite values are skipped).')
+      : new PlotError(`No hay valores numéricos en \`${vf}\`.`, 'El radar necesita un número por eje y serie (se omiten vacíos, nulos y valores no finitos).');
+  }
+  const fmt = makeFormat(spec.format, locale, raw);
+
+  // Normalización por eje (cada eje a 0–1 según su máximo).
+  const axisMax = new Map(axes.map((a) => [a, Math.max(...seriesKeys.map((s) => values.get(s).get(a)).filter(Number.isFinite), 0)]));
+  const norm = !!spec.normalize;
+  const val = (s, a) => { const v = values.get(s).get(a); return norm ? v / (axisMax.get(a) || 1) : v; };
+  const vals = seriesKeys.flatMap((s) => axes.map((a) => val(s, a))).filter(Number.isFinite);
+  let dom;
+  if (spec.domain || spec.valueDomain || spec.yDomain) { const d = spec.domain || spec.valueDomain || spec.yDomain; dom = { min: d[0], max: d[1], step: niceStep(d[1] - d[0], 5) }; }
+  else if (norm) dom = { min: 0, max: 1, step: 0.25 };
+  else dom = niceDomain(Math.min(0, ...vals), Math.max(...vals), 4);
+  const rings = linear(dom.min, dom.max, 0, 1).ticks(dom.step).filter((t) => t > dom.min + 1e-9 && t <= dom.max + 1e-9);
+  if (!rings.length || Math.abs(rings[rings.length - 1] - dom.max) > 1e-9) rings.push(dom.max);
+  const ringFmt = norm ? (v) => Math.round(v * 100) + '%' : fmt.tick(dom.step);
+
+  // Colores y foco
+  const cmap = colorMap(seriesKeys, theme, spec.colors);
+  const hl = spec.highlight === undefined ? null : new Set([].concat(spec.highlight).map(String));
+  const focus = (s) => !hl || hl.has(s);
+  const colorOf = (s) => (focus(s) ? (seriesKeys.length === 1 ? cmap.get(s) || theme.categorical[0] : cmap.get(s)) : theme.dim);
+  const legend = seriesKeys.length > 1 ? seriesKeys.map((s) => ({ label: s, color: colorOf(s), shape: 'square' })) : [];
+
+  const frame = createFrame(spec, theme, { height: (spec.width || 720) < 560 ? Math.round((spec.width || 720) * 0.95 + 170) : 460 });
+  let area = frame.layout(spec.legend === false ? [] : legend);
+
+  // Etiquetas de eje: ancho máximo y alto (hasta 2 líneas).
+  const ls = (theme.type?.label ?? 12) + 0.5;
+  const maxLabelW = Math.min(130, Math.max(60, area.w * 0.2));
+  const labelLines = axes.map((a) => wrap(a, maxLabelW, ls, 500, 2));
+  const labW = Math.max(...labelLines.map((ls2) => Math.max(...ls2.map((l) => measure(l, ls, 500)))));
+  const labH = ls * 1.25 * Math.max(...labelLines.map((l) => l.length));
+  const gapL = 10;
+  let R = Math.min((area.w - 2 * (labW + gapL)) / 2, (area.h - 2 * (labH + gapL)) / 2);
+  if (spec.height === undefined) {
+    R = Math.max(60, Math.min((area.w - 2 * (labW + gapL)) / 2, spec.maxRadius ?? 210));
+    frame.setHeight(area.y + 2 * (R + labH + gapL) + 4 + frame.chrome);
+    area = { ...area, h: frame.bottom - area.y };
+  }
+  R = Math.max(40, R);
+  const cx = area.x + area.w / 2;
+  const cy = area.y + area.h / 2;
+  const ang = (i) => -Math.PI / 2 + (2 * Math.PI * i) / n;
+  const rOf = (v) => Math.max(0, ((v - dom.min) / (dom.max - dom.min || 1)) * R);
+  const pt = (i, r) => [cx + r * Math.cos(ang(i)), cy + r * Math.sin(ang(i))];
+  const shape = spec.grid === 'circle' ? 'circle' : 'polygon';
+  const ringPath = (r) => (shape === 'circle' ? null : 'M' + axes.map((_, i) => pt(i, r).map((v) => v.toFixed(2)).join(',')).join('L') + 'Z');
+
+  const body = [];
+  // Rejilla: anillos y radios, recesivos.
+  rings.forEach((t, k) => {
+    const r = rOf(t);
+    const outer = k === rings.length - 1;
+    const attrs = { fill: 'none', stroke: outer ? theme.axis : theme.grid, strokeWidth: 1 };
+    body.push(shape === 'circle' ? el('circle', { cx, cy, r, ...attrs }) : el('path', { d: ringPath(r), ...attrs, strokeLinejoin: 'round' }));
+  });
+  axes.forEach((_, i) => { const [x, y] = pt(i, R); body.push(el('line', { x1: cx, y1: cy, x2: x, y2: y, stroke: theme.grid, strokeWidth: 1 })); });
+
+  // Series: el foco se dibuja al final (encima).
+  const order = [...seriesKeys].sort((a, b) => (focus(a) ? 1 : 0) - (focus(b) ? 1 : 0));
+  const op = theme.marks?.bandOpacity ?? 0.16;
+  const lw = theme.marks?.lineWidth ?? 2;
+  for (const s of order) {
+    const c = colorOf(s);
+    const verts = axes.map((a, i) => { const v = val(s, a); return Number.isFinite(v) ? pt(i, rOf(v)) : [cx, cy]; });
+    const d = 'M' + verts.map(([x, y]) => `${x.toFixed(2)},${y.toFixed(2)}`).join('L') + 'Z';
+    const top = axes.map((a) => [a, values.get(s).get(a)]).filter(([, v]) => Number.isFinite(v)).sort((p, q) => (norm ? q[1] / (axisMax.get(q[0]) || 1) - p[1] / (axisMax.get(p[0]) || 1) : q[1] - p[1]));
+    const parts = [el('path', { d, fill: c, fillOpacity: focus(s) ? op : op * 0.5, stroke: c, strokeWidth: focus(s) ? lw : 1.25, strokeLinejoin: 'round' })];
+    if (focus(s)) verts.forEach(([x, y], i) => {
+      const v = values.get(s).get(axes[i]);
+      parts.push(el('circle', { cx: x, cy: y, r: (theme.marks?.pointRadius ?? 4) - 0.5, fill: c, stroke: theme.surface, strokeWidth: theme.marks?.ring ?? 2, 'data-tip': tip(s, `${axes[i]}: ${Number.isFinite(v) ? fmt(v) : '—'}`) }));
+    });
+    body.push(g({ class: 'pa-m', 'data-series': s, 'data-tip': tip(s, ...top.slice(0, 6).map(([a, v]) => `${a}: ${fmt(v)}`)) }, parts));
+  }
+
+  // Valores de los anillos sobre el primer radio (arriba), con halo.
+  rings.forEach((t) => {
+    const r = rOf(t);
+    body.push(text(cx + 4, cy - r - 3, ringFmt(t), { fill: theme.muted, fontSize: (theme.type?.axis ?? 11.5) - 1, stroke: theme.surface, strokeWidth: 3, paintOrder: 'stroke', strokeLinejoin: 'round' }));
+  });
+
+  // Etiquetas de eje fuera del círculo, ancladas según el ángulo.
+  axes.forEach((a, i) => {
+    const t = ang(i);
+    const cos = Math.cos(t), sin = Math.sin(t);
+    const [x, y] = pt(i, R + gapL);
+    const anchor = cos > 0.25 ? 'start' : cos < -0.25 ? 'end' : 'middle';
+    const lines = labelLines[i];
+    const lh = ls * 1.25;
+    const total = lines.length * lh;
+    const y0 = sin < -0.25 ? y - total + ls * 0.85 : sin > 0.25 ? y + ls * 0.85 : y - total / 2 + ls * 0.85;
+    lines.forEach((l, k) => body.push(text(x, y0 + k * lh, l, { fill: theme.ink, fontSize: ls, fontWeight: 500, textAnchor: anchor })));
+  });
+
+  // Descripción: fortaleza de cada serie.
+  const parts = seriesKeys.slice(0, 5).map((s) => {
+    const best = axes.map((a) => [a, val(s, a)]).filter(([, v]) => Number.isFinite(v)).sort((p, q) => q[1] - p[1]);
+    if (!best.length) return '';
+    const b = best[0], w = best[best.length - 1];
+    return en ? `${s}: strongest on ${b[0]}, weakest on ${w[0]}.` : `${s}: más alto en ${b[0]}, más bajo en ${w[0]}.`;
+  });
+  const warn = seriesKeys.length > 4 ? (en ? ' More than 4 series overlap; consider highlight.' : ' Más de 4 series se superponen; considera highlight.') : '';
+  const desc = (en ? `Radar chart with ${n} axes and ${seriesKeys.length} series${norm ? ' (each axis normalized to its maximum)' : ''}. ` : `Gráfico de radar con ${n} ejes y ${seriesKeys.length} series${norm ? ' (cada eje normalizado a su máximo)' : ''}. `) + parts.join(' ') + warn;
+  return frame.finish(body, { desc, type: 'radar' });
+}