plotagents 0.5.0 → 0.8.0

package/src/geo/registry.js

@@ -1,31 +1,110 @@
 // Registro de geometrías. El núcleo no trae mapas pesados: se registran al
 // importar 'plotagents/geo/chile', 'plotagents/geo/usa' o 'plotagents/geo/world', o se pasa un
 // GeoJSON propio en spec.geo.
+//
+// `geo` acepta, además de un nombre registrado:
+//   · un GeoJSON FeatureCollection, un Feature, un arreglo de Features o una geometría suelta
+//   · un TopoJSON (Topology); `geoObject` elige el objeto (por defecto, el primero)
+//   · en el navegador, una URL (render() la descarga; ver runtime.js)
 import { PlotError } from '../data.js';
 
 const REG = new Map();
 
-export function registerGeo(name, fc, aliases = []) {
-  if (!fc || fc.type !== 'FeatureCollection') throw new PlotError(`La geometría "${name}" debe ser un GeoJSON FeatureCollection.`);
+export function registerGeo(name, geo, aliases = []) {
+  const fc = toFeatureCollection(geo);
   for (const n of [name, ...aliases]) REG.set(String(n).toLowerCase(), fc);
   return fc;
 }
 
-export function getGeo(geo) {
-  if (geo && typeof geo === 'object') {
-    if (geo.type === 'FeatureCollection') return geo;
-    if (geo.type === 'Feature') return { type: 'FeatureCollection', features: [geo] };
-    throw new PlotError('`geo` debe ser un nombre registrado o un GeoJSON FeatureCollection.');
+/** ¿Parece una URL o una ruta a un archivo .json / .geojson / .topojson? */
+export const isGeoUrl = (s) => typeof s === 'string' && (/^(https?:)?\/\//i.test(s) || /^(\.{0,2}\/|data:)/.test(s) || /\.(geo|topo)?json(\?.*)?$/i.test(s));
+
+export function getGeo(geo, objectName) {
+  if (geo && typeof geo === 'object') return toFeatureCollection(geo, objectName);
+  if (isGeoUrl(geo)) {
+    throw new PlotError(
+      `"${geo}" es una URL o un archivo: plot() es sincrónico y no descarga nada.`,
+      "En Node, lee el archivo y pásalo como objeto: geo: JSON.parse(fs.readFileSync('mapa.geojson', 'utf8')). En el navegador, render(el, spec) sí acepta la URL."
+    );
   }
   const fc = REG.get(String(geo || '').toLowerCase());
   if (!fc) {
     const known = [...new Set(REG.keys())];
     throw new PlotError(
       `No hay una geometría registrada con el nombre "${geo}".`,
-      known.length ? `Disponibles: ${known.join(', ')}. O pasa un GeoJSON en \`geo\`.` : "Importa 'plotagents/geo/chile', 'plotagents/geo/usa' o 'plotagents/geo/world', o pasa un GeoJSON en `geo`."
+      known.length ? `Disponibles: ${known.join(', ')}. O pasa un GeoJSON o TopoJSON en \`geo\`.` : "Importa 'plotagents/geo/chile', 'plotagents/geo/usa' o 'plotagents/geo/world', o pasa un GeoJSON en `geo`."
     );
   }
   return fc;
 }
 
 export const registeredGeo = () => [...new Set(REG.keys())];
+
+const GEOMS = new Set(['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection']);
+const cache = new WeakMap();
+
+/** Cualquier forma de GeoJSON / TopoJSON → FeatureCollection. */
+export function toFeatureCollection(geo, objectName) {
+  if (!geo || typeof geo !== 'object') throw new PlotError('`geo` debe ser un nombre registrado, un GeoJSON o un TopoJSON.', 'geo: "chile" | "usa" | "world" | { type: "FeatureCollection", features: [...] }');
+  if (Array.isArray(geo)) return { type: 'FeatureCollection', features: geo.map(asFeature) };
+  if (geo.type === 'FeatureCollection') {
+    if (!Array.isArray(geo.features)) throw new PlotError('El FeatureCollection no tiene `features`.');
+    return geo.features.every((f) => f && f.type === 'Feature') ? geo : { ...geo, features: geo.features.map(asFeature) };
+  }
+  if (geo.type === 'Feature') return { type: 'FeatureCollection', features: [geo] };
+  if (GEOMS.has(geo.type)) return { type: 'FeatureCollection', features: [{ type: 'Feature', properties: {}, geometry: geo }] };
+  if (geo.type === 'Topology') {
+    const key = objectName ?? '';
+    const memo = cache.get(geo) || {};
+    if (!memo[key]) { memo[key] = topoFeatures(geo, objectName); cache.set(geo, memo); }
+    return memo[key];
+  }
+  throw new PlotError(`No reconozco este \`geo\` (type: "${geo.type}").`, 'Usa un GeoJSON (FeatureCollection, Feature o geometría) o un TopoJSON (type: "Topology").');
+}
+
+function asFeature(f) {
+  if (f && f.type === 'Feature') return f;
+  if (f && GEOMS.has(f.type)) return { type: 'Feature', properties: {}, geometry: f };
+  throw new PlotError('Cada elemento de `geo` debe ser un Feature de GeoJSON.');
+}
+
+// ── TopoJSON (decodificador mínimo, sin dependencias) ──────────────────────
+function topoFeatures(topo, objectName) {
+  const names = Object.keys(topo.objects || {});
+  if (!names.length) throw new PlotError('El TopoJSON no tiene objetos.');
+  const name = objectName ?? names[0];
+  const obj = topo.objects[name];
+  if (!obj) throw new PlotError(`El TopoJSON no tiene el objeto "${name}".`, `Objetos disponibles: ${names.join(', ')}. Indícalo con \`geoObject\`.`);
+  const tf = topo.transform;
+  // Arcos absolutos (deshace la cuantización y la codificación delta).
+  const arcs = (topo.arcs || []).map((arc) => {
+    if (!tf) return arc.map((p) => p.slice(0, 2));
+    let x = 0, y = 0;
+    return arc.map((p) => { x += p[0]; y += p[1]; return [x * tf.scale[0] + tf.translate[0], y * tf.scale[1] + tf.translate[1]]; });
+  });
+  const point = (p) => (tf ? [p[0] * tf.scale[0] + tf.translate[0], p[1] * tf.scale[1] + tf.translate[1]] : p.slice(0, 2));
+  const line = (ids) => {
+    const out = [];
+    for (const i of ids) {
+      const a = i < 0 ? arcs[~i].slice().reverse() : arcs[i];
+      if (!a) continue;
+      for (let k = out.length ? 1 : 0; k < a.length; k++) out.push(a[k]);
+    }
+    return out;
+  };
+  const ring = (ids) => { const r = line(ids); if (r.length && (r[0][0] !== r[r.length - 1][0] || r[0][1] !== r[r.length - 1][1])) r.push(r[0]); return r; };
+  const geom = (o) => {
+    switch (o.type) {
+      case 'Point': return { type: 'Point', coordinates: point(o.coordinates) };
+      case 'MultiPoint': return { type: 'MultiPoint', coordinates: o.coordinates.map(point) };
+      case 'LineString': return { type: 'LineString', coordinates: line(o.arcs) };
+      case 'MultiLineString': return { type: 'MultiLineString', coordinates: o.arcs.map(line) };
+      case 'Polygon': return { type: 'Polygon', coordinates: o.arcs.map(ring) };
+      case 'MultiPolygon': return { type: 'MultiPolygon', coordinates: o.arcs.map((p) => p.map(ring)) };
+      default: return null;
+    }
+  };
+  const feat = (o) => ({ type: 'Feature', id: o.id, properties: { ...(o.properties || {}), ...(o.id !== undefined && (o.properties || {}).id === undefined ? { id: o.id } : {}) }, geometry: geom(o) });
+  const list = obj.type === 'GeometryCollection' ? obj.geometries.map(feat) : [feat(obj)];
+  return { type: 'FeatureCollection', features: list.filter((f) => f.geometry) };
+}

package/src/hierarchy.js

@@ -66,6 +66,12 @@ export function findNode(root, focus = []) {
   return node;
 }
 
+/** Nodo de foco para dibujar: una hoja no se puede "abrir" (quedaría vacío), se usa su padre. */
+export function focusNode(root, focus = []) {
+  const n = findNode(root, focus);
+  return !n.children.length && n.parent ? n.parent : n;
+}
+
 export const height = (n) => (n.children.length ? 1 + Math.max(...n.children.map(height)) : 0);
 export const descendants = (n) => [n, ...n.children.flatMap(descendants)];
 

package/src/i18n.js

@@ -0,0 +1,107 @@
+// Idioma: reconocimiento a partir del texto del spec y las pocas palabras que
+// la biblioteca escribe por su cuenta (fuente, total, buscar…). Lo demás
+// (paginación, flechas, ✓) se dibuja con símbolos que no dependen del idioma.
+//
+//   detectLocale(['Ventas por región, 2025', 'Biobío'])  → 'es'
+//   detectLocale(['Sales grew 12% in the South'])          → 'en'
+//   locale: 'auto' en cualquier spec (y por defecto en `table`) lo usa.
+
+export const LANGS = ['es', 'en', 'pt', 'fr', 'de'];
+
+const WORDS = {
+  es: { source: 'Fuente: ', total: 'Total', search: 'Buscar', none: 'Sin resultados', clear: 'Borrar', page: 'Página', prev: 'Anterior', next: 'Siguiente', sort: 'Ordenar por', yes: 'Sí', no: 'No', rows: 'filas', table: 'Tabla', of: 'de' },
+  en: { source: 'Source: ', total: 'Total', search: 'Search', none: 'No results', clear: 'Clear', page: 'Page', prev: 'Previous', next: 'Next', sort: 'Sort by', yes: 'Yes', no: 'No', rows: 'rows', table: 'Table', of: 'of' },
+  pt: { source: 'Fonte: ', total: 'Total', search: 'Buscar', none: 'Sem resultados', clear: 'Limpar', page: 'Página', prev: 'Anterior', next: 'Próxima', sort: 'Ordenar por', yes: 'Sim', no: 'Não', rows: 'linhas', table: 'Tabela', of: 'de' },
+  fr: { source: 'Source : ', total: 'Total', search: 'Rechercher', none: 'Aucun résultat', clear: 'Effacer', page: 'Page', prev: 'Précédente', next: 'Suivante', sort: 'Trier par', yes: 'Oui', no: 'Non', rows: 'lignes', table: 'Tableau', of: 'sur' },
+  de: { source: 'Quelle: ', total: 'Gesamt', search: 'Suchen', none: 'Keine Treffer', clear: 'Löschen', page: 'Seite', prev: 'Zurück', next: 'Weiter', sort: 'Sortieren nach', yes: 'Ja', no: 'Nein', rows: 'Zeilen', table: 'Tabelle', of: 'von' },
+};
+
+/** Código de idioma soportado ('es', 'en', 'pt', 'fr', 'de') a partir de cualquier etiqueta ('pt-BR', 'en_US'…). */
+export function langOf(locale) {
+  const k = String(locale || 'es').toLowerCase().slice(0, 2);
+  return LANGS.includes(k) ? k : 'es';
+}
+
+/** Palabras de interfaz en el idioma del gráfico. */
+export const words = (locale) => WORDS[langOf(locale)];
+
+// Palabras funcionales frecuentes de cada idioma. Una palabra compartida
+// (de, la, que…) reparte su peso entre los idiomas que la usan.
+const STOP = {
+  es: 'de la el los las y en por con para del que una un se al más es son sus su según entre como año años sin hasta desde ventas región regiones total mil millones porcentaje hogares personas este esta sobre cada ha han fue lidera mayor menor tasa crecimiento meta comuna comunas mes meses semana proyecto estado avance',
+  en: 'the of and in by for with to is are from on at than more its as per was were this that which share sales region regions total thousand million percent households people over each has have had leads largest smallest rate growth target month months week project status progress revenue year years',
+  pt: 'de da do das dos e em por com para que uma um ao mais é são sua seu entre como ano anos não até desde pelo pela no na nos nas vendas região total mil milhões taxa crescimento meta mês meses projeto estado cada foi tem',
+  fr: 'de la le les et en par pour avec du des que une un au aux plus est sont sa son ses entre comme année années sans jusqu depuis sur dans ventes région total mille millions taux croissance objectif mois semaine projet état chaque été',
+  de: 'der die das und in von mit für zu ist sind den dem des ein eine einer im am mehr als nach bei auf aus nicht jahr jahre umsatz region gesamt tausend millionen anteil wachstum ziel monat monate woche projekt status jede wurde hat',
+};
+const INDEX = new Map();
+for (const [lang, list] of Object.entries(STOP)) for (const w of list.split(' ')) { if (!INDEX.has(w)) INDEX.set(w, []); INDEX.get(w).push(lang); }
+
+// Letras que delatan un idioma (se suman a las palabras).
+const CHARS = [
+  [/[ñ¿¡]/g, { es: 3 }],
+  [/[ãõ]/g, { pt: 3 }],
+  [/ç/g, { pt: 1.5, fr: 1.5 }],
+  [/[èêëàâùûœî]/g, { fr: 2 }],
+  [/[äöüß]/g, { de: 3 }],
+  [/[áíóú]/g, { es: 1, pt: 1 }],
+  [/é/g, { es: 0.5, pt: 0.5, fr: 0.8 }],
+];
+
+/**
+ * Idioma más probable de unos textos (títulos, encabezados, categorías), o
+ * null si no hay señal suficiente. Determinista y sin diccionarios grandes.
+ */
+export function detectLocale(texts) {
+  const s = [].concat(texts || []).filter((t) => typeof t === 'string' && t).join(' \n ').toLowerCase().slice(0, 6000);
+  if (!s) return null;
+  const score = { es: 0, en: 0, pt: 0, fr: 0, de: 0 };
+  for (const tok of s.split(/[^\p{L}]+/u)) {
+    const langs = tok && INDEX.get(tok);
+    if (langs) for (const l of langs) score[l] += 1 / langs.length;
+  }
+  for (const [re, w] of CHARS) {
+    const n = (s.match(re) || []).length;
+    if (n) for (const [l, v] of Object.entries(w)) score[l] += Math.min(6, n) * v;
+  }
+  const ranked = Object.entries(score).sort((a, b) => b[1] - a[1]);
+  const [[best, a], [, b]] = ranked;
+  if (a < 1 || a < b * 1.25 + 0.25) return null;
+  return best;
+}
+
+/** Idioma del documento en el navegador (`<html lang>` o el del sistema), o null. */
+export function browserLocale() {
+  // Solo en un navegador: Node 21+ también define `navigator`, y el SVG del servidor no debe depender de él.
+  if (typeof document === 'undefined') return null;
+  try {
+    const l = (document.documentElement && document.documentElement.lang) || (typeof navigator !== 'undefined' && navigator.language) || '';
+    const k = String(l).toLowerCase().slice(0, 2);
+    return LANGS.includes(k) ? k : null;
+  } catch { return null; }
+}
+
+/**
+ * Textos de un spec que delatan su idioma: título, bajada, fuente, nombres de
+ * columna y algunas categorías.
+ */
+export function specTexts(spec, data) {
+  const out = [spec.title, spec.subtitle, spec.source, spec.dashedLabel];
+  for (const c of [].concat(Array.isArray(spec.columns) ? spec.columns : [])) {
+    if (typeof c === 'string') out.push(c);
+    else if (c && typeof c === 'object') out.push(c.label, c.field);
+  }
+  if (Array.isArray(data)) {
+    const rows = data.slice(0, 40);
+    const keys = new Set();
+    for (const r of rows) if (r && typeof r === 'object') for (const [k, v] of Object.entries(r)) { keys.add(k); if (typeof v === 'string' && v.length > 2 && !/^[\d\s.,%$€£-]+$/.test(v)) out.push(v); }
+    // Nombres de campo con guiones bajos o camelCase: "ventas_region" → "ventas region".
+    for (const k of keys) out.push(String(k).replace(/[_-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2'));
+  }
+  return out;
+}
+
+/** Resuelve `locale: "auto"`: idioma del texto, luego el del navegador, luego español. */
+export function autoLocale(spec, data) {
+  return detectLocale(specTexts(spec, data)) || browserLocale() || 'es';
+}

package/src/index.js

@@ -3,7 +3,7 @@
 //   import { plot } from 'plotagents';
 //   const svg = plot({ data, x: 'region', y: 'ventas', title: 'Biobío lidera las ventas' });
 //
-import { getTheme, themeFor, themes, palettes, ramps, colorMap, fontSpec, FONT_CSS } from './theme.js';
+import { getTheme, themeFor, themes, palettes, ramps, colorMap, fontSpec, deepMerge, registerTheme, isColor, FONT_CSS } from './theme.js';
 import { withContext } from './context.js';
 import { validatePalette } from './palette.js';
 import { bar } from './charts/bar.js';
@@ -20,26 +20,34 @@ import { network } from './charts/network.js';
 import { chord } from './charts/chord.js';
 import { pyramid } from './charts/pyramid.js';
 import { flowchart } from './charts/flowchart.js';
+import { gantt } from './charts/gantt.js';
+import { wordcloud, countWords } from './charts/wordcloud.js';
 import { choropleth, symbolMap } from './charts/choropleth.js';
-import { registerGeo, getGeo, registeredGeo } from './geo/registry.js';
+import { pointmap, embedTiles, TILE_PROVIDERS } from './charts/pointmap.js';
+import { registerGeo, getGeo, registeredGeo, toFeatureCollection } from './geo/registry.js';
 // Mapas incluidos (Chile por regiones, estados de EE. UU. y países del mundo): listos sin importar nada más.
 // El bundle del navegador los separa en dist/plotagents-geo.js.
 import './geo/chile.js';
 import './geo/world.js';
 import './geo/usa.js';
 import { heatmap } from './charts/heatmap.js';
+import { corr, pairplot, correlations } from './charts/corr.js';
 import { sankey } from './charts/sankey.js';
 import { kpi } from './charts/kpi.js';
+import { table } from './charts/table.js';
+import { autoLocale, detectLocale } from './i18n.js';
 import { ensureData, PlotError, fieldKind, uniq, num } from './data.js';
 import { facet } from './facet.js';
 import { parseDate } from './format.js';
 import { inferType, TYPES, ALIASES, normalizeType } from './infer.js';
 import { lint, _setProbe } from './lint.js';
-import { schema, toolDefinition } from './schema.js';
+import { schema, toolDefinition, dashboardSchema } from './schema.js';
 import { attach, attachSource } from './interact.js';
-import { render, _bind } from './runtime.js';
+import { render, _bind, loadGeo } from './runtime.js';
+import { dashboard, renderDashboard, planDashboard, lintDashboard, safeDashboard, mountDashboard, packRows, balancedRows, _bindDashboard } from './dashboard.js';
 import { makeFormat, formatNumber, formatCompact } from './format.js';
 import { esc } from './svg.js';
+import { resolveColorScale, colorScaleNames, interpolate as interpolateColor, COLORMAPS, QUALITATIVE } from './colorscales.js';
 
 const RENDERERS = {
   bar: (s, t) => bar(s, t),
@@ -54,8 +62,11 @@ const RENDERERS = {
   donut: (s, t) => donut(s, t),
   pie: (s, t) => pie(s, t),
   heatmap: (s, t) => heatmap(s, t),
+  corr: (s, t) => corr(s, t),
+  pairplot: (s, t) => pairplot(s, t),
   sankey: (s, t) => sankey(s, t),
   kpi: (s, t) => kpi(s, t),
+  table: (s, t) => table(s, t),
   hist: (s, t) => hist(s, t),
   kde: (s, t) => kde(s, t),
   ecdf: (s, t) => ecdf(s, t),
@@ -72,8 +83,11 @@ const RENDERERS = {
   chord: (s, t) => chord(s, t),
   pyramid: (s, t) => pyramid(s, t),
   flowchart: (s, t) => flowchart(s, t),
+  gantt: (s, t) => gantt(s, t),
+  wordcloud: (s, t) => wordcloud(s, t),
   choropleth: (s, t) => choropleth(s, t),
   symbolmap: (s, t) => symbolMap(s, t),
+  pointmap: (s, t) => pointmap(s, t),
 };
 
 
@@ -82,19 +96,35 @@ const RENDERERS = {
 export function resolve(spec = {}) {
   if (!spec || typeof spec !== 'object') throw new PlotError('El spec debe ser un objeto.', 'plot({ data: [...], x: "campo", y: "campo" })');
   const s = withDefaults(spec);
+  // refLines / annotations: un objeto suelto vale como lista de uno.
+  for (const k of ['refLines', 'annotations']) if (s[k] != null && !Array.isArray(s[k]) && typeof s[k] === 'object') s[k] = [s[k]];
   if (s.color && !s.series && typeof s.color === 'string' && !s.color.startsWith('#')) s.series = s.color;
-  let type = s.type && s.type !== 'auto' ? String(s.type).toLowerCase() : null;
+  let type = s.type && s.type !== 'auto' ? String(s.type).trim().toLowerCase() : null;
   if (type) {
     const [t, extra] = normalizeType(type);
     type = t;
     for (const [k, v] of Object.entries(extra)) if (s[k] === undefined) s[k] = v;
   }
   if (!type) {
-    const data = s.items ? [] : ensureData(s);
+    const data = s.items || (!s.data && (typeof s.text === 'string' || Array.isArray(s.text))) ? [] : ensureData(s);
     type = inferType(s, data);
   }
   if (!RENDERERS[type]) throw new PlotError(`Tipo de gráfico "${s.type}" no soportado.`, `Usa uno de: ${TYPES.join(', ')} o "auto".`);
   s.type = type;
+  // Idioma: `locale: "auto"` (y las tablas sin `locale`) lo reconocen del texto del spec.
+  if (s.locale === 'auto' || (s.locale === undefined && type === 'table')) {
+    s.locale = autoLocale(s, Array.isArray(s.data) ? s.data : []);
+  }
+  // Colormap divergente (RdBu, coolwarm…): centrada en 0 si los datos lo cruzan; si no, en el medio.
+  const cs = resolveColorScale(s.colorScale ?? s.cmap ?? s.colormap);
+  if (cs && cs.kind === 'diverging' && s.midpoint === undefined && s.diverging === undefined) {
+    const vf = typeof s.colorScale === 'object' && s.colorScale.mid !== undefined ? null : s.value;
+    if (typeof s.colorScale === 'object' && s.colorScale?.mid !== undefined) s.midpoint = +s.colorScale.mid;
+    else if (vf && Array.isArray(s.data) && s.data.length && typeof s.data[0] === 'object') {
+      const vs = s.data.map((r) => num(r[vf])).filter(Number.isFinite);
+      if (vs.length) { let lo = Infinity, hi = -Infinity; for (const v of vs) { if (v < lo) lo = v; if (v > hi) hi = v; } s.midpoint = lo < 0 && hi > 0 ? 0 : (lo + hi) / 2; }
+    } else s.diverging = true;
+  }
   return s;
 }
 
@@ -105,6 +135,7 @@ export function resolve(spec = {}) {
 export function plot(spec) {
   let s = resolve(spec);
   s = applyTime(s);
+  s = applyExclude(s);
   const theme = themeFor(s);
   const textScale = Math.max(0.5, Math.min(4, +(s.textScale ?? s.fontScale ?? s.labelScale ?? 1) || 1));
   return withContext({ textScale }, () => {
@@ -131,7 +162,12 @@ export function configure(options) {
 
 function withDefaults(spec) {
   const s = { ...DEFAULTS, ...spec };
-  if (DEFAULTS.theme && typeof DEFAULTS.theme === 'object' && spec.theme && typeof spec.theme === 'object') s.theme = { ...DEFAULTS.theme, ...spec.theme };
+  // Colores fijados por entidad: solo colores CSS válidos (viajan a atributos y al tooltip).
+  if (s.colors && typeof s.colors === 'object') s.colors = Object.fromEntries(Object.entries(s.colors).filter(([, c]) => isColor(c)));
+  // Tema global + tema del spec: el del spec se fusiona en profundidad sobre el global.
+  if (DEFAULTS.theme && spec.theme && typeof spec.theme === 'object' && spec.theme.extends === undefined) {
+    s.theme = typeof DEFAULTS.theme === 'string' ? { ...spec.theme, extends: DEFAULTS.theme } : deepMerge(DEFAULTS.theme, spec.theme);
+  }
   // `font`: atajo de theme.font (familia + URL para cargarla).
   const f = fontSpec(s.font);
   if (f) {
@@ -173,6 +209,37 @@ function applyTime(s) {
   return { ...s, data, colors: stableColors(s, all), subtitle: s.subtitle ? `${s.subtitle} · ${label}` : label, _time: { field: s.time, value: cur, values: vals }, _prev };
 }
 
+/** Campo que define las entradas de la leyenda (series, primer nivel, grupo…). */
+function legendField(s) {
+  if (Array.isArray(s.path) && s.path.length) return s.path[0];
+  return s.series ?? s.hue ?? s.group ?? (['donut', 'pie'].includes(s.type) ? s.label ?? s.x : null) ?? (s.type === 'treemap' || s.type === 'sunburst' ? s.label ?? s.x : null);
+}
+
+/**
+ * `exclude: ["Maule"]` (o shift + clic en la leyenda): quita esas entradas y
+ * recalcula ejes, participaciones y layout con lo que queda. Los colores no
+ * se mueven y las entradas excluidas siguen en la leyenda, apagadas.
+ */
+function applyExclude(s) {
+  const ex = s.exclude == null || s.exclude === false ? [] : [].concat(s.exclude).map(String);
+  if (!ex.length) return s;
+  // Tabla ancha: y: ["ingresos", "costos"] → se excluyen columnas.
+  if (Array.isArray(s.y) && !s.series && !s.hue) {
+    const keep = s.y.filter((k) => !ex.includes(String(k)));
+    if (!keep.length || keep.length === s.y.length) return s;
+    const cmap = colorMap(s.y, themeFor(s), s.colors);
+    return { ...s, y: keep, colors: { ...Object.fromEntries(cmap), ...(s.colors || {}) }, _excluded: s.y.filter((k) => ex.includes(String(k))) };
+  }
+  const f = legendField(s);
+  if (!f || s.items) return s;
+  const all = ensureData(s);
+  if (!all.length || !(f in all[0])) return s;
+  const keep = all.filter((r) => !ex.includes(String(r[f])));
+  if (!keep.length || keep.length === all.length) return s;
+  const present = new Set(all.map((r) => String(r[f])));
+  return { ...s, data: keep, colors: { ...stableColors(s, all), ...(s.colors || {}) }, _excluded: ex.filter((v) => present.has(v)) };
+}
+
 /**
  * Colores fijos por entidad a lo largo de TODOS los periodos: al mover el
  * slider, "Minería" sigue siendo índigo aunque cambie su tamaño o su orden.
@@ -200,9 +267,10 @@ export function safePlot(spec) {
   const report = lint(spec || {});
   try {
     const svg = plot(spec);
-    return { ok: true, svg, type: report.type, description: describeSvg(svg), errors: [], warnings: report.warnings, suggestions: report.suggestions };
+    // Se dibujó (con valores de respaldo), pero los errores de lint igual se devuelven: ok = sin errores.
+    return { ok: report.errors.length === 0, svg, type: report.type, description: describeSvg(svg), errors: report.errors, warnings: report.warnings, suggestions: report.suggestions };
   } catch (e) {
-    const errors = report.errors.length ? report.errors : [{ code: 'render', message: e.message.split('\n')[0], fix: e.hint }];
+    const errors = report.errors.length ? report.errors : [{ code: 'render', message: e.message.split('\n')[0], fix: e.hint || 'Revisa los campos del spec contra el schema (`toolDefinition()`): textos donde van textos, listas donde van listas.' }];
     return { ok: false, svg: null, type: report.type, description: '', errors, warnings: report.warnings, suggestions: report.suggestions };
   }
 }
@@ -224,9 +292,11 @@ function describeSvg(svg) {
  */
 export function toHTML(specs, { title = 'Gráficos', lang = 'es', columns = 1 } = {}) {
   const list = Array.isArray(specs) ? specs : [specs];
-  const dark = list.every((s) => themeFor(s).mode === 'dark');
-  const bg = dark ? '#0B0F2B' : '#FCFBF9';
-  const needsGeo = list.some((s) => { try { return ['choropleth', 'symbolmap'].includes(resolve(s).type); } catch { return false; } });
+  const themesOf = list.map((s) => themeFor(withDefaults(s)));
+  const dark = themesOf.every((t) => t.mode === 'dark');
+  // Fondo de la página = fondo del tema (también uno global de configure()).
+  const bg = themesOf.every((t) => t.surface === themesOf[0].surface) ? themesOf[0].surface : dark ? '#0B0F2B' : '#FCFBF9';
+  const needsGeo = list.some((s) => { try { return ['choropleth', 'symbolmap', 'pointmap'].includes(resolve(s).type); } catch { return false; } });
   const bundle = bundleSource() && (needsGeo ? bundleSource() + '\n' + (bundleSource('plotagents-geo.js') || '') : bundleSource());
   const safeJSON = (o) => JSON.stringify(o).replace(/</g, '\\u003c');
   const charts = list.map((s, i) => `<figure class="pa" id="pa-${i}">${plot(s)}</figure>` + (bundle ? `<script type="application/json" id="pa-spec-${i}">${safeJSON(s)}</script>` : '')).join('\n');
@@ -239,7 +309,7 @@ export function toHTML(specs, { title = 'Gráficos', lang = 'es', columns = 1 }
 ${[...new Set([FONT_CSS, ...list.map((s) => themeFor(withDefaults(s)).font?.import).filter(Boolean)])].map((u) => `<link rel="stylesheet" href="${esc(u)}">`).join('\n')}
 <style>
 :root{color-scheme:${dark ? 'dark' : 'light'}}
-body{margin:0;background:${bg};font-family:${esc(themeFor(withDefaults(list[0])).font?.family || "'Mozilla Text',system-ui,sans-serif")}}
+body{margin:0;background:${cssText(bg)};font-family:${cssText(themeFor(withDefaults(list[0])).font?.family || "'Mozilla Text',system-ui,sans-serif")}}
 main{max-width:${columns > 1 ? 1500 : 820}px;margin:0 auto;padding:24px 16px;display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,${columns > 1 ? 560 : 320}px),1fr));gap:24px}
 figure.pa{margin:0;min-width:0}
 figure.pa svg{width:100%;height:auto;display:block}
@@ -251,6 +321,9 @@ ${boot}
 </body></html>`;
 }
 
+/** Texto dentro de <style>: las entidades HTML no se decodifican ahí (esc() rompería las comillas), así que se quitan los caracteres que cierran la regla o la etiqueta. */
+const cssText = (v) => String(v ?? '').replace(/[<>{};\\&]/g, '');
+
 /** Código de la biblioteca en un archivo (para incrustar en HTML). */
 export function bundleSource(file = 'plotagents.js') {
   try {
@@ -263,9 +336,14 @@ export function bundleSource(file = 'plotagents.js') {
 }
 
 _bind(plot, resolve);
+_bindDashboard({ plot, resolve, lint, bundleSource, resolveDefaults: withDefaults });
 _setProbe((s) => plot(s));
 export { render };
 
-export { RENDERERS, ALIASES, registerGeo, getGeo, registeredGeo };
+export { countWords, dashboardSchema, detectLocale, correlations };
+export { resolveColorScale, colorScaleNames, interpolateColor, COLORMAPS, QUALITATIVE };
+export { dashboard, renderDashboard, planDashboard, lintDashboard, safeDashboard, mountDashboard, packRows, balancedRows };
+export { RENDERERS, ALIASES, registerGeo, getGeo, registeredGeo, toFeatureCollection, loadGeo };
+export { registerTheme, withDefaults as resolveDefaults, embedTiles, TILE_PROVIDERS };
 export { lint, schema, toolDefinition, themes, palettes, ramps, validatePalette, getTheme, themeFor, attach, PlotError, TYPES, squarify, makeFormat, formatNumber, formatCompact };
 export default plot;

package/src/infer.js

@@ -1,7 +1,7 @@
 // Elige el tipo de gráfico cuando el agente no lo indica (type: "auto").
 import { fieldsOf, fieldKind } from './data.js';
 
-export const TYPES = ['bar', 'column', 'count', 'line', 'area', 'scatter', 'bubble', 'treemap', 'sunburst', 'donut', 'pie', 'heatmap', 'sankey', 'kpi', 'hist', 'kde', 'ecdf', 'regplot', 'residplot', 'jointplot', 'box', 'violin', 'strip', 'swarm', 'point', 'radar', 'network', 'chord', 'pyramid', 'flowchart', 'choropleth', 'symbolmap'];
+export const TYPES = ['bar', 'column', 'count', 'line', 'area', 'scatter', 'bubble', 'treemap', 'sunburst', 'donut', 'pie', 'heatmap', 'sankey', 'kpi', 'hist', 'kde', 'ecdf', 'regplot', 'residplot', 'jointplot', 'box', 'violin', 'strip', 'swarm', 'point', 'radar', 'network', 'chord', 'pyramid', 'flowchart', 'gantt', 'wordcloud', 'choropleth', 'symbolmap', 'pointmap', 'table', 'corr', 'pairplot'];
 
 // Nombres de seaborn, d3plus y otros: el agente puede usar el que conozca.
 export const ALIASES = {
@@ -9,10 +9,18 @@ export const ALIASES = {
   scatterplot: 'scatter', histplot: 'hist', histogram: 'hist', kdeplot: 'kde', density: 'kde', ecdfplot: 'ecdf',
   lmplot: 'regplot', reg: 'regplot', regression: 'regplot', joint: 'jointplot', boxplot: 'box', violinplot: 'violin',
   stripplot: 'strip', swarmplot: 'swarm', beeswarm: 'swarm', pointplot: 'point', spider: 'radar', doughnut: 'donut',
+  pointmap: 'pointmap', dotmap: 'pointmap', 'dot-map': 'pointmap', tilemap: 'pointmap', basemap: 'pointmap', 'mapa-puntos': 'pointmap', 'mapa-de-puntos': 'pointmap', latlon: 'pointmap',
   graph: 'network', force: 'network', red: 'network', 'chord-diagram': 'chord', cuerdas: 'chord',
   populationpyramid: 'pyramid', population: 'pyramid', piramide: 'pyramid', 'pirámide': 'pyramid',
   flow: 'flowchart', diagram: 'flowchart', process: 'flowchart', diagrama: 'flowchart',
   map: 'choropleth', mapa: 'choropleth', choroplethmap: 'choropleth', symbol: 'symbolmap', bubblemap: 'symbolmap', 'mapa-simbolos': 'symbolmap',
+  words: 'wordcloud', 'word-cloud': 'wordcloud', wordclouds: 'wordcloud', tagcloud: 'wordcloud', 'tag-cloud': 'wordcloud', nube: 'wordcloud', 'nube-de-palabras': 'wordcloud', cloud: 'wordcloud',
+  timeline: 'gantt', roadmap: 'gantt', schedule: 'gantt', cronograma: 'gantt', 'carta-gantt': 'gantt', ganttchart: 'gantt', 'gantt-chart': 'gantt', planning: 'gantt',
+  tabla: 'table', tables: 'table', datatable: 'table', 'data-table': 'table', grid: 'table', tableau: 'table', tabelle: 'table', tabela: 'table', spreadsheet: 'table', planilla: 'table',
+  correlation: 'corr', correlations: 'corr', corrplot: 'corr', corrmatrix: 'corr', 'corr-matrix': 'corr', 'correlation-matrix': 'corr', correlogram: 'corr', correlograma: 'corr',
+  correlacion: 'corr', 'correlación': 'corr', 'matriz-correlacion': 'corr', 'matriz-de-correlacion': 'corr', 'matriz-de-correlación': 'corr',
+  clustermap: ['corr', { cluster: true }], 'cluster-map': ['corr', { cluster: true }],
+  pairs: 'pairplot', pairgrid: 'pairplot', splom: 'pairplot', scattermatrix: 'pairplot', 'scatter-matrix': 'pairplot', 'scatterplot-matrix': 'pairplot', 'matriz-de-dispersion': 'pairplot', 'matriz-de-dispersión': 'pairplot',
   tree: 'treemap', stat: 'kpi', stats: 'kpi', number: 'kpi', heat: 'heatmap', flow: 'sankey',
 };
 
@@ -26,16 +34,25 @@ export function normalizeType(t) {
 
 export function inferType(spec, data = []) {
   if (spec.items) return 'kpi';
+  if (Array.isArray(spec.columns) || spec.pageSize !== undefined) return 'table';
   if (spec.geo) return 'choropleth';
+  if (spec.lat || spec.lon || spec.tiles !== undefined) return 'pointmap';
+  { const f = fieldsOf(data); if (f.some((k) => /^(lat|latitude|latitud)$/i.test(k)) && f.some((k) => /^(lon|lng|long|longitude|longitud)$/i.test(k))) return 'pointmap'; }
+  if ((typeof spec.text === 'string' && !(data[0] && spec.text in data[0])) || (Array.isArray(spec.text) && spec.text.length && typeof spec.text[0] === 'string') || spec.textField) return 'wordcloud';
+  if (spec.start !== undefined && (spec.end !== undefined || spec.duration !== undefined) && typeof spec.start === 'string') return 'gantt';
   if (spec.nodes && spec.nodes.some?.((n) => n && n.type)) return 'flowchart';
   if (spec.nodes) return 'network';
   if (spec.matrix) return 'chord';
   if (spec.from || spec.to) return 'sankey';
   if (spec.path || spec.group) return 'treemap';
+  if (spec.triangle !== undefined || spec.cluster !== undefined || spec.method !== undefined) return 'corr';
+  if (spec.diag !== undefined || spec.corner !== undefined || spec.upper !== undefined) return 'pairplot';
   if (spec.size) return 'bubble';
   const fields = fieldsOf(data);
   if ((fields.includes('source') && fields.includes('target')) || (fields.includes('from') && fields.includes('to'))) return 'sankey';
   const kinds = Object.fromEntries(fields.map((f) => [f, fieldKind(data, f)]));
+  // Dos fechas por fila (inicio y fin) y un nombre: un cronograma.
+  if (fields.filter((f) => kinds[f] === 'date').length >= 2 && fields.some((f) => kinds[f] === 'category') && !spec.y && !spec.series) return 'gantt';
   const x = spec.x ?? fields[0];
   const xk = kinds[x];
   if (xk === 'date' || xk === 'year') return 'line';