acai-ui 1.65.5

package/dist/index199.mjs

@@ -0,0 +1,399 @@
+import { fatiasPizza, caminhoSetor, caixaDoArco, caminhoArco, pontoNoArco, caminhoMarcador, caminhoBarra, caminhoArea, caminhoLinha } from "./index213.mjs";
+import { resolverCor, corQuasarParaToken, dominioDeSeries, empilhar } from "./index197.mjs";
+import { escalaLinear, escalaBanda, escalaSubBanda } from "./index214.mjs";
+import { calcularLayout, LARGURA_COMPACTA } from "./index200.mjs";
+import { quebrarRotulo } from "./index215.mjs";
+import { dominioBonito } from "./index216.mjs";
+const FRACAO_ROTULO_INTERNO = 0.12;
+const MARGEM_ROTULO = 86;
+function montarPlanoPizza(entrada) {
+  const {
+    dados,
+    largura,
+    altura,
+    formatar,
+    raioInterno = 0,
+    colorBy = "series",
+    thresholds = []
+  } = entrada;
+  const compacto = largura < LARGURA_COMPACTA;
+  const serie = dados.series.find((s) => !s.oculta);
+  const cx = largura / 2;
+  const cy = altura / 2;
+  const margem = compacto ? 44 : MARGEM_ROTULO;
+  const raioExterno = Math.max(
+    0,
+    Math.min(largura / 2 - margem, altura / 2 - 16)
+  );
+  const ri = Math.max(0, Math.min(0.95, raioInterno)) * raioExterno;
+  if (!serie || raioExterno <= 0) {
+    return { cx, cy, raioExterno: 0, raioInterno: 0, fatias: [], compacto };
+  }
+  const valores = serie.pontos.map((p) => p.valor === null ? 0 : p.valor);
+  const fatiasBase = fatiasPizza(valores, { espacoGraus: valores.length > 1 ? 1 : 0 });
+  const fatias = [];
+  fatiasBase.forEach((fatia) => {
+    if (fatia.valor <= 0) return;
+    const ponto = serie.pontos[fatia.indice];
+    if (!ponto) return;
+    const meio = (fatia.anguloInicio + fatia.anguloFim) / 2;
+    const dentro = fatia.fracao >= FRACAO_ROTULO_INTERNO && !compacto;
+    const percentual = `${(fatia.fracao * 100).toFixed(fatia.fracao < 0.1 ? 1 : 0).replace(".", ",")}%`;
+    let rotuloX;
+    let rotuloY;
+    let ancora = "middle";
+    let linhaGuia = "";
+    if (dentro) {
+      const raioTexto = ri > 0 ? (raioExterno + ri) / 2 : raioExterno * 0.62;
+      const p = pontoNoArco(cx, cy, raioTexto, meio);
+      rotuloX = p.x;
+      rotuloY = p.y;
+    } else {
+      const aDireita = Math.cos(meio * Math.PI / 180) >= 0;
+      const dobra = pontoNoArco(cx, cy, raioExterno + 10, meio);
+      const fim = { x: aDireita ? dobra.x + 14 : dobra.x - 14, y: dobra.y };
+      const inicio = pontoNoArco(cx, cy, raioExterno, meio);
+      linhaGuia = `M ${inicio.x.toFixed(2)} ${inicio.y.toFixed(2)} L ${dobra.x.toFixed(2)} ${dobra.y.toFixed(2)} L ${fim.x.toFixed(2)} ${fim.y.toFixed(2)}`;
+      rotuloX = aDireita ? fim.x + 4 : fim.x - 4;
+      rotuloY = fim.y;
+      ancora = aDireita ? "start" : "end";
+    }
+    fatias.push({
+      chave: `f-${fatia.indice}`,
+      indicePonto: fatia.indice,
+      d: caminhoSetor(cx, cy, raioExterno, ri, fatia.anguloInicio, fatia.anguloFim),
+      cor: resolverCor(ponto, serie, colorBy, thresholds),
+      rotulo: ponto.rotulo,
+      valor: fatia.valor,
+      percentual,
+      valorFormatado: formatar(fatia.valor),
+      anguloInicioBruto: fatia.anguloInicio,
+      anguloFimBruto: fatia.anguloFim,
+      dentro,
+      rotuloX,
+      rotuloY,
+      ancora,
+      linhaGuia
+    });
+  });
+  return { cx, cy, raioExterno, raioInterno: ri, fatias, compacto };
+}
+function paraAnguloSvg(anguloPolar) {
+  return -anguloPolar;
+}
+const FOLGA_GAUGE = 10;
+const ALTURA_VALOR_GAUGE = 30;
+const ALTURA_LEGENDA_GAUGE = 16;
+function montarPlanoGauge(entrada) {
+  const {
+    dados,
+    largura,
+    altura,
+    formatar,
+    min = 0,
+    max = 100,
+    anguloInicio = 180,
+    anguloFim = 0,
+    espessura = 14,
+    ponteiro = false,
+    bandas = false,
+    legenda = "",
+    colorBy = "series",
+    thresholds = []
+  } = entrada;
+  const compacto = largura < LARGURA_COMPACTA;
+  const baixo = Math.min(min, max);
+  const alto = Math.max(min, max);
+  const amplitude = alto - baixo;
+  const serie = dados.series.find((s) => !s.oculta);
+  const ponto = (serie == null ? void 0 : serie.pontos.find((p) => p.valor !== null)) ?? (serie == null ? void 0 : serie.pontos[0]);
+  const valor = (ponto == null ? void 0 : ponto.valor) ?? null;
+  const fracao = valor === null || amplitude <= 0 ? 0 : clamp((valor - baixo) / amplitude, 0, 1);
+  const svgInicio = paraAnguloSvg(anguloInicio);
+  const svgFimBruto = paraAnguloSvg(anguloFim);
+  const svgFim = svgFimBruto > svgInicio ? svgFimBruto : svgInicio + 360;
+  const caixa = caixaDoArco(svgInicio, svgFim);
+  const larguraCaixa = Math.max(1e-4, caixa.maxX - caixa.minX);
+  const alturaCaixa = Math.max(1e-4, caixa.maxY - caixa.minY);
+  const margem = espessura / 2 + FOLGA_GAUGE + (compacto ? 8 : 14);
+  const reservaTexto = ponteiro ? ALTURA_VALOR_GAUGE + (legenda ? ALTURA_LEGENDA_GAUGE : 0) : 0;
+  const dispX = Math.max(0, largura - margem * 2);
+  const dispY = Math.max(0, altura - margem * 2 - reservaTexto);
+  const raio = Math.max(0, Math.min(dispX / larguraCaixa, dispY / alturaCaixa));
+  const cx = margem + (dispX - larguraCaixa * raio) / 2 - caixa.minX * raio;
+  const cy = margem + (dispY - alturaCaixa * raio) / 2 - caixa.minY * raio;
+  const anguloDoValor = svgInicio + (svgFim - svgInicio) * fracao;
+  const faixas = [];
+  if (bandas && thresholds.length > 0 && amplitude > 0) {
+    const ordenadas = [...thresholds].sort((a, b) => a.upTo - b.upTo);
+    let cursorFracao = 0;
+    ordenadas.forEach((faixa, i) => {
+      const ate = clamp((faixa.upTo - baixo) / amplitude, 0, 1);
+      if (ate <= cursorFracao) return;
+      faixas.push({
+        chave: `fx-${i}`,
+        d: caminhoArco(
+          cx,
+          cy,
+          raio,
+          svgInicio + (svgFim - svgInicio) * cursorFracao,
+          svgInicio + (svgFim - svgInicio) * ate
+        ),
+        cor: corQuasarParaToken(faixa.color)
+      });
+      cursorFracao = ate;
+    });
+  }
+  const dPonteiro = ponteiro ? caminhoPonteiro(cx, cy, raio, espessura, anguloDoValor) : "";
+  const baseDoDesenho = cy + caixa.maxY * raio + espessura / 2;
+  const marcarValor = faixas.length > 0 && !ponteiro && valor !== null;
+  const dMarcadorValor = marcarValor ? caminhoMarcadorRadial(cx, cy, raio, espessura, anguloDoValor) : "";
+  return {
+    cx,
+    cy,
+    raio,
+    espessura,
+    dTrilho: caminhoArco(cx, cy, raio, svgInicio, svgFim),
+    dProgresso: valor === null ? "" : caminhoArco(cx, cy, raio, svgInicio, anguloDoValor),
+    faixas,
+    dPonteiro,
+    dEixoPonteiro: ponteiro ? caminhoMarcador("circle", cx, cy, espessura * 0.9) : "",
+    dMarcadorValor,
+    cor: ponto && serie ? resolverCor(ponto, serie, colorBy, thresholds) : "var(--acai-chart-1)",
+    valor,
+    valorFormatado: valor === null ? "—" : formatar(valor),
+    fracao,
+    minFormatado: formatar(baixo),
+    maxFormatado: formatar(alto),
+    minX: pontoNoArco(cx, cy, raio, svgInicio).x,
+    maxX: pontoNoArco(cx, cy, raio, svgFim).x,
+    rotulosY: pontoNoArco(cx, cy, raio, svgInicio).y + espessura / 2 + 14,
+    mostrarEscala: !compacto && svgFim - svgInicio < 350,
+    textoX: cx,
+    // Sem agulha: linha de base um pouco ACIMA do centro. Num semicírculo o `cy`
+    // é a borda de baixo da caixa, e assentar o número exatamente nela o
+    // empurraria pra fora no export (o canvas corta o que o `overflow: visible`
+    // do SVG deixa passar na tela).
+    // Com agulha: abaixo do ponto mais baixo do desenho, no espaço reservado.
+    textoY: ponteiro ? baseDoDesenho + ALTURA_VALOR_GAUGE : cy - 6,
+    legendaY: ponteiro ? baseDoDesenho + ALTURA_VALOR_GAUGE + ALTURA_LEGENDA_GAUGE : cy + 12,
+    legenda,
+    compacto
+  };
+}
+function caminhoPonteiro(cx, cy, raio, espessura, anguloSvg) {
+  const comprimento = Math.max(0, raio - espessura);
+  if (comprimento <= 0) return "";
+  const meiaBase = Math.max(2, espessura * 0.28);
+  const ponta = pontoNoArco(cx, cy, comprimento, anguloSvg);
+  const esquerda = pontoNoArco(cx, cy, meiaBase, anguloSvg - 90);
+  const direita = pontoNoArco(cx, cy, meiaBase, anguloSvg + 90);
+  const cauda = pontoNoArco(cx, cy, meiaBase * 1.4, anguloSvg + 180);
+  const f = (valor) => Number(valor.toFixed(2)).toString();
+  return `M ${f(ponta.x)} ${f(ponta.y)} L ${f(esquerda.x)} ${f(esquerda.y)} L ${f(cauda.x)} ${f(cauda.y)} L ${f(direita.x)} ${f(direita.y)} Z`;
+}
+function caminhoMarcadorRadial(cx, cy, raio, espessura, anguloSvg) {
+  const sobra = espessura * 0.35;
+  const dentro = pontoNoArco(cx, cy, Math.max(0, raio - espessura / 2 - sobra), anguloSvg);
+  const fora = pontoNoArco(cx, cy, raio + espessura / 2 + sobra, anguloSvg);
+  const f = (valor) => Number(valor.toFixed(2)).toString();
+  return `M ${f(dentro.x)} ${f(dentro.y)} L ${f(fora.x)} ${f(fora.y)}`;
+}
+const ALTURA_MINIMA_BARRA = 2;
+function montarPlanoCartesiano(entrada) {
+  const {
+    dados,
+    largura,
+    altura,
+    formatar,
+    horizontal = false,
+    empilhado = false,
+    percentual = false,
+    curva = "linear",
+    colorBy = "series",
+    thresholds = [],
+    tamanhoFontePx = 12,
+    raioBarra = 3
+  } = entrada;
+  const visiveis = dados.series.filter((s) => !s.oculta);
+  const temBarra = visiveis.some((s) => s.tipo === "bar");
+  const incluirZero = entrada.incluirZero ?? temBarra;
+  const [dominioMin, dominioMax] = calcularDominio(dados, {
+    empilhado,
+    percentual,
+    incluirZero,
+    min: entrada.min,
+    max: entrada.max
+  });
+  const bonito = dominioBonito(dominioMin, dominioMax, {
+    alvo: entrada.ticksAlvo ?? 5,
+    incluirZero
+  });
+  const rotulosValor = bonito.ticks.map(formatar);
+  const layout = calcularLayout({
+    largura,
+    altura,
+    rotulosCategoria: dados.rotulos,
+    rotulosValor: horizontal ? [] : rotulosValor,
+    horizontal,
+    temTitulo: entrada.temTitulo === true,
+    temLegenda: entrada.temLegenda === true,
+    ...entrada.posicaoLegenda ? { posicaoLegenda: entrada.posicaoLegenda } : {},
+    tamanhoFontePx
+  });
+  const { area } = layout;
+  const ticksUsados = layout.compacto && bonito.ticks.length > 4 ? bonito.ticks.filter((_, i) => i % 2 === 0) : bonito.ticks;
+  const escalaValor = horizontal ? escalaLinear([bonito.min, bonito.max], [area.x, area.x + area.largura]) : escalaLinear([bonito.min, bonito.max], [area.y + area.altura, area.y]);
+  const escalaCategoria = horizontal ? escalaBanda(dados.rotulos.length, [area.y, area.y + area.altura]) : escalaBanda(dados.rotulos.length, [area.x, area.x + area.largura]);
+  const ticks = ticksUsados.map((valor) => ({
+    valor,
+    posicao: escalaValor(valor),
+    rotulo: formatar(valor)
+  }));
+  const categorias = dados.rotulos.map((rotulo, i) => ({
+    rotulo,
+    linhas: layout.rotacao === 0 && !horizontal ? quebrarRotulo(rotulo, Math.max(4, Math.floor(escalaCategoria.larguraBanda / 7)), 2) : [rotulo],
+    centro: escalaCategoria.centro(i),
+    inicio: escalaCategoria(i),
+    largura: escalaCategoria.larguraBanda
+  }));
+  const zeroBruto = escalaValor(0);
+  const dentro = horizontal ? zeroBruto >= area.x && zeroBruto <= area.x + area.largura : zeroBruto >= area.y && zeroBruto <= area.y + area.altura;
+  const zero = bonito.min <= 0 && bonito.max >= 0 && dentro ? zeroBruto : null;
+  const barras = montarBarras({
+    dados,
+    visiveis,
+    escalaValor,
+    escalaCategoria,
+    horizontal,
+    empilhado,
+    percentual,
+    colorBy,
+    thresholds,
+    formatar,
+    mostrarValores: entrada.mostrarValores === true,
+    raioBarra,
+    base: escalaValor(clamp(0, bonito.min, bonito.max))
+  });
+  const linhas = montarLinhas({
+    visiveis,
+    escalaValor,
+    escalaCategoria,
+    horizontal,
+    curva,
+    base: escalaValor(clamp(0, bonito.min, bonito.max))
+  });
+  return {
+    area,
+    horizontal,
+    rotacao: layout.rotacao,
+    compacto: layout.compacto,
+    ticks,
+    categorias,
+    barras,
+    linhas,
+    zero
+  };
+}
+function clamp(valor, min, max) {
+  return Math.min(max, Math.max(min, valor));
+}
+function calcularDominio(dados, opcoes) {
+  return dominioDeSeries(dados, {
+    empilhado: opcoes.empilhado,
+    percentual: opcoes.percentual,
+    incluirZero: opcoes.incluirZero,
+    ...opcoes.min === void 0 ? {} : { min: opcoes.min },
+    ...opcoes.max === void 0 ? {} : { max: opcoes.max }
+  });
+}
+function montarBarras(e) {
+  const seriesBarra = e.visiveis.filter((s) => s.tipo === "bar");
+  if (seriesBarra.length === 0) return [];
+  const segmentos = e.empilhado ? empilhar(e.dados, e.percentual) : null;
+  const sub = e.empilhado ? null : escalaSubBanda(e.escalaCategoria, seriesBarra.length);
+  const barras = [];
+  seriesBarra.forEach((serie, ordem) => {
+    serie.pontos.forEach((ponto, iPonto) => {
+      var _a;
+      if (ponto.valor === null) return;
+      const inicioBanda = e.escalaCategoria(iPonto);
+      const espessura = e.empilhado ? e.escalaCategoria.larguraBanda : sub.larguraBanda;
+      const deslocamento = e.empilhado ? 0 : sub(ordem);
+      let de;
+      let ate;
+      if (segmentos) {
+        const seg = (_a = segmentos[iPonto]) == null ? void 0 : _a.find((s) => s.indiceSerie === serie.indice);
+        if (!seg) return;
+        de = e.escalaValor(seg.base);
+        ate = e.escalaValor(seg.topo);
+      } else {
+        de = e.base;
+        ate = e.escalaValor(ponto.valor);
+      }
+      const cor = resolverCor(ponto, serie, e.colorBy, e.thresholds);
+      const chave = `b-${serie.indice}-${iPonto}`;
+      const texto = ponto.rotuloDireto ?? e.formatar(ponto.valor);
+      if (e.horizontal) {
+        const x = Math.min(de, ate);
+        const comprimento = Math.max(Math.abs(ate - de), ALTURA_MINIMA_BARRA);
+        const y = inicioBanda + deslocamento;
+        barras.push({
+          chave,
+          indiceSerie: serie.indice,
+          indicePonto: iPonto,
+          d: caminhoBarra(x, y, comprimento, espessura, e.raioBarra, ate >= de ? "direita" : "esquerda"),
+          cor,
+          fantasma: ponto.fantasma,
+          rotulo: e.mostrarValores ? texto : "",
+          rotuloX: x + comprimento + 4,
+          rotuloY: y + espessura / 2
+        });
+      } else {
+        const y = Math.min(de, ate);
+        const comprimento = Math.max(Math.abs(ate - de), ALTURA_MINIMA_BARRA);
+        const x = inicioBanda + deslocamento;
+        barras.push({
+          chave,
+          indiceSerie: serie.indice,
+          indicePonto: iPonto,
+          d: caminhoBarra(x, y, espessura, comprimento, e.raioBarra, ate <= de ? "topo" : "base"),
+          cor,
+          fantasma: ponto.fantasma,
+          rotulo: e.mostrarValores ? texto : "",
+          rotuloX: x + espessura / 2,
+          rotuloY: y - 4
+        });
+      }
+    });
+  });
+  return barras;
+}
+function montarLinhas(e) {
+  const seriesLinha = e.visiveis.filter((s) => s.tipo === "line" || s.tipo === "area");
+  return seriesLinha.map((serie) => {
+    const pontos = serie.pontos.map((ponto, i) => {
+      if (ponto.valor === null) return null;
+      const aoLongo = e.escalaCategoria.centro(i);
+      const valor = e.escalaValor(ponto.valor);
+      return e.horizontal ? { x: valor, y: aoLongo } : { x: aoLongo, y: valor };
+    });
+    const marcadores = pontos.map((p, i) => p ? { d: caminhoMarcador(serie.marcador, p.x, p.y, 7), indicePonto: i } : null).filter((m) => m !== null);
+    return {
+      chave: `l-${serie.indice}`,
+      indiceSerie: serie.indice,
+      d: caminhoLinha(pontos, e.curva),
+      dArea: serie.tipo === "area" ? caminhoArea(pontos, e.base, e.curva) : "",
+      cor: serie.cor,
+      tracejada: serie.tracejada,
+      marcadores,
+      marcador: serie.marcador
+    };
+  });
+}
+export {
+  montarPlanoCartesiano,
+  montarPlanoGauge,
+  montarPlanoPizza
+};
+//# sourceMappingURL=index199.mjs.map

package/dist/index199.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index199.mjs","sources":["../src/components/chart/chart-plano.ts"],"sourcesContent":["// Plano de desenho — transforma dados + caixa em coordenadas prontas.\n//\n// Tudo que é ARITMÉTICA do gráfico mora aqui, e o `.vue` só percorre listas e\n// pinta. Ganho concreto: dá pra testar \"a barra do valor 0 encosta no eixo\",\n// \"o rótulo do tick está no y certo\", \"a linha pula o buraco\" sem montar\n// componente nem medir DOM.\n\nimport {\n  caixaDoArco,\n  caminhoArco,\n  caminhoArea,\n  caminhoBarra,\n  caminhoLinha,\n  caminhoMarcador,\n  caminhoSetor,\n  fatiasPizza,\n  pontoNoArco,\n  type MarcadorSerie,\n  type Ponto,\n} from './chart-caminhos'\nimport { corQuasarParaToken, dominioDeSeries, empilhar, resolverCor } from './chart-dados'\nimport { escalaBanda, escalaLinear, escalaSubBanda } from './chart-escalas'\nimport {\n  LARGURA_COMPACTA,\n  calcularLayout,\n  type AreaPlotagem,\n  type RotacaoRotulo,\n} from './chart-layout'\nimport { quebrarRotulo } from './chart-rotulos'\nimport { dominioBonito } from './chart-ticks'\nimport type {\n  ChartColorBy,\n  ChartThreshold,\n  DadosNormalizados,\n} from './acai-ui-chart-interface'\n\nexport interface TickPlano {\n  valor: number\n  /** Coordenada no eixo de valor (y em vertical, x em horizontal). */\n  posicao: number\n  rotulo: string\n}\n\nexport interface CategoriaPlano {\n  rotulo: string\n  /** Já quebrado em linhas — em SVG cada uma vira um `<tspan>`. */\n  linhas: string[]\n  centro: number\n  inicio: number\n  largura: number\n}\n\nexport interface BarraPlano {\n  chave: string\n  indiceSerie: number\n  indicePonto: number\n  d: string\n  cor: string\n  fantasma: boolean\n  /** Posição do rótulo direto de valor, quando ligado. */\n  rotulo: string\n  rotuloX: number\n  rotuloY: number\n}\n\nexport interface LinhaPlano {\n  chave: string\n  indiceSerie: number\n  d: string\n  dArea: string\n  cor: string\n  tracejada: boolean\n  marcadores: Array<{ d: string; indicePonto: number }>\n  marcador: MarcadorSerie\n}\n\nexport interface PlanoCartesiano {\n  area: AreaPlotagem\n  horizontal: boolean\n  rotacao: RotacaoRotulo\n  compacto: boolean\n  ticks: TickPlano[]\n  categorias: CategoriaPlano[]\n  barras: BarraPlano[]\n  linhas: LinhaPlano[]\n  /** Coordenada da linha do zero, quando ela cai dentro da área. */\n  zero: number | null\n}\n\n// ── pizza / rosca ──────────────────────────────────────────────────────────\n\nexport interface FatiaPlano {\n  chave: string\n  indicePonto: number\n  d: string\n  cor: string\n  rotulo: string\n  valor: number\n  percentual: string\n  /** Valor absoluto já formatado. Percentual sozinho esconde a grandeza. */\n  valorFormatado: string\n  /** Ângulos crus — o hit-test do cursor em pizza é ANGULAR, não por distância. */\n  anguloInicioBruto: number\n  anguloFimBruto: number\n  /** Rótulo cabe DENTRO da fatia; senão vai pra fora com linha-guia. */\n  dentro: boolean\n  rotuloX: number\n  rotuloY: number\n  ancora: 'start' | 'middle' | 'end'\n  /** Traço ligando a fatia ao rótulo externo. Vazio quando o rótulo é interno. */\n  linhaGuia: string\n}\n\nexport interface PlanoPizza {\n  cx: number\n  cy: number\n  raioExterno: number\n  raioInterno: number\n  fatias: FatiaPlano[]\n  compacto: boolean\n}\n\nexport interface EntradaPizza {\n  dados: DadosNormalizados\n  largura: number\n  altura: number\n  formatar: (valor: number) => string\n  /** 0 = pizza; 0..0.95 = fração do raio virando furo. */\n  raioInterno?: number\n  colorBy?: ChartColorBy\n  thresholds?: readonly ChartThreshold[]\n  tamanhoFontePx?: number\n}\n\n/** Abaixo disso o rótulo não cabe dentro da fatia e vai pra fora. */\nconst FRACAO_ROTULO_INTERNO = 0.12\n/** Espaço reservado nas laterais pros rótulos externos. */\nconst MARGEM_ROTULO = 86\n\n/**\n * Monta a pizza/rosca.\n *\n * O rótulo direto NÃO é enfeite: a medição da paleta mostrou que, entre TODOS\n * os pares (e em pizza toda fatia toca todas), só 2 a 4 cores se separam\n * dependendo do modo. Sem o rótulo na fatia, boa parte dos usuários não\n * consegue ler o gráfico — por isso ele é calculado aqui, não opcional.\n */\nexport function montarPlanoPizza(entrada: EntradaPizza): PlanoPizza {\n  const {\n    dados,\n    largura,\n    altura,\n    formatar,\n    raioInterno = 0,\n    colorBy = 'series',\n    thresholds = [],\n  } = entrada\n\n  const compacto = largura < LARGURA_COMPACTA\n  const serie = dados.series.find((s) => !s.oculta)\n\n  const cx = largura / 2\n  const cy = altura / 2\n  // O raio desconta a margem dos rótulos externos; sem isso o texto sai da\n  // caixa e é cortado pelo container.\n  const margem = compacto ? 44 : MARGEM_ROTULO\n  const raioExterno = Math.max(\n    0,\n    Math.min(largura / 2 - margem, altura / 2 - 16),\n  )\n  const ri = Math.max(0, Math.min(0.95, raioInterno)) * raioExterno\n\n  if (!serie || raioExterno <= 0) {\n    return { cx, cy, raioExterno: 0, raioInterno: 0, fatias: [], compacto }\n  }\n\n  const valores = serie.pontos.map((p) => (p.valor === null ? 0 : p.valor))\n  const fatiasBase = fatiasPizza(valores, { espacoGraus: valores.length > 1 ? 1 : 0 })\n\n  const fatias: FatiaPlano[] = []\n  fatiasBase.forEach((fatia) => {\n    if (fatia.valor <= 0) return\n    const ponto = serie.pontos[fatia.indice]\n    if (!ponto) return\n\n    const meio = (fatia.anguloInicio + fatia.anguloFim) / 2\n    const dentro = fatia.fracao >= FRACAO_ROTULO_INTERNO && !compacto\n    const percentual = `${(fatia.fracao * 100).toFixed(fatia.fracao < 0.1 ? 1 : 0).replace('.', ',')}%`\n\n    let rotuloX: number\n    let rotuloY: number\n    let ancora: FatiaPlano['ancora'] = 'middle'\n    let linhaGuia = ''\n\n    if (dentro) {\n      const raioTexto = ri > 0 ? (raioExterno + ri) / 2 : raioExterno * 0.62\n      const p = pontoNoArco(cx, cy, raioTexto, meio)\n      rotuloX = p.x\n      rotuloY = p.y\n    } else {\n      const aDireita = Math.cos((meio * Math.PI) / 180) >= 0\n      const dobra = pontoNoArco(cx, cy, raioExterno + 10, meio)\n      const fim = { x: aDireita ? dobra.x + 14 : dobra.x - 14, y: dobra.y }\n      const inicio = pontoNoArco(cx, cy, raioExterno, meio)\n      linhaGuia = `M ${inicio.x.toFixed(2)} ${inicio.y.toFixed(2)} L ${dobra.x.toFixed(2)} ${dobra.y.toFixed(2)} L ${fim.x.toFixed(2)} ${fim.y.toFixed(2)}`\n      rotuloX = aDireita ? fim.x + 4 : fim.x - 4\n      rotuloY = fim.y\n      ancora = aDireita ? 'start' : 'end'\n    }\n\n    fatias.push({\n      chave: `f-${fatia.indice}`,\n      indicePonto: fatia.indice,\n      d: caminhoSetor(cx, cy, raioExterno, ri, fatia.anguloInicio, fatia.anguloFim),\n      cor: resolverCor(ponto, serie, colorBy, thresholds),\n      rotulo: ponto.rotulo,\n      valor: fatia.valor,\n      percentual,\n      valorFormatado: formatar(fatia.valor),\n      anguloInicioBruto: fatia.anguloInicio,\n      anguloFimBruto: fatia.anguloFim,\n      dentro,\n      rotuloX,\n      rotuloY,\n      ancora,\n      linhaGuia,\n    })\n  })\n\n  return { cx, cy, raioExterno, raioInterno: ri, fatias, compacto }\n}\n\n// ── medidor (gauge) ────────────────────────────────────────────────────────\n\nexport interface FaixaGaugePlano {\n  chave: string\n  d: string\n  cor: string\n}\n\nexport interface PlanoGauge {\n  cx: number\n  cy: number\n  raio: number\n  espessura: number\n  /** Arco de fundo — a escala inteira. */\n  dTrilho: string\n  /** Arco preenchido até o valor. Vazio quando não há valor. */\n  dProgresso: string\n  /** Trilho fatiado pelas faixas de `thresholds` (só com `bands`). */\n  faixas: FaixaGaugePlano[]\n  /** Agulha + eixo. Vazios quando `pointer` está desligado. */\n  dPonteiro: string\n  dEixoPonteiro: string\n  /**\n   * Traço radial cruzando o arco na posição do valor. Só com `bands` e sem\n   * agulha: ali o progresso é fino e da cor da faixa, e sobre um trilho já\n   * colorido o olho não acha onde ele termina.\n   */\n  dMarcadorValor: string\n  cor: string\n  valor: number | null\n  valorFormatado: string\n  /** Posição do valor no domínio, 0..1 — já com clamp. */\n  fracao: number\n  /** Rótulos das pontas da escala. */\n  minFormatado: string\n  maxFormatado: string\n  minX: number\n  maxX: number\n  rotulosY: number\n  /**\n   * Se vale desenhar os rótulos das pontas. Em volta completa as duas pontas\n   * caem no MESMO ponto: os dois rótulos se empilham um sobre o outro e ainda por\n   * cima do arco.\n   */\n  mostrarEscala: boolean\n  /** Âncora do número central (linha de base) e da legenda logo abaixo. */\n  textoX: number\n  textoY: number\n  legendaY: number\n  legenda: string\n  compacto: boolean\n}\n\nexport interface EntradaGauge {\n  dados: DadosNormalizados\n  largura: number\n  altura: number\n  formatar: (valor: number) => string\n  min?: number\n  max?: number\n  anguloInicio?: number\n  anguloFim?: number\n  espessura?: number\n  ponteiro?: boolean\n  bandas?: boolean\n  legenda?: string\n  colorBy?: ChartColorBy\n  thresholds?: readonly ChartThreshold[]\n}\n\n/**\n * Converte o ângulo polar do consumidor (0° à direita, crescendo no\n * ANTI-horário, como no echarts) pro sistema do SVG, onde o y cresce pra baixo\n * e o `pontoNoArco` cresce no horário. É só a inversão de sinal, mas explicitar\n * evita a confusão que faria o medidor nascer de cabeça pra baixo.\n */\nfunction paraAnguloSvg(anguloPolar: number): number {\n  return -anguloPolar\n}\n\n/** Respiro pros rótulos de mínimo/máximo nas pontas do arco. */\nconst FOLGA_GAUGE = 10\n\n/**\n * Altura reservada pro número quando ele sai do centro.\n *\n * Casa com o `font-size: 1.75rem` do `chart-gauge.vue` (28px) mais um fio de\n * folga. Se aquele tamanho mudar, este número muda junto — é a duplicata\n * inevitável entre o SCSS e a aritmética do layout, igual à dos breakpoints.\n */\nconst ALTURA_VALOR_GAUGE = 30\n\n/** Altura da legenda miúda sob o número. */\nconst ALTURA_LEGENDA_GAUGE = 16\n\n/**\n * Monta o medidor.\n *\n * O número vai DENTRO do SVG, e não num overlay HTML por cima: overlay não entra\n * no export de imagem, e o medidor sem o número exportado viraria um arco\n * colorido sem informação nenhuma no PDF.\n */\nexport function montarPlanoGauge(entrada: EntradaGauge): PlanoGauge {\n  const {\n    dados,\n    largura,\n    altura,\n    formatar,\n    min = 0,\n    max = 100,\n    anguloInicio = 180,\n    anguloFim = 0,\n    espessura = 14,\n    ponteiro = false,\n    bandas = false,\n    legenda = '',\n    colorBy = 'series',\n    thresholds = [],\n  } = entrada\n\n  const compacto = largura < LARGURA_COMPACTA\n\n  // Sem par ordenado não há escala: min == max dividiria por zero e o arco\n  // ficaria preso em 0% (ou em NaN, que não desenha e não avisa).\n  const baixo = Math.min(min, max)\n  const alto = Math.max(min, max)\n  const amplitude = alto - baixo\n\n  const serie = dados.series.find((s) => !s.oculta)\n  const ponto = serie?.pontos.find((p) => p.valor !== null) ?? serie?.pontos[0]\n  const valor = ponto?.valor ?? null\n\n  const fracao =\n    valor === null || amplitude <= 0 ? 0 : clamp((valor - baixo) / amplitude, 0, 1)\n\n  // Varredura no sentido do desenho. Ângulos iguais (ou invertidos) viram uma\n  // volta completa em vez de um arco de zero grau que não apareceria.\n  const svgInicio = paraAnguloSvg(anguloInicio)\n  const svgFimBruto = paraAnguloSvg(anguloFim)\n  const svgFim = svgFimBruto > svgInicio ? svgFimBruto : svgInicio + 360\n\n  const caixa = caixaDoArco(svgInicio, svgFim)\n  const larguraCaixa = Math.max(0.0001, caixa.maxX - caixa.minX)\n  const alturaCaixa = Math.max(0.0001, caixa.maxY - caixa.minY)\n\n  // A borda do traço avança meia espessura pra fora do raio, e o rótulo da ponta\n  // pede mais um pouco — descontar isso é o que impede o arco de ser cortado.\n  const margem = espessura / 2 + FOLGA_GAUGE + (compacto ? 8 : 14)\n\n  // 🔴 Com agulha o número NÃO pode ficar no centro: é exatamente por ali que a\n  // agulha e o eixo passam, e o traço corta o algarismo. Então ele desce pra\n  // baixo do arco — e o espaço tem que ser reservado ANTES de calcular o raio,\n  // senão o arco cresce até a borda e o número fica sem lugar (ou cortado no\n  // export, onde o `overflow: visible` do SVG não vale).\n  const reservaTexto = ponteiro\n    ? ALTURA_VALOR_GAUGE + (legenda ? ALTURA_LEGENDA_GAUGE : 0)\n    : 0\n\n  const dispX = Math.max(0, largura - margem * 2)\n  const dispY = Math.max(0, altura - margem * 2 - reservaTexto)\n  const raio = Math.max(0, Math.min(dispX / larguraCaixa, dispY / alturaCaixa))\n\n  // Centraliza a CAIXA DO ARCO na área, não o círculo: num semicírculo os dois\n  // não coincidem, e usar o círculo deixaria o desenho colado no topo.\n  const cx = margem + (dispX - larguraCaixa * raio) / 2 - caixa.minX * raio\n  const cy = margem + (dispY - alturaCaixa * raio) / 2 - caixa.minY * raio\n\n  const anguloDoValor = svgInicio + (svgFim - svgInicio) * fracao\n\n  const faixas: FaixaGaugePlano[] = []\n  if (bandas && thresholds.length > 0 && amplitude > 0) {\n    const ordenadas = [...thresholds].sort((a, b) => a.upTo - b.upTo)\n    let cursorFracao = 0\n    ordenadas.forEach((faixa, i) => {\n      const ate = clamp((faixa.upTo - baixo) / amplitude, 0, 1)\n      if (ate <= cursorFracao) return\n      faixas.push({\n        chave: `fx-${i}`,\n        d: caminhoArco(\n          cx,\n          cy,\n          raio,\n          svgInicio + (svgFim - svgInicio) * cursorFracao,\n          svgInicio + (svgFim - svgInicio) * ate,\n        ),\n        cor: corQuasarParaToken(faixa.color),\n      })\n      cursorFracao = ate\n    })\n  }\n\n  const dPonteiro = ponteiro ? caminhoPonteiro(cx, cy, raio, espessura, anguloDoValor) : ''\n\n  /** Y do ponto mais baixo que o arco alcança — onde o número assenta com agulha. */\n  const baseDoDesenho = cy + caixa.maxY * raio + espessura / 2\n\n  const marcarValor = faixas.length > 0 && !ponteiro && valor !== null\n  const dMarcadorValor = marcarValor\n    ? caminhoMarcadorRadial(cx, cy, raio, espessura, anguloDoValor)\n    : ''\n\n  return {\n    cx,\n    cy,\n    raio,\n    espessura,\n    dTrilho: caminhoArco(cx, cy, raio, svgInicio, svgFim),\n    dProgresso: valor === null ? '' : caminhoArco(cx, cy, raio, svgInicio, anguloDoValor),\n    faixas,\n    dPonteiro,\n    dEixoPonteiro: ponteiro ? caminhoMarcador('circle', cx, cy, espessura * 0.9) : '',\n    dMarcadorValor,\n    cor: ponto && serie ? resolverCor(ponto, serie, colorBy, thresholds) : 'var(--acai-chart-1)',\n    valor,\n    valorFormatado: valor === null ? '—' : formatar(valor),\n    fracao,\n    minFormatado: formatar(baixo),\n    maxFormatado: formatar(alto),\n    minX: pontoNoArco(cx, cy, raio, svgInicio).x,\n    maxX: pontoNoArco(cx, cy, raio, svgFim).x,\n    rotulosY: pontoNoArco(cx, cy, raio, svgInicio).y + espessura / 2 + 14,\n    mostrarEscala: !compacto && svgFim - svgInicio < 350,\n    textoX: cx,\n    // Sem agulha: linha de base um pouco ACIMA do centro. Num semicírculo o `cy`\n    // é a borda de baixo da caixa, e assentar o número exatamente nela o\n    // empurraria pra fora no export (o canvas corta o que o `overflow: visible`\n    // do SVG deixa passar na tela).\n    // Com agulha: abaixo do ponto mais baixo do desenho, no espaço reservado.\n    textoY: ponteiro ? baseDoDesenho + ALTURA_VALOR_GAUGE : cy - 6,\n    legendaY: ponteiro\n      ? baseDoDesenho + ALTURA_VALOR_GAUGE + ALTURA_LEGENDA_GAUGE\n      : cy + 12,\n    legenda,\n    compacto,\n  }\n}\n\n/**\n * Agulha em forma de gota: larga no eixo, fina na ponta. Um retângulo fino ficaria\n * ambíguo sobre qual extremidade aponta o valor.\n */\nfunction caminhoPonteiro(\n  cx: number,\n  cy: number,\n  raio: number,\n  espessura: number,\n  anguloSvg: number,\n): string {\n  const comprimento = Math.max(0, raio - espessura)\n  if (comprimento <= 0) return ''\n  const meiaBase = Math.max(2, espessura * 0.28)\n\n  const ponta = pontoNoArco(cx, cy, comprimento, anguloSvg)\n  const esquerda = pontoNoArco(cx, cy, meiaBase, anguloSvg - 90)\n  const direita = pontoNoArco(cx, cy, meiaBase, anguloSvg + 90)\n  const cauda = pontoNoArco(cx, cy, meiaBase * 1.4, anguloSvg + 180)\n\n  const f = (valor: number): string => Number(valor.toFixed(2)).toString()\n  return (\n    `M ${f(ponta.x)} ${f(ponta.y)} L ${f(esquerda.x)} ${f(esquerda.y)}` +\n    ` L ${f(cauda.x)} ${f(cauda.y)} L ${f(direita.x)} ${f(direita.y)} Z`\n  )\n}\n\n/** Traço radial atravessando a espessura do arco, com uma sobra de cada lado. */\nfunction caminhoMarcadorRadial(\n  cx: number,\n  cy: number,\n  raio: number,\n  espessura: number,\n  anguloSvg: number,\n): string {\n  const sobra = espessura * 0.35\n  const dentro = pontoNoArco(cx, cy, Math.max(0, raio - espessura / 2 - sobra), anguloSvg)\n  const fora = pontoNoArco(cx, cy, raio + espessura / 2 + sobra, anguloSvg)\n  const f = (valor: number): string => Number(valor.toFixed(2)).toString()\n  return `M ${f(dentro.x)} ${f(dentro.y)} L ${f(fora.x)} ${f(fora.y)}`\n}\n\nexport interface EntradaPlano {\n  dados: DadosNormalizados\n  largura: number\n  altura: number\n  formatar: (valor: number) => string\n  horizontal?: boolean\n  empilhado?: boolean\n  percentual?: boolean\n  curva?: 'linear' | 'smooth'\n  incluirZero?: boolean\n  min?: number | undefined\n  max?: number | undefined\n  ticksAlvo?: number\n  colorBy?: ChartColorBy\n  thresholds?: readonly ChartThreshold[]\n  mostrarValores?: boolean\n  temTitulo?: boolean\n  temLegenda?: boolean\n  posicaoLegenda?: 'bottom' | 'right'\n  tamanhoFontePx?: number\n  /** Raio da ponta da barra. 0 desliga. */\n  raioBarra?: number\n}\n\n/** Barra de valor exatamente 0 vira um traço: some, e \"zero\" viraria \"sem dado\". */\nconst ALTURA_MINIMA_BARRA = 2\n\nexport function montarPlanoCartesiano(entrada: EntradaPlano): PlanoCartesiano {\n  const {\n    dados,\n    largura,\n    altura,\n    formatar,\n    horizontal = false,\n    empilhado = false,\n    percentual = false,\n    curva = 'linear',\n    colorBy = 'series',\n    thresholds = [],\n    tamanhoFontePx = 12,\n    raioBarra = 3,\n  } = entrada\n\n  const visiveis = dados.series.filter((s) => !s.oculta)\n  const temBarra = visiveis.some((s) => s.tipo === 'bar')\n\n  // Domínio: barra inclui zero por padrão (a área codifica grandeza, cortar a\n  // base infla a diferença); linha não (codifica variação).\n  const incluirZero = entrada.incluirZero ?? temBarra\n\n  const [dominioMin, dominioMax] = calcularDominio(dados, {\n    empilhado,\n    percentual,\n    incluirZero,\n    min: entrada.min,\n    max: entrada.max,\n  })\n\n  const bonito = dominioBonito(dominioMin, dominioMax, {\n    alvo: entrada.ticksAlvo ?? 5,\n    incluirZero,\n  })\n\n  const rotulosValor = bonito.ticks.map(formatar)\n\n  const layout = calcularLayout({\n    largura,\n    altura,\n    rotulosCategoria: dados.rotulos,\n    rotulosValor: horizontal ? [] : rotulosValor,\n    horizontal,\n    temTitulo: entrada.temTitulo === true,\n    temLegenda: entrada.temLegenda === true,\n    ...(entrada.posicaoLegenda ? { posicaoLegenda: entrada.posicaoLegenda } : {}),\n    tamanhoFontePx,\n  })\n\n  const { area } = layout\n  // Em modo compacto o eixo ganha menos ticks — 5 rótulos num celular viram\n  // um borrão.\n  const ticksUsados = layout.compacto && bonito.ticks.length > 4\n    ? bonito.ticks.filter((_, i) => i % 2 === 0)\n    : bonito.ticks\n\n  // Eixo de valor: em vertical o y CRESCE pra baixo, então a faixa inverte.\n  const escalaValor = horizontal\n    ? escalaLinear([bonito.min, bonito.max], [area.x, area.x + area.largura])\n    : escalaLinear([bonito.min, bonito.max], [area.y + area.altura, area.y])\n\n  const escalaCategoria = horizontal\n    ? escalaBanda(dados.rotulos.length, [area.y, area.y + area.altura])\n    : escalaBanda(dados.rotulos.length, [area.x, area.x + area.largura])\n\n  const ticks: TickPlano[] = ticksUsados.map((valor) => ({\n    valor,\n    posicao: escalaValor(valor),\n    rotulo: formatar(valor),\n  }))\n\n  const categorias: CategoriaPlano[] = dados.rotulos.map((rotulo, i) => ({\n    rotulo,\n    linhas:\n      layout.rotacao === 0 && !horizontal\n        ? quebrarRotulo(rotulo, Math.max(4, Math.floor(escalaCategoria.larguraBanda / 7)), 2)\n        : [rotulo],\n    centro: escalaCategoria.centro(i),\n    inicio: escalaCategoria(i),\n    largura: escalaCategoria.larguraBanda,\n  }))\n\n  const zeroBruto = escalaValor(0)\n  const dentro = horizontal\n    ? zeroBruto >= area.x && zeroBruto <= area.x + area.largura\n    : zeroBruto >= area.y && zeroBruto <= area.y + area.altura\n  const zero = bonito.min <= 0 && bonito.max >= 0 && dentro ? zeroBruto : null\n\n  const barras = montarBarras({\n    dados,\n    visiveis,\n    escalaValor,\n    escalaCategoria,\n    horizontal,\n    empilhado,\n    percentual,\n    colorBy,\n    thresholds,\n    formatar,\n    mostrarValores: entrada.mostrarValores === true,\n    raioBarra,\n    base: escalaValor(clamp(0, bonito.min, bonito.max)),\n  })\n\n  const linhas = montarLinhas({\n    visiveis,\n    escalaValor,\n    escalaCategoria,\n    horizontal,\n    curva,\n    base: escalaValor(clamp(0, bonito.min, bonito.max)),\n  })\n\n  return {\n    area,\n    horizontal,\n    rotacao: layout.rotacao,\n    compacto: layout.compacto,\n    ticks,\n    categorias,\n    barras,\n    linhas,\n    zero,\n  }\n}\n\nfunction clamp(valor: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, valor))\n}\n\n/**\n * Repassa pro `dominioDeSeries`, montando o objeto sem chaves `undefined` —\n * `exactOptionalPropertyTypes` recusa `{ min: undefined }` numa prop opcional.\n */\nfunction calcularDominio(\n  dados: DadosNormalizados,\n  opcoes: {\n    empilhado: boolean\n    percentual: boolean\n    incluirZero: boolean\n    min: number | undefined\n    max: number | undefined\n  },\n): [number, number] {\n  return dominioDeSeries(dados, {\n    empilhado: opcoes.empilhado,\n    percentual: opcoes.percentual,\n    incluirZero: opcoes.incluirZero,\n    ...(opcoes.min === undefined ? {} : { min: opcoes.min }),\n    ...(opcoes.max === undefined ? {} : { max: opcoes.max }),\n  })\n}\n\ninterface EntradaBarras {\n  dados: DadosNormalizados\n  visiveis: DadosNormalizados['series']\n  escalaValor: ReturnType<typeof escalaLinear>\n  escalaCategoria: ReturnType<typeof escalaBanda>\n  horizontal: boolean\n  empilhado: boolean\n  percentual: boolean\n  colorBy: ChartColorBy\n  thresholds: readonly ChartThreshold[]\n  formatar: (valor: number) => string\n  mostrarValores: boolean\n  raioBarra: number\n  base: number\n}\n\nfunction montarBarras(e: EntradaBarras): BarraPlano[] {\n  const seriesBarra = e.visiveis.filter((s) => s.tipo === 'bar')\n  if (seriesBarra.length === 0) return []\n\n  const segmentos = e.empilhado ? empilhar(e.dados, e.percentual) : null\n  const sub = e.empilhado\n    ? null\n    : escalaSubBanda(e.escalaCategoria, seriesBarra.length)\n\n  const barras: BarraPlano[] = []\n\n  seriesBarra.forEach((serie, ordem) => {\n    serie.pontos.forEach((ponto, iPonto) => {\n      if (ponto.valor === null) return\n\n      const inicioBanda = e.escalaCategoria(iPonto)\n      const espessura = e.empilhado ? e.escalaCategoria.larguraBanda : (sub as NonNullable<typeof sub>).larguraBanda\n      const deslocamento = e.empilhado ? 0 : (sub as NonNullable<typeof sub>)(ordem)\n\n      let de: number\n      let ate: number\n      if (segmentos) {\n        const seg = segmentos[iPonto]?.find((s) => s.indiceSerie === serie.indice)\n        if (!seg) return\n        de = e.escalaValor(seg.base)\n        ate = e.escalaValor(seg.topo)\n      } else {\n        de = e.base\n        ate = e.escalaValor(ponto.valor)\n      }\n\n      const cor = resolverCor(ponto, serie, e.colorBy, e.thresholds)\n      const chave = `b-${serie.indice}-${iPonto}`\n      const texto = ponto.rotuloDireto ?? e.formatar(ponto.valor)\n\n      if (e.horizontal) {\n        const x = Math.min(de, ate)\n        const comprimento = Math.max(Math.abs(ate - de), ALTURA_MINIMA_BARRA)\n        const y = inicioBanda + deslocamento\n        barras.push({\n          chave,\n          indiceSerie: serie.indice,\n          indicePonto: iPonto,\n          d: caminhoBarra(x, y, comprimento, espessura, e.raioBarra, ate >= de ? 'direita' : 'esquerda'),\n          cor,\n          fantasma: ponto.fantasma,\n          rotulo: e.mostrarValores ? texto : '',\n          rotuloX: x + comprimento + 4,\n          rotuloY: y + espessura / 2,\n        })\n      } else {\n        const y = Math.min(de, ate)\n        const comprimento = Math.max(Math.abs(ate - de), ALTURA_MINIMA_BARRA)\n        const x = inicioBanda + deslocamento\n        barras.push({\n          chave,\n          indiceSerie: serie.indice,\n          indicePonto: iPonto,\n          d: caminhoBarra(x, y, espessura, comprimento, e.raioBarra, ate <= de ? 'topo' : 'base'),\n          cor,\n          fantasma: ponto.fantasma,\n          rotulo: e.mostrarValores ? texto : '',\n          rotuloX: x + espessura / 2,\n          rotuloY: y - 4,\n        })\n      }\n    })\n  })\n\n  return barras\n}\n\ninterface EntradaLinhas {\n  visiveis: DadosNormalizados['series']\n  escalaValor: ReturnType<typeof escalaLinear>\n  escalaCategoria: ReturnType<typeof escalaBanda>\n  horizontal: boolean\n  curva: 'linear' | 'smooth'\n  base: number\n}\n\nfunction montarLinhas(e: EntradaLinhas): LinhaPlano[] {\n  const seriesLinha = e.visiveis.filter((s) => s.tipo === 'line' || s.tipo === 'area')\n\n  return seriesLinha.map((serie) => {\n    const pontos: Array<Ponto | null> = serie.pontos.map((ponto, i) => {\n      if (ponto.valor === null) return null\n      const aoLongo = e.escalaCategoria.centro(i)\n      const valor = e.escalaValor(ponto.valor)\n      // Linha sempre no CENTRO da banda: alinhada com o rótulo do eixo e com o\n      // grupo de barras, quando os dois convivem no mesmo gráfico.\n      return e.horizontal ? { x: valor, y: aoLongo } : { x: aoLongo, y: valor }\n    })\n\n    const marcadores = pontos\n      .map((p, i) => (p ? { d: caminhoMarcador(serie.marcador, p.x, p.y, 7), indicePonto: i } : null))\n      .filter((m): m is { d: string; indicePonto: number } => m !== null)\n\n    return {\n      chave: `l-${serie.indice}`,\n      indiceSerie: serie.indice,\n      d: caminhoLinha(pontos, e.curva),\n      dArea: serie.tipo === 'area' ? caminhoArea(pontos, e.base, e.curva) : '',\n      cor: serie.cor,\n      tracejada: serie.tracejada,\n      marcadores,\n      marcador: serie.marcador,\n    }\n  })\n}\n"],"names":[],"mappings":"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"}

package/dist/index200.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const LARGURA_COMPACTA = 480;
+const ESTREITOS = new Set(`iljtIf.,:;'"|!()[]{}-`);
+const LARGOS = new Set("mwMW@%");
+function medirTextoAprox(texto, tamanhoFontePx) {
+  if (!texto || tamanhoFontePx <= 0) return 0;
+  let avanco = 0;
+  for (const c of texto) {
+    if (c === " ") avanco += 0.26;
+    else if (ESTREITOS.has(c)) avanco += 0.3;
+    else if (LARGOS.has(c)) avanco += 0.87;
+    else if (c >= "A" && c <= "Z") avanco += 0.64;
+    else if (c >= "0" && c <= "9") avanco += 0.56;
+    else avanco += 0.52;
+  }
+  return avanco * tamanhoFontePx;
+}
+function maiorLargura(rotulos, tamanhoFontePx) {
+  return rotulos.reduce((max, r) => Math.max(max, medirTextoAprox(r, tamanhoFontePx)), 0);
+}
+function decidirRotacao(rotulos, larguraDisponivel, tamanhoFontePx) {
+  if (rotulos.length === 0 || larguraDisponivel <= 0) return 0;
+  const porCategoria = larguraDisponivel / rotulos.length;
+  const necessaria = maiorLargura(rotulos, tamanhoFontePx) + 6;
+  if (necessaria <= porCategoria) return 0;
+  if (necessaria * Math.SQRT1_2 <= porCategoria * 1.8) return -45;
+  return -90;
+}
+function alturaRotulos(rotulos, rotacao, tamanhoFontePx, maxLinhas = 2) {
+  if (rotulos.length === 0) return 0;
+  const alturaLinha = tamanhoFontePx * 1.25;
+  if (rotacao === 0) return alturaLinha * Math.max(1, Math.min(maxLinhas, 2));
+  const largura = maiorLargura(rotulos, tamanhoFontePx);
+  if (rotacao === -45) return largura * Math.SQRT1_2 + alturaLinha * 0.5;
+  return largura + alturaLinha * 0.25;
+}
+const FOLGA = 8;
+function calcularLayout(entrada) {
+  const fonte = entrada.tamanhoFontePx ?? 12;
+  const largura = Math.max(0, entrada.largura);
+  const altura = Math.max(0, entrada.altura);
+  const compacto = largura < LARGURA_COMPACTA;
+  const alturaLinha = fonte * 1.25;
+  const topo = FOLGA + (entrada.temTitulo ? alturaLinha * 1.6 : 0);
+  const legendaDireita = entrada.temLegenda === true && entrada.posicaoLegenda === "right" && !compacto;
+  const legendaAbaixo = entrada.temLegenda === true && !legendaDireita;
+  const direita = FOLGA + (legendaDireita ? Math.min(largura * 0.28, 160) : 0);
+  let esquerda;
+  let base;
+  let rotacao = 0;
+  if (entrada.horizontal) {
+    esquerda = FOLGA + Math.min(maiorLargura(entrada.rotulosCategoria, fonte) + 10, largura * 0.4);
+    base = FOLGA + alturaLinha;
+  } else {
+    esquerda = FOLGA + maiorLargura(entrada.rotulosValor, fonte) + 10;
+    const larguraEixo = Math.max(0, largura - esquerda - direita);
+    rotacao = decidirRotacao(entrada.rotulosCategoria, larguraEixo, fonte);
+    base = FOLGA + alturaRotulos(entrada.rotulosCategoria, rotacao, fonte);
+  }
+  if (legendaAbaixo) base += alturaLinha * 1.8;
+  const margens = { topo, direita, base, esquerda };
+  const area = {
+    x: esquerda,
+    y: topo,
+    largura: Math.max(0, largura - esquerda - direita),
+    altura: Math.max(0, altura - topo - base)
+  };
+  return { margens, area, rotacao, compacto };
+}
+function alturaAutomatica(quantidadeBarras, opcoes = {}) {
+  const n = Math.max(0, Math.floor(quantidadeBarras));
+  const alturaBarra = opcoes.alturaBarra ?? 36;
+  const margens = opcoes.margens ?? 40;
+  return n * alturaBarra + margens;
+}
+exports.LARGURA_COMPACTA = LARGURA_COMPACTA;
+exports.alturaAutomatica = alturaAutomatica;
+exports.alturaRotulos = alturaRotulos;
+exports.calcularLayout = calcularLayout;
+exports.decidirRotacao = decidirRotacao;
+exports.medirTextoAprox = medirTextoAprox;
+//# sourceMappingURL=index200.cjs.map

package/dist/index200.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index200.cjs","sources":["../src/components/chart/chart-layout.ts"],"sourcesContent":["// Layout — quanto espaço o chrome come e o que sobra pra plotagem.\n//\n// O ponto delicado aqui é medir texto SEM DOM. `canvas.measureText` seria exato,\n// mas exige `document` (morre em SSR), custa um reflow por medição e tornaria\n// esta camada intestável sem navegador. A saída é uma tabela de avanço médio por\n// classe de caractere: erro de ~8%, compensado por folga nas margens. Errar 8%\n// numa margem é invisível; não conseguir testar o layout, não.\n//\n// A responsividade da lib mora aqui: ela é por REGRA (menos ticks, rótulo\n// rotacionado, legenda embaixo), não por escala. Esticar o `viewBox` escalaria\n// o TEXTO junto — a mesma folha em 380px e 1400px teria rótulo de 8px e de\n// 20px, quebrando o eMAG 4.1 e ignorando a preferência de tamanho de fonte.\n\nexport interface Margens {\n  topo: number\n  direita: number\n  base: number\n  esquerda: number\n}\n\nexport interface AreaPlotagem {\n  x: number\n  y: number\n  largura: number\n  altura: number\n}\n\nexport type RotacaoRotulo = 0 | -45 | -90\n\n/** Abaixo disto o layout entra em modo compacto. Casa com o `S`/`XS` do estudo. */\nexport const LARGURA_COMPACTA = 480\n\n/** Avanço médio por caractere, em múltiplos do tamanho da fonte (stack sans do sistema). */\nconst ESTREITOS = new Set(\"iljtIf.,:;'\\\"|!()[]{}-\")\nconst LARGOS = new Set('mwMW@%')\n\n/**\n * Largura aproximada de um texto, sem tocar no DOM.\n * Alvo de precisão: ±8%. Quem consome soma folga em cima.\n */\nexport function medirTextoAprox(texto: string, tamanhoFontePx: number): number {\n  if (!texto || tamanhoFontePx <= 0) return 0\n\n  let avanco = 0\n  for (const c of texto) {\n    if (c === ' ') avanco += 0.26\n    else if (ESTREITOS.has(c)) avanco += 0.3\n    else if (LARGOS.has(c)) avanco += 0.87\n    else if (c >= 'A' && c <= 'Z') avanco += 0.64\n    else if (c >= '0' && c <= '9') avanco += 0.56\n    else avanco += 0.52\n  }\n  return avanco * tamanhoFontePx\n}\n\nfunction maiorLargura(rotulos: readonly string[], tamanhoFontePx: number): number {\n  return rotulos.reduce((max, r) => Math.max(max, medirTextoAprox(r, tamanhoFontePx)), 0)\n}\n\n/**\n * Rotação necessária pros rótulos do eixo de categoria não se sobreporem.\n *\n * Escalonado de propósito: horizontal é o mais legível, então só sai de 0 quando\n * realmente não cabe. -90 é o último recurso (leitura vertical cansa).\n */\nexport function decidirRotacao(\n  rotulos: readonly string[],\n  larguraDisponivel: number,\n  tamanhoFontePx: number,\n): RotacaoRotulo {\n  if (rotulos.length === 0 || larguraDisponivel <= 0) return 0\n\n  const porCategoria = larguraDisponivel / rotulos.length\n  // 6px de respiro entre rótulos vizinhos: encostados, viram um borrão só.\n  const necessaria = maiorLargura(rotulos, tamanhoFontePx) + 6\n\n  if (necessaria <= porCategoria) return 0\n  // A 45° a projeção horizontal cai por ~cos(45); ainda dá pra ler correndo o olho.\n  if (necessaria * Math.SQRT1_2 <= porCategoria * 1.8) return -45\n  return -90\n}\n\n/** Altura que a faixa de rótulos vai ocupar abaixo do eixo. */\nexport function alturaRotulos(\n  rotulos: readonly string[],\n  rotacao: RotacaoRotulo,\n  tamanhoFontePx: number,\n  maxLinhas = 2,\n): number {\n  if (rotulos.length === 0) return 0\n  const alturaLinha = tamanhoFontePx * 1.25\n\n  if (rotacao === 0) return alturaLinha * Math.max(1, Math.min(maxLinhas, 2))\n  const largura = maiorLargura(rotulos, tamanhoFontePx)\n  if (rotacao === -45) return largura * Math.SQRT1_2 + alturaLinha * 0.5\n  return largura + alturaLinha * 0.25\n}\n\nexport interface EntradaLayout {\n  largura: number\n  altura: number\n  rotulosCategoria: readonly string[]\n  /** Rótulos JÁ formatados do eixo de valor — a margem esquerda depende do maior. */\n  rotulosValor: readonly string[]\n  horizontal?: boolean\n  temTitulo?: boolean\n  temLegenda?: boolean\n  posicaoLegenda?: 'bottom' | 'right'\n  tamanhoFontePx?: number\n}\n\nexport interface ResultadoLayout {\n  margens: Margens\n  area: AreaPlotagem\n  rotacao: RotacaoRotulo\n  /** Abaixo de LARGURA_COMPACTA: menos ticks, sem rótulo de valor, legenda embaixo. */\n  compacto: boolean\n}\n\n/** Respiro mínimo pra o traço da linha e o rótulo de valor não serem cortados. */\nconst FOLGA = 8\n\nexport function calcularLayout(entrada: EntradaLayout): ResultadoLayout {\n  const fonte = entrada.tamanhoFontePx ?? 12\n  const largura = Math.max(0, entrada.largura)\n  const altura = Math.max(0, entrada.altura)\n  const compacto = largura < LARGURA_COMPACTA\n  const alturaLinha = fonte * 1.25\n\n  const topo = FOLGA + (entrada.temTitulo ? alturaLinha * 1.6 : 0)\n\n  // Legenda à direita em tela estreita rouba metade da plotagem: força embaixo.\n  const legendaDireita =\n    entrada.temLegenda === true && entrada.posicaoLegenda === 'right' && !compacto\n  const legendaAbaixo = entrada.temLegenda === true && !legendaDireita\n\n  const direita = FOLGA + (legendaDireita ? Math.min(largura * 0.28, 160) : 0)\n\n  let esquerda: number\n  let base: number\n  let rotacao: RotacaoRotulo = 0\n\n  if (entrada.horizontal) {\n    // Barras horizontais invertem os papéis: a categoria vira eixo Y, e o nome\n    // do município é MUITO mais largo que um número — daí o teto generoso.\n    esquerda = FOLGA + Math.min(maiorLargura(entrada.rotulosCategoria, fonte) + 10, largura * 0.4)\n    base = FOLGA + alturaLinha\n  } else {\n    esquerda = FOLGA + maiorLargura(entrada.rotulosValor, fonte) + 10\n    const larguraEixo = Math.max(0, largura - esquerda - direita)\n    rotacao = decidirRotacao(entrada.rotulosCategoria, larguraEixo, fonte)\n    base = FOLGA + alturaRotulos(entrada.rotulosCategoria, rotacao, fonte)\n  }\n\n  if (legendaAbaixo) base += alturaLinha * 1.8\n\n  const margens: Margens = { topo, direita, base, esquerda }\n\n  // Rótulo longo demais poderia comer a área inteira e produzir largura\n  // negativa — o SVG aceita e desenha nada, sem erro.\n  const area: AreaPlotagem = {\n    x: esquerda,\n    y: topo,\n    largura: Math.max(0, largura - esquerda - direita),\n    altura: Math.max(0, altura - topo - base),\n  }\n\n  return { margens, area, rotacao, compacto }\n}\n\n/**\n * Altura total pra barras horizontais, onde a altura é FUNÇÃO da quantidade de\n * barras (não o contrário): 40 municípios numa caixa de 320px viram traços de\n * 4px. Espelha o `nItens * 36 + 40` que o est-web calculava na mão em cada tela.\n */\nexport function alturaAutomatica(\n  quantidadeBarras: number,\n  opcoes: { alturaBarra?: number; margens?: number } = {},\n): number {\n  const n = Math.max(0, Math.floor(quantidadeBarras))\n  const alturaBarra = opcoes.alturaBarra ?? 36\n  const margens = opcoes.margens ?? 40\n  return n * alturaBarra + margens\n}\n"],"names":[],"mappings":"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"}