acai-ui 1.65.5

package/dist/index213.mjs

@@ -0,0 +1,241 @@
+const CASAS = 2;
+const n = (valor) => Number(valor.toFixed(CASAS)).toString();
+function segmentar(pontos) {
+  const segmentos = [];
+  let atual = [];
+  for (const ponto of pontos) {
+    if (ponto && Number.isFinite(ponto.x) && Number.isFinite(ponto.y)) {
+      atual.push(ponto);
+    } else if (atual.length > 0) {
+      segmentos.push(atual);
+      atual = [];
+    }
+  }
+  if (atual.length > 0) segmentos.push(atual);
+  return segmentos;
+}
+function tangentes(p) {
+  const total = p.length;
+  const dx = [];
+  const inclinacoes = [];
+  for (let i = 0; i < total - 1; i++) {
+    const passoX = p[i + 1].x - p[i].x;
+    dx.push(passoX);
+    inclinacoes.push(passoX === 0 ? 0 : (p[i + 1].y - p[i].y) / passoX);
+  }
+  const t = new Array(total);
+  t[0] = inclinacoes[0] ?? 0;
+  t[total - 1] = inclinacoes[total - 2] ?? 0;
+  for (let i = 1; i < total - 1; i++) {
+    const anterior = inclinacoes[i - 1];
+    const proxima = inclinacoes[i];
+    if (anterior * proxima <= 0) {
+      t[i] = 0;
+      continue;
+    }
+    const p1 = 2 * dx[i] + dx[i - 1];
+    const p2 = dx[i] + 2 * dx[i - 1];
+    t[i] = (p1 + p2) / (p1 / anterior + p2 / proxima);
+  }
+  return t;
+}
+function segmentoParaD(pontos, curva) {
+  const primeiro = pontos[0];
+  if (pontos.length === 1) {
+    return `M ${n(primeiro.x)} ${n(primeiro.y)}`;
+  }
+  const partes = [`M ${n(primeiro.x)} ${n(primeiro.y)}`];
+  if (curva !== "smooth" || pontos.length === 2) {
+    for (let i = 1; i < pontos.length; i++) {
+      const ponto = pontos[i];
+      partes.push(`L ${n(ponto.x)} ${n(ponto.y)}`);
+    }
+    return partes.join(" ");
+  }
+  const t = tangentes(pontos);
+  for (let i = 0; i < pontos.length - 1; i++) {
+    const a = pontos[i];
+    const b = pontos[i + 1];
+    const terco = (b.x - a.x) / 3;
+    partes.push(
+      `C ${n(a.x + terco)} ${n(a.y + t[i] * terco)} ${n(b.x - terco)} ${n(b.y - t[i + 1] * terco)} ${n(b.x)} ${n(b.y)}`
+    );
+  }
+  return partes.join(" ");
+}
+function caminhoLinha(pontos, curva = "linear") {
+  return segmentar(pontos).map((s) => segmentoParaD(s, curva)).join(" ");
+}
+function caminhoArea(pontos, yBase, curva = "linear") {
+  return segmentar(pontos).filter((s) => s.length > 1).map((s) => {
+    const inicio = s[0];
+    const fim = s[s.length - 1];
+    return `${segmentoParaD(s, curva)} L ${n(fim.x)} ${n(yBase)} L ${n(inicio.x)} ${n(yBase)} Z`;
+  }).join(" ");
+}
+function retanguloArredondado(x, y, largura, altura, raios) {
+  const limite = Math.max(0, Math.min(largura, altura) / 2);
+  const [a, b, c, d] = raios.map((r) => Math.max(0, Math.min(r, limite)));
+  return [
+    `M ${n(x + a)} ${n(y)}`,
+    `L ${n(x + largura - b)} ${n(y)}`,
+    b > 0 ? `A ${n(b)} ${n(b)} 0 0 1 ${n(x + largura)} ${n(y + b)}` : "",
+    `L ${n(x + largura)} ${n(y + altura - c)}`,
+    c > 0 ? `A ${n(c)} ${n(c)} 0 0 1 ${n(x + largura - c)} ${n(y + altura)}` : "",
+    `L ${n(x + d)} ${n(y + altura)}`,
+    d > 0 ? `A ${n(d)} ${n(d)} 0 0 1 ${n(x)} ${n(y + altura - d)}` : "",
+    `L ${n(x)} ${n(y + a)}`,
+    a > 0 ? `A ${n(a)} ${n(a)} 0 0 1 ${n(x + a)} ${n(y)}` : "",
+    "Z"
+  ].filter(Boolean).join(" ");
+}
+function caminhoBarra(x, y, largura, altura, raio = 0, ponta = "topo") {
+  const larg = Math.max(0, largura);
+  const alt = Math.max(0, altura);
+  const cantos = {
+    topo: [raio, raio, 0, 0],
+    base: [0, 0, raio, raio],
+    direita: [0, raio, raio, 0],
+    esquerda: [raio, 0, 0, raio],
+    nenhuma: [0, 0, 0, 0]
+  };
+  return retanguloArredondado(x, y, larg, alt, cantos[ponta]);
+}
+function pontoNoArco(cx, cy, raio, anguloGraus) {
+  const rad = anguloGraus * Math.PI / 180;
+  return { x: cx + raio * Math.cos(rad), y: cy + raio * Math.sin(rad) };
+}
+const VOLTA_COMPLETA = 359.999;
+function caminhoSetor(cx, cy, raioExterno, raioInterno, anguloInicio, anguloFim) {
+  const re = Math.max(0, raioExterno);
+  const ri = Math.max(0, Math.min(raioInterno, re));
+  const varredura = anguloFim - anguloInicio;
+  if (varredura <= 0) return "";
+  const p = (raio, graus) => {
+    const { x, y } = pontoNoArco(cx, cy, raio, graus);
+    return `${n(x)} ${n(y)}`;
+  };
+  if (varredura >= VOLTA_COMPLETA) {
+    const meio = anguloInicio + 180;
+    const externo = `M ${p(re, anguloInicio)} A ${n(re)} ${n(re)} 0 1 1 ${p(re, meio)} A ${n(re)} ${n(re)} 0 1 1 ${p(re, anguloInicio)} Z`;
+    if (ri <= 0) return externo;
+    const interno = `M ${p(ri, anguloInicio)} A ${n(ri)} ${n(ri)} 0 1 0 ${p(ri, meio)} A ${n(ri)} ${n(ri)} 0 1 0 ${p(ri, anguloInicio)} Z`;
+    return `${externo} ${interno}`;
+  }
+  const arcoGrande = varredura > 180 ? 1 : 0;
+  if (ri <= 0) {
+    return [
+      `M ${n(cx)} ${n(cy)}`,
+      `L ${p(re, anguloInicio)}`,
+      `A ${n(re)} ${n(re)} 0 ${arcoGrande} 1 ${p(re, anguloFim)}`,
+      "Z"
+    ].join(" ");
+  }
+  return [
+    `M ${p(re, anguloInicio)}`,
+    `A ${n(re)} ${n(re)} 0 ${arcoGrande} 1 ${p(re, anguloFim)}`,
+    `L ${p(ri, anguloFim)}`,
+    `A ${n(ri)} ${n(ri)} 0 ${arcoGrande} 0 ${p(ri, anguloInicio)}`,
+    "Z"
+  ].join(" ");
+}
+function caminhoArco(cx, cy, raio, anguloInicio, anguloFim) {
+  const r = Math.max(0, raio);
+  const varredura = anguloFim - anguloInicio;
+  if (r === 0 || varredura <= 0) return "";
+  const p = (graus) => {
+    const { x, y } = pontoNoArco(cx, cy, r, graus);
+    return `${n(x)} ${n(y)}`;
+  };
+  if (varredura >= VOLTA_COMPLETA) {
+    const meio = anguloInicio + 180;
+    return `M ${p(anguloInicio)} A ${n(r)} ${n(r)} 0 1 1 ${p(meio)} A ${n(r)} ${n(r)} 0 1 1 ${p(anguloInicio)}`;
+  }
+  return `M ${p(anguloInicio)} A ${n(r)} ${n(r)} 0 ${varredura > 180 ? 1 : 0} 1 ${p(anguloFim)}`;
+}
+function caixaDoArco(anguloInicio, anguloFim) {
+  const amostras = [
+    { x: 0, y: 0 },
+    pontoNoArco(0, 0, 1, anguloInicio),
+    pontoNoArco(0, 0, 1, anguloFim)
+  ];
+  const primeiroEixo = Math.ceil(anguloInicio / 90) * 90;
+  for (let a = primeiroEixo; a < anguloFim; a += 90) {
+    amostras.push(pontoNoArco(0, 0, 1, a));
+  }
+  const xs = amostras.map((p) => p.x);
+  const ys = amostras.map((p) => p.y);
+  return {
+    minX: Math.min(...xs),
+    maxX: Math.max(...xs),
+    minY: Math.min(...ys),
+    maxY: Math.max(...ys)
+  };
+}
+function fatiasPizza(valores, opcoes = {}) {
+  const inicioBase = opcoes.anguloInicioGraus ?? -90;
+  const espaco = Math.max(0, opcoes.espacoGraus ?? 0);
+  const limpos = valores.map((v) => Number.isFinite(v) && v > 0 ? v : 0);
+  const total = limpos.reduce((soma, v) => soma + v, 0);
+  if (total <= 0) return [];
+  const naoVazias = limpos.filter((v) => v > 0).length;
+  const vaoTotal = naoVazias > 1 ? espaco * naoVazias : 0;
+  const disponivel = 360 - vaoTotal;
+  let cursor = inicioBase;
+  return limpos.map((valor, indice) => {
+    const fracao = valor / total;
+    const varredura = fracao * disponivel;
+    const fatia = {
+      indice,
+      valor,
+      fracao,
+      anguloInicio: cursor,
+      anguloFim: cursor + varredura
+    };
+    cursor = fatia.anguloFim + (valor > 0 && naoVazias > 1 ? espaco : 0);
+    return fatia;
+  });
+}
+function caminhoMarcador(tipo, cx, cy, tamanho) {
+  const r = Math.max(0, tamanho) / 2;
+  if (r === 0 || tipo === "none") return "";
+  switch (tipo) {
+    case "square":
+      return `M ${n(cx - r)} ${n(cy - r)} H ${n(cx + r)} V ${n(cy + r)} H ${n(cx - r)} Z`;
+    case "triangle":
+      return `M ${n(cx)} ${n(cy - r)} L ${n(cx + r)} ${n(cy + r)} L ${n(cx - r)} ${n(cy + r)} Z`;
+    case "diamond":
+      return `M ${n(cx)} ${n(cy - r)} L ${n(cx + r)} ${n(cy)} L ${n(cx)} ${n(cy + r)} L ${n(cx - r)} ${n(cy)} Z`;
+    case "cross": {
+      const b = r / 2.5;
+      return `M ${n(cx - b)} ${n(cy - r)} H ${n(cx + b)} V ${n(cy - b)} H ${n(cx + r)} V ${n(cy + b)} H ${n(cx + b)} V ${n(cy + r)} H ${n(cx - b)} V ${n(cy + b)} H ${n(cx - r)} V ${n(cy - b)} H ${n(cx - b)} Z`;
+    }
+    case "circle":
+    default:
+      return `M ${n(cx - r)} ${n(cy)} A ${n(r)} ${n(r)} 0 1 0 ${n(cx + r)} ${n(cy)} A ${n(r)} ${n(r)} 0 1 0 ${n(cx - r)} ${n(cy)} Z`;
+  }
+}
+const CICLO_MARCADORES = [
+  "circle",
+  "square",
+  "triangle",
+  "diamond",
+  "cross"
+];
+function marcadorDaSerie(indice) {
+  if (indice < 0) return "circle";
+  return CICLO_MARCADORES[indice % CICLO_MARCADORES.length];
+}
+export {
+  caixaDoArco,
+  caminhoArco,
+  caminhoArea,
+  caminhoBarra,
+  caminhoLinha,
+  caminhoMarcador,
+  caminhoSetor,
+  fatiasPizza,
+  marcadorDaSerie,
+  pontoNoArco
+};
+//# sourceMappingURL=index213.mjs.map

package/dist/index213.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index213.mjs","sources":["../src/components/chart/chart-caminhos.ts"],"sourcesContent":["// Geração de `d` de SVG — linha, área, barra, setor e marcador.\n//\n// Tudo aqui é aritmética pura, sem DOM: é o que permite testar as armadilhas de\n// geometria (arco de 100% que não desenha, largeArcFlag, buraco na série, raio\n// maior que a barra) sem montar componente. Mesmo modelo do `tour-posicionar.ts`.\n\nexport interface Ponto {\n  x: number\n  y: number\n}\n\nexport type CurvaLinha = 'linear' | 'smooth'\n\nexport type MarcadorSerie = 'circle' | 'square' | 'triangle' | 'diamond' | 'cross' | 'none'\n\n/** Quanto arredondar antes de virar string. Evita `d` com 15 casas decimais. */\nconst CASAS = 2\nconst n = (valor: number): string => Number(valor.toFixed(CASAS)).toString()\n\n// ── linha e área ───────────────────────────────────────────────────────────\n\n/**\n * Quebra a lista em segmentos contínuos. `null` INTERROMPE a linha — não\n * interpola. Ligar por cima de um buraco inventa dado que não existe: se\n * fevereiro não tem medição, a linha não pode atravessar fevereiro.\n */\nfunction segmentar(pontos: ReadonlyArray<Ponto | null>): Ponto[][] {\n  const segmentos: Ponto[][] = []\n  let atual: Ponto[] = []\n\n  for (const ponto of pontos) {\n    if (ponto && Number.isFinite(ponto.x) && Number.isFinite(ponto.y)) {\n      atual.push(ponto)\n    } else if (atual.length > 0) {\n      segmentos.push(atual)\n      atual = []\n    }\n  }\n  if (atual.length > 0) segmentos.push(atual)\n\n  return segmentos\n}\n\n/**\n * Tangentes de Fritsch-Carlson — interpolação cúbica MONOTÔNICA.\n *\n * Por que não Catmull-Rom/Bézier solto: eles produzem *overshoot*. Numa série\n * que vai 0 → 100 → 0, a curva solta desce abaixo de zero entre os pontos, e o\n * leitor vê valor negativo que nunca existiu. Em gráfico isso não é estética,\n * é correção: a curva não pode sair da faixa dos dados vizinhos.\n */\nfunction tangentes(p: readonly Ponto[]): number[] {\n  const total = p.length\n  const dx: number[] = []\n  const inclinacoes: number[] = []\n\n  for (let i = 0; i < total - 1; i++) {\n    const passoX = (p[i + 1] as Ponto).x - (p[i] as Ponto).x\n    dx.push(passoX)\n    inclinacoes.push(passoX === 0 ? 0 : ((p[i + 1] as Ponto).y - (p[i] as Ponto).y) / passoX)\n  }\n\n  const t: number[] = new Array<number>(total)\n  t[0] = inclinacoes[0] ?? 0\n  t[total - 1] = inclinacoes[total - 2] ?? 0\n\n  for (let i = 1; i < total - 1; i++) {\n    const anterior = inclinacoes[i - 1] as number\n    const proxima = inclinacoes[i] as number\n\n    // Troca de sinal (ou platô) = extremo local. Tangente zero prende a curva\n    // no ponto e é justamente o que impede o overshoot.\n    if (anterior * proxima <= 0) {\n      t[i] = 0\n      continue\n    }\n    const p1 = 2 * (dx[i] as number) + (dx[i - 1] as number)\n    const p2 = (dx[i] as number) + 2 * (dx[i - 1] as number)\n    t[i] = (p1 + p2) / (p1 / anterior + p2 / proxima)\n  }\n\n  return t\n}\n\nfunction segmentoParaD(pontos: readonly Ponto[], curva: CurvaLinha): string {\n  const primeiro = pontos[0] as Ponto\n  if (pontos.length === 1) {\n    // Ponto solto entre dois buracos: sem um `L` o path não pinta nada e o dado\n    // some. O marcador é quem o torna visível; o path só precisa existir.\n    return `M ${n(primeiro.x)} ${n(primeiro.y)}`\n  }\n\n  const partes = [`M ${n(primeiro.x)} ${n(primeiro.y)}`]\n\n  if (curva !== 'smooth' || pontos.length === 2) {\n    for (let i = 1; i < pontos.length; i++) {\n      const ponto = pontos[i] as Ponto\n      partes.push(`L ${n(ponto.x)} ${n(ponto.y)}`)\n    }\n    return partes.join(' ')\n  }\n\n  const t = tangentes(pontos)\n  for (let i = 0; i < pontos.length - 1; i++) {\n    const a = pontos[i] as Ponto\n    const b = pontos[i + 1] as Ponto\n    const terco = (b.x - a.x) / 3\n    partes.push(\n      `C ${n(a.x + terco)} ${n(a.y + (t[i] as number) * terco)}` +\n        ` ${n(b.x - terco)} ${n(b.y - (t[i + 1] as number) * terco)}` +\n        ` ${n(b.x)} ${n(b.y)}`,\n    )\n  }\n\n  return partes.join(' ')\n}\n\n/** Caminho da linha. Cada trecho contínuo vira um `M` novo (buraco = corte). */\nexport function caminhoLinha(\n  pontos: ReadonlyArray<Ponto | null>,\n  curva: CurvaLinha = 'linear',\n): string {\n  return segmentar(pontos)\n    .map((s) => segmentoParaD(s, curva))\n    .join(' ')\n}\n\n/**\n * Caminho da área. Mesmo traçado da linha, fechado contra `yBase`.\n * Cada segmento fecha sozinho — senão o preenchimento atravessaria o buraco.\n */\nexport function caminhoArea(\n  pontos: ReadonlyArray<Ponto | null>,\n  yBase: number,\n  curva: CurvaLinha = 'linear',\n): string {\n  return segmentar(pontos)\n    .filter((s) => s.length > 1)\n    .map((s) => {\n      const inicio = s[0] as Ponto\n      const fim = s[s.length - 1] as Ponto\n      return `${segmentoParaD(s, curva)} L ${n(fim.x)} ${n(yBase)} L ${n(inicio.x)} ${n(yBase)} Z`\n    })\n    .join(' ')\n}\n\n// ── barra ──────────────────────────────────────────────────────────────────\n\n/** De que lado a barra tem a ponta arredondada (a ponta do DADO, não a base). */\nexport type PontaBarra = 'topo' | 'base' | 'direita' | 'esquerda' | 'nenhuma'\n\n/** Retângulo com raio por canto: [sup-esq, sup-dir, inf-dir, inf-esq]. */\nfunction retanguloArredondado(\n  x: number,\n  y: number,\n  largura: number,\n  altura: number,\n  raios: readonly [number, number, number, number],\n): string {\n  // Raio maior que a metade do lado inverte a curva e desenha uma gravatinha.\n  const limite = Math.max(0, Math.min(largura, altura) / 2)\n  const [a, b, c, d] = raios.map((r) => Math.max(0, Math.min(r, limite))) as [\n    number,\n    number,\n    number,\n    number,\n  ]\n\n  return [\n    `M ${n(x + a)} ${n(y)}`,\n    `L ${n(x + largura - b)} ${n(y)}`,\n    b > 0 ? `A ${n(b)} ${n(b)} 0 0 1 ${n(x + largura)} ${n(y + b)}` : '',\n    `L ${n(x + largura)} ${n(y + altura - c)}`,\n    c > 0 ? `A ${n(c)} ${n(c)} 0 0 1 ${n(x + largura - c)} ${n(y + altura)}` : '',\n    `L ${n(x + d)} ${n(y + altura)}`,\n    d > 0 ? `A ${n(d)} ${n(d)} 0 0 1 ${n(x)} ${n(y + altura - d)}` : '',\n    `L ${n(x)} ${n(y + a)}`,\n    a > 0 ? `A ${n(a)} ${n(a)} 0 0 1 ${n(x + a)} ${n(y)}` : '',\n    'Z',\n  ]\n    .filter(Boolean)\n    .join(' ')\n}\n\n/**\n * Barra com arredondamento só na ponta do dado. A base fica reta porque encosta\n * no eixo — arredondar os dois lados faz a barra parecer flutuar.\n */\nexport function caminhoBarra(\n  x: number,\n  y: number,\n  largura: number,\n  altura: number,\n  raio = 0,\n  ponta: PontaBarra = 'topo',\n): string {\n  // Valor zero (ou quase) ainda precisa ocupar uma linha: barra de altura 0 some\n  // e o leitor não distingue \"zero\" de \"sem dado\".\n  const larg = Math.max(0, largura)\n  const alt = Math.max(0, altura)\n\n  const cantos: Record<PontaBarra, [number, number, number, number]> = {\n    topo: [raio, raio, 0, 0],\n    base: [0, 0, raio, raio],\n    direita: [0, raio, raio, 0],\n    esquerda: [raio, 0, 0, raio],\n    nenhuma: [0, 0, 0, 0],\n  }\n\n  return retanguloArredondado(x, y, larg, alt, cantos[ponta])\n}\n\n// ── arco, pizza e rosca ────────────────────────────────────────────────────\n\n/** Ponto na circunferência. 0° aponta para a direita; cresce no sentido horário. */\nexport function pontoNoArco(cx: number, cy: number, raio: number, anguloGraus: number): Ponto {\n  const rad = (anguloGraus * Math.PI) / 180\n  return { x: cx + raio * Math.cos(rad), y: cy + raio * Math.sin(rad) }\n}\n\n/** Acima disso tratamos como volta completa (ver armadilha no `caminhoSetor`). */\nconst VOLTA_COMPLETA = 359.999\n\n/**\n * Setor de pizza (`raioInterno = 0`) ou anel de rosca (`raioInterno > 0`).\n *\n * ⚠️ Armadilha do 100%: um arco cujo ponto inicial coincide com o final NÃO\n * desenha nada em SVG — uma única categoria sumiria da tela, sem erro. Por isso\n * a volta completa é emitida como DOIS arcos de 180°.\n *\n * ⚠️ `largeArcFlag` precisa ser 1 acima de 180°, senão o arco vai pelo lado\n * curto e a fatia dominante aparece invertida.\n */\nexport function caminhoSetor(\n  cx: number,\n  cy: number,\n  raioExterno: number,\n  raioInterno: number,\n  anguloInicio: number,\n  anguloFim: number,\n): string {\n  const re = Math.max(0, raioExterno)\n  const ri = Math.max(0, Math.min(raioInterno, re))\n  const varredura = anguloFim - anguloInicio\n\n  if (varredura <= 0) return ''\n\n  const p = (raio: number, graus: number): string => {\n    const { x, y } = pontoNoArco(cx, cy, raio, graus)\n    return `${n(x)} ${n(y)}`\n  }\n\n  if (varredura >= VOLTA_COMPLETA) {\n    const meio = anguloInicio + 180\n    const externo =\n      `M ${p(re, anguloInicio)} A ${n(re)} ${n(re)} 0 1 1 ${p(re, meio)}` +\n      ` A ${n(re)} ${n(re)} 0 1 1 ${p(re, anguloInicio)} Z`\n    if (ri <= 0) return externo\n    // Subcaminho interno no sentido CONTRÁRIO: com fill-rule nonzero é isso que\n    // abre o furo da rosca.\n    const interno =\n      `M ${p(ri, anguloInicio)} A ${n(ri)} ${n(ri)} 0 1 0 ${p(ri, meio)}` +\n      ` A ${n(ri)} ${n(ri)} 0 1 0 ${p(ri, anguloInicio)} Z`\n    return `${externo} ${interno}`\n  }\n\n  const arcoGrande = varredura > 180 ? 1 : 0\n\n  if (ri <= 0) {\n    return [\n      `M ${n(cx)} ${n(cy)}`,\n      `L ${p(re, anguloInicio)}`,\n      `A ${n(re)} ${n(re)} 0 ${arcoGrande} 1 ${p(re, anguloFim)}`,\n      'Z',\n    ].join(' ')\n  }\n\n  return [\n    `M ${p(re, anguloInicio)}`,\n    `A ${n(re)} ${n(re)} 0 ${arcoGrande} 1 ${p(re, anguloFim)}`,\n    `L ${p(ri, anguloFim)}`,\n    `A ${n(ri)} ${n(ri)} 0 ${arcoGrande} 0 ${p(ri, anguloInicio)}`,\n    'Z',\n  ].join(' ')\n}\n\n/**\n * Arco ABERTO — só a linha, sem fechar contra o centro. É o traçado do medidor:\n * a espessura vem do `stroke-width` e a ponta redonda do `stroke-linecap`, o que\n * o `caminhoSetor` (preenchido) não consegue dar.\n *\n * Convenção igual à do `pontoNoArco`: 0° à direita, crescendo no sentido\n * horário. `anguloFim > anguloInicio` varre no horário.\n *\n * ⚠️ Mesma armadilha do setor de 100%: início coincidindo com o fim não desenha\n * nada. Aqui a volta completa sai em dois arcos de 180°.\n */\nexport function caminhoArco(\n  cx: number,\n  cy: number,\n  raio: number,\n  anguloInicio: number,\n  anguloFim: number,\n): string {\n  const r = Math.max(0, raio)\n  const varredura = anguloFim - anguloInicio\n  if (r === 0 || varredura <= 0) return ''\n\n  const p = (graus: number): string => {\n    const { x, y } = pontoNoArco(cx, cy, r, graus)\n    return `${n(x)} ${n(y)}`\n  }\n\n  if (varredura >= VOLTA_COMPLETA) {\n    const meio = anguloInicio + 180\n    return (\n      `M ${p(anguloInicio)} A ${n(r)} ${n(r)} 0 1 1 ${p(meio)}` +\n      ` A ${n(r)} ${n(r)} 0 1 1 ${p(anguloInicio)}`\n    )\n  }\n\n  return `M ${p(anguloInicio)} A ${n(r)} ${n(r)} 0 ${varredura > 180 ? 1 : 0} 1 ${p(anguloFim)}`\n}\n\n/**\n * Caixa que um arco de raio 1 centrado na origem ocupa.\n *\n * Existe porque o medidor NÃO é um círculo inteiro: um semicírculo de 180° usa\n * só a metade de cima, e centrar pelo círculo completo desperdiçaria metade da\n * altura — o arco sairia pequeno com uma faixa vazia embaixo. Amostrar os\n * extremos e os cruzamentos de eixo dentro da varredura dá a caixa REAL, e o\n * mesmo cálculo serve pra 180°, 270° ou volta completa.\n *\n * A origem entra na caixa de propósito: é onde mora o número no meio do medidor.\n */\nexport function caixaDoArco(\n  anguloInicio: number,\n  anguloFim: number,\n): { minX: number; maxX: number; minY: number; maxY: number } {\n  const amostras: Ponto[] = [\n    { x: 0, y: 0 },\n    pontoNoArco(0, 0, 1, anguloInicio),\n    pontoNoArco(0, 0, 1, anguloFim),\n  ]\n\n  // Os extremos de x e y de um arco só podem cair nas pontas ou onde ele cruza\n  // um dos quatro eixos.\n  const primeiroEixo = Math.ceil(anguloInicio / 90) * 90\n  for (let a = primeiroEixo; a < anguloFim; a += 90) {\n    amostras.push(pontoNoArco(0, 0, 1, a))\n  }\n\n  const xs = amostras.map((p) => p.x)\n  const ys = amostras.map((p) => p.y)\n  return {\n    minX: Math.min(...xs),\n    maxX: Math.max(...xs),\n    minY: Math.min(...ys),\n    maxY: Math.max(...ys),\n  }\n}\n\nexport interface Fatia {\n  indice: number\n  valor: number\n  /** Participação no total, 0..1. É o que o rótulo mostra como percentual. */\n  fracao: number\n  anguloInicio: number\n  anguloFim: number\n}\n\n/**\n * Converte valores em ângulos. Começa no topo (-90°) porque é onde o olho\n * entra num gráfico circular.\n *\n * Valor negativo é ignorado: não existe fatia negativa, e somá-lo ao total\n * distorceria todas as outras em silêncio.\n */\nexport function fatiasPizza(\n  valores: readonly number[],\n  opcoes: { anguloInicioGraus?: number; espacoGraus?: number } = {},\n): Fatia[] {\n  const inicioBase = opcoes.anguloInicioGraus ?? -90\n  const espaco = Math.max(0, opcoes.espacoGraus ?? 0)\n\n  const limpos = valores.map((v) => (Number.isFinite(v) && v > 0 ? v : 0))\n  const total = limpos.reduce((soma, v) => soma + v, 0)\n  if (total <= 0) return []\n\n  // O vão entre fatias sai do total, senão a soma passa de 360°.\n  const naoVazias = limpos.filter((v) => v > 0).length\n  const vaoTotal = naoVazias > 1 ? espaco * naoVazias : 0\n  const disponivel = 360 - vaoTotal\n\n  let cursor = inicioBase\n  return limpos.map((valor, indice) => {\n    const fracao = valor / total\n    const varredura = fracao * disponivel\n    const fatia: Fatia = {\n      indice,\n      valor,\n      fracao,\n      anguloInicio: cursor,\n      anguloFim: cursor + varredura,\n    }\n    cursor = fatia.anguloFim + (valor > 0 && naoVazias > 1 ? espaco : 0)\n    return fatia\n  })\n}\n\n// ── marcador ───────────────────────────────────────────────────────────────\n\n/**\n * Marcador do ponto, como `path` (e não `<circle>`/`<rect>`) para a legenda\n * poder reaproveitar exatamente a mesma forma do gráfico.\n *\n * A forma é o SEGUNDO canal de codificação, além da cor: é o que mantém as\n * séries distinguíveis em impressão P&B e para quem não vê cor (eMAG 4.2).\n */\nexport function caminhoMarcador(\n  tipo: MarcadorSerie,\n  cx: number,\n  cy: number,\n  tamanho: number,\n): string {\n  const r = Math.max(0, tamanho) / 2\n  if (r === 0 || tipo === 'none') return ''\n\n  switch (tipo) {\n    case 'square':\n      return `M ${n(cx - r)} ${n(cy - r)} H ${n(cx + r)} V ${n(cy + r)} H ${n(cx - r)} Z`\n    case 'triangle':\n      return `M ${n(cx)} ${n(cy - r)} L ${n(cx + r)} ${n(cy + r)} L ${n(cx - r)} ${n(cy + r)} Z`\n    case 'diamond':\n      return `M ${n(cx)} ${n(cy - r)} L ${n(cx + r)} ${n(cy)} L ${n(cx)} ${n(cy + r)} L ${n(cx - r)} ${n(cy)} Z`\n    case 'cross': {\n      const b = r / 2.5\n      return (\n        `M ${n(cx - b)} ${n(cy - r)} H ${n(cx + b)} V ${n(cy - b)} H ${n(cx + r)}` +\n        ` V ${n(cy + b)} H ${n(cx + b)} V ${n(cy + r)} H ${n(cx - b)}` +\n        ` V ${n(cy + b)} H ${n(cx - r)} V ${n(cy - b)} H ${n(cx - b)} Z`\n      )\n    }\n    case 'circle':\n    default:\n      // Círculo em dois arcos pelo mesmo motivo do setor de 100%.\n      return (\n        `M ${n(cx - r)} ${n(cy)} A ${n(r)} ${n(r)} 0 1 0 ${n(cx + r)} ${n(cy)}` +\n        ` A ${n(r)} ${n(r)} 0 1 0 ${n(cx - r)} ${n(cy)} Z`\n      )\n  }\n}\n\n/** Marcador do índice da série. Ciclo de 5, alinhado com os 5 slots de cor. */\nconst CICLO_MARCADORES: readonly MarcadorSerie[] = [\n  'circle',\n  'square',\n  'triangle',\n  'diamond',\n  'cross',\n]\n\nexport function marcadorDaSerie(indice: number): MarcadorSerie {\n  if (indice < 0) return 'circle'\n  return CICLO_MARCADORES[indice % CICLO_MARCADORES.length] as MarcadorSerie\n}\n"],"names":[],"mappings":"AAgBA,MAAM,QAAQ;AACd,MAAM,IAAI,CAAC,UAA0B,OAAO,MAAM,QAAQ,KAAK,CAAC,EAAE,SAAA;AASlE,SAAS,UAAU,QAAgD;AACjE,QAAM,YAAuB,CAAA;AAC7B,MAAI,QAAiB,CAAA;AAErB,aAAW,SAAS,QAAQ;AAC1B,QAAI,SAAS,OAAO,SAAS,MAAM,CAAC,KAAK,OAAO,SAAS,MAAM,CAAC,GAAG;AACjE,YAAM,KAAK,KAAK;AAAA,IAClB,WAAW,MAAM,SAAS,GAAG;AAC3B,gBAAU,KAAK,KAAK;AACpB,cAAQ,CAAA;AAAA,IACV;AAAA,EACF;AACA,MAAI,MAAM,SAAS,EAAG,WAAU,KAAK,KAAK;AAE1C,SAAO;AACT;AAUA,SAAS,UAAU,GAA+B;AAChD,QAAM,QAAQ,EAAE;AAChB,QAAM,KAAe,CAAA;AACrB,QAAM,cAAwB,CAAA;AAE9B,WAAS,IAAI,GAAG,IAAI,QAAQ,GAAG,KAAK;AAClC,UAAM,SAAU,EAAE,IAAI,CAAC,EAAY,IAAK,EAAE,CAAC,EAAY;AACvD,OAAG,KAAK,MAAM;AACd,gBAAY,KAAK,WAAW,IAAI,KAAM,EAAE,IAAI,CAAC,EAAY,IAAK,EAAE,CAAC,EAAY,KAAK,MAAM;AAAA,EAC1F;AAEA,QAAM,IAAc,IAAI,MAAc,KAAK;AAC3C,IAAE,CAAC,IAAI,YAAY,CAAC,KAAK;AACzB,IAAE,QAAQ,CAAC,IAAI,YAAY,QAAQ,CAAC,KAAK;AAEzC,WAAS,IAAI,GAAG,IAAI,QAAQ,GAAG,KAAK;AAClC,UAAM,WAAW,YAAY,IAAI,CAAC;AAClC,UAAM,UAAU,YAAY,CAAC;AAI7B,QAAI,WAAW,WAAW,GAAG;AAC3B,QAAE,CAAC,IAAI;AACP;AAAA,IACF;AACA,UAAM,KAAK,IAAK,GAAG,CAAC,IAAgB,GAAG,IAAI,CAAC;AAC5C,UAAM,KAAM,GAAG,CAAC,IAAe,IAAK,GAAG,IAAI,CAAC;AAC5C,MAAE,CAAC,KAAK,KAAK,OAAO,KAAK,WAAW,KAAK;AAAA,EAC3C;AAEA,SAAO;AACT;AAEA,SAAS,cAAc,QAA0B,OAA2B;AAC1E,QAAM,WAAW,OAAO,CAAC;AACzB,MAAI,OAAO,WAAW,GAAG;AAGvB,WAAO,KAAK,EAAE,SAAS,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AAAA,EAC5C;AAEA,QAAM,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,EAAE;AAErD,MAAI,UAAU,YAAY,OAAO,WAAW,GAAG;AAC7C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,QAAQ,OAAO,CAAC;AACtB,aAAO,KAAK,KAAK,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE;AAAA,IAC7C;AACA,WAAO,OAAO,KAAK,GAAG;AAAA,EACxB;AAEA,QAAM,IAAI,UAAU,MAAM;AAC1B,WAAS,IAAI,GAAG,IAAI,OAAO,SAAS,GAAG,KAAK;AAC1C,UAAM,IAAI,OAAO,CAAC;AAClB,UAAM,IAAI,OAAO,IAAI,CAAC;AACtB,UAAM,SAAS,EAAE,IAAI,EAAE,KAAK;AAC5B,WAAO;AAAA,MACL,KAAK,EAAE,EAAE,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,IAAK,EAAE,CAAC,IAAe,KAAK,CAAC,IAClD,EAAE,EAAE,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,IAAK,EAAE,IAAI,CAAC,IAAe,KAAK,CAAC,IACvD,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAAA,IAAA;AAAA,EAE1B;AAEA,SAAO,OAAO,KAAK,GAAG;AACxB;AAGO,SAAS,aACd,QACA,QAAoB,UACZ;AACR,SAAO,UAAU,MAAM,EACpB,IAAI,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC,EAClC,KAAK,GAAG;AACb;AAMO,SAAS,YACd,QACA,OACA,QAAoB,UACZ;AACR,SAAO,UAAU,MAAM,EACpB,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1B,IAAI,CAAC,MAAM;AACV,UAAM,SAAS,EAAE,CAAC;AAClB,UAAM,MAAM,EAAE,EAAE,SAAS,CAAC;AAC1B,WAAO,GAAG,cAAc,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC;AAAA,EAC1F,CAAC,EACA,KAAK,GAAG;AACb;AAQA,SAAS,qBACP,GACA,GACA,SACA,QACA,OACQ;AAER,QAAM,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,SAAS,MAAM,IAAI,CAAC;AACxD,QAAM,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,MAAM,IAAI,CAAC,MAAM,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,MAAM,CAAC,CAAC;AAOtE,SAAO;AAAA,IACL,KAAK,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAAA,IACrB,KAAK,EAAE,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAAA,IAC/B,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK;AAAA,IAClE,KAAK,EAAE,IAAI,OAAO,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC,CAAC;AAAA,IACxC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,MAAM,CAAC,KAAK;AAAA,IAC3E,KAAK,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,IAAI,MAAM,CAAC;AAAA,IAC9B,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC,CAAC,KAAK;AAAA,IACjE,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAAA,IACrB,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK;AAAA,IACxD;AAAA,EAAA,EAEC,OAAO,OAAO,EACd,KAAK,GAAG;AACb;AAMO,SAAS,aACd,GACA,GACA,SACA,QACA,OAAO,GACP,QAAoB,QACZ;AAGR,QAAM,OAAO,KAAK,IAAI,GAAG,OAAO;AAChC,QAAM,MAAM,KAAK,IAAI,GAAG,MAAM;AAE9B,QAAM,SAA+D;AAAA,IACnE,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC;AAAA,IACvB,MAAM,CAAC,GAAG,GAAG,MAAM,IAAI;AAAA,IACvB,SAAS,CAAC,GAAG,MAAM,MAAM,CAAC;AAAA,IAC1B,UAAU,CAAC,MAAM,GAAG,GAAG,IAAI;AAAA,IAC3B,SAAS,CAAC,GAAG,GAAG,GAAG,CAAC;AAAA,EAAA;AAGtB,SAAO,qBAAqB,GAAG,GAAG,MAAM,KAAK,OAAO,KAAK,CAAC;AAC5D;AAKO,SAAS,YAAY,IAAY,IAAY,MAAc,aAA4B;AAC5F,QAAM,MAAO,cAAc,KAAK,KAAM;AACtC,SAAO,EAAE,GAAG,KAAK,OAAO,KAAK,IAAI,GAAG,GAAG,GAAG,KAAK,OAAO,KAAK,IAAI,GAAG,EAAA;AACpE;AAGA,MAAM,iBAAiB;AAYhB,SAAS,aACd,IACA,IACA,aACA,aACA,cACA,WACQ;AACR,QAAM,KAAK,KAAK,IAAI,GAAG,WAAW;AAClC,QAAM,KAAK,KAAK,IAAI,GAAG,KAAK,IAAI,aAAa,EAAE,CAAC;AAChD,QAAM,YAAY,YAAY;AAE9B,MAAI,aAAa,EAAG,QAAO;AAE3B,QAAM,IAAI,CAAC,MAAc,UAA0B;AACjD,UAAM,EAAE,GAAG,MAAM,YAAY,IAAI,IAAI,MAAM,KAAK;AAChD,WAAO,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAAA,EACxB;AAEA,MAAI,aAAa,gBAAgB;AAC/B,UAAM,OAAO,eAAe;AAC5B,UAAM,UACJ,KAAK,EAAE,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,MAC3D,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,YAAY,CAAC;AACnD,QAAI,MAAM,EAAG,QAAO;AAGpB,UAAM,UACJ,KAAK,EAAE,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,MAC3D,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,YAAY,CAAC;AACnD,WAAO,GAAG,OAAO,IAAI,OAAO;AAAA,EAC9B;AAEA,QAAM,aAAa,YAAY,MAAM,IAAI;AAEzC,MAAI,MAAM,GAAG;AACX,WAAO;AAAA,MACL,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC;AAAA,MACnB,KAAK,EAAE,IAAI,YAAY,CAAC;AAAA,MACxB,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,UAAU,MAAM,EAAE,IAAI,SAAS,CAAC;AAAA,MACzD;AAAA,IAAA,EACA,KAAK,GAAG;AAAA,EACZ;AAEA,SAAO;AAAA,IACL,KAAK,EAAE,IAAI,YAAY,CAAC;AAAA,IACxB,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,UAAU,MAAM,EAAE,IAAI,SAAS,CAAC;AAAA,IACzD,KAAK,EAAE,IAAI,SAAS,CAAC;AAAA,IACrB,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,UAAU,MAAM,EAAE,IAAI,YAAY,CAAC;AAAA,IAC5D;AAAA,EAAA,EACA,KAAK,GAAG;AACZ;AAaO,SAAS,YACd,IACA,IACA,MACA,cACA,WACQ;AACR,QAAM,IAAI,KAAK,IAAI,GAAG,IAAI;AAC1B,QAAM,YAAY,YAAY;AAC9B,MAAI,MAAM,KAAK,aAAa,EAAG,QAAO;AAEtC,QAAM,IAAI,CAAC,UAA0B;AACnC,UAAM,EAAE,GAAG,MAAM,YAAY,IAAI,IAAI,GAAG,KAAK;AAC7C,WAAO,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAAA,EACxB;AAEA,MAAI,aAAa,gBAAgB;AAC/B,UAAM,OAAO,eAAe;AAC5B,WACE,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,MACjD,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC;AAAA,EAE/C;AAEA,SAAO,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,YAAY,MAAM,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC;AAC9F;AAaO,SAAS,YACd,cACA,WAC4D;AAC5D,QAAM,WAAoB;AAAA,IACxB,EAAE,GAAG,GAAG,GAAG,EAAA;AAAA,IACX,YAAY,GAAG,GAAG,GAAG,YAAY;AAAA,IACjC,YAAY,GAAG,GAAG,GAAG,SAAS;AAAA,EAAA;AAKhC,QAAM,eAAe,KAAK,KAAK,eAAe,EAAE,IAAI;AACpD,WAAS,IAAI,cAAc,IAAI,WAAW,KAAK,IAAI;AACjD,aAAS,KAAK,YAAY,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,EACvC;AAEA,QAAM,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,CAAC;AAClC,QAAM,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,CAAC;AAClC,SAAO;AAAA,IACL,MAAM,KAAK,IAAI,GAAG,EAAE;AAAA,IACpB,MAAM,KAAK,IAAI,GAAG,EAAE;AAAA,IACpB,MAAM,KAAK,IAAI,GAAG,EAAE;AAAA,IACpB,MAAM,KAAK,IAAI,GAAG,EAAE;AAAA,EAAA;AAExB;AAkBO,SAAS,YACd,SACA,SAA+D,IACtD;AACT,QAAM,aAAa,OAAO,qBAAqB;AAC/C,QAAM,SAAS,KAAK,IAAI,GAAG,OAAO,eAAe,CAAC;AAElD,QAAM,SAAS,QAAQ,IAAI,CAAC,MAAO,OAAO,SAAS,CAAC,KAAK,IAAI,IAAI,IAAI,CAAE;AACvE,QAAM,QAAQ,OAAO,OAAO,CAAC,MAAM,MAAM,OAAO,GAAG,CAAC;AACpD,MAAI,SAAS,EAAG,QAAO,CAAA;AAGvB,QAAM,YAAY,OAAO,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE;AAC9C,QAAM,WAAW,YAAY,IAAI,SAAS,YAAY;AACtD,QAAM,aAAa,MAAM;AAEzB,MAAI,SAAS;AACb,SAAO,OAAO,IAAI,CAAC,OAAO,WAAW;AACnC,UAAM,SAAS,QAAQ;AACvB,UAAM,YAAY,SAAS;AAC3B,UAAM,QAAe;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA,cAAc;AAAA,MACd,WAAW,SAAS;AAAA,IAAA;AAEtB,aAAS,MAAM,aAAa,QAAQ,KAAK,YAAY,IAAI,SAAS;AAClE,WAAO;AAAA,EACT,CAAC;AACH;AAWO,SAAS,gBACd,MACA,IACA,IACA,SACQ;AACR,QAAM,IAAI,KAAK,IAAI,GAAG,OAAO,IAAI;AACjC,MAAI,MAAM,KAAK,SAAS,OAAQ,QAAO;AAEvC,UAAQ,MAAA;AAAA,IACN,KAAK;AACH,aAAO,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAAA,IACjF,KAAK;AACH,aAAO,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAAA,IACxF,KAAK;AACH,aAAO,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;AAAA,IACxG,KAAK,SAAS;AACZ,YAAM,IAAI,IAAI;AACd,aACE,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAClE,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MACtD,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAAA,IAEhE;AAAA,IACA,KAAK;AAAA,IACL;AAEE,aACE,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAC/D,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;AAAA,EAAA;AAGtD;AAGA,MAAM,mBAA6C;AAAA,EACjD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,SAAS,gBAAgB,QAA+B;AAC7D,MAAI,SAAS,EAAG,QAAO;AACvB,SAAO,iBAAiB,SAAS,iBAAiB,MAAM;AAC1D;"}

package/dist/index214.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function escalaLinear(dominio, faixa) {
+  const [d0, d1] = dominio;
+  const [f0, f1] = faixa;
+  const amplitude = d1 - d0;
+  const degenerado = amplitude === 0 || !Number.isFinite(amplitude);
+  const escala = ((valor) => {
+    if (degenerado) return (f0 + f1) / 2;
+    if (!Number.isFinite(valor)) return NaN;
+    return f0 + (valor - d0) / amplitude * (f1 - f0);
+  });
+  return Object.assign(escala, {
+    inverter(px) {
+      if (degenerado || f1 === f0) return d0;
+      return d0 + (px - f0) / (f1 - f0) * amplitude;
+    },
+    dominio,
+    faixa
+  });
+}
+function escalaBanda(quantidade, faixa, opcoes = {}) {
+  const espacoInterno = Math.min(0.95, Math.max(0, opcoes.espacoInterno ?? 0.2));
+  const espacoExterno = Math.max(0, opcoes.espacoExterno ?? 0.1);
+  const [f0, f1] = faixa;
+  const n = Math.max(0, Math.floor(quantidade));
+  if (n === 0) {
+    const vazia = ((_indice) => f0);
+    return Object.assign(vazia, {
+      larguraBanda: 0,
+      passo: 0,
+      quantidade: 0,
+      centro: (_indice) => f0,
+      indiceEm: (_px) => 0
+    });
+  }
+  const passo = (f1 - f0) / Math.max(1, n - espacoInterno + espacoExterno * 2);
+  const larguraBanda = passo * (1 - espacoInterno);
+  const inicio = f0 + (f1 - f0 - passo * (n - espacoInterno)) / 2;
+  const escala = ((indice) => inicio + passo * indice);
+  return Object.assign(escala, {
+    larguraBanda,
+    passo,
+    quantidade: n,
+    centro: (indice) => inicio + passo * indice + larguraBanda / 2,
+    indiceEm(px) {
+      if (passo === 0) return 0;
+      const cru = Math.floor((px - inicio) / passo);
+      return Math.min(n - 1, Math.max(0, cru));
+    }
+  });
+}
+function escalaSubBanda(banda, quantidadeSeries, espacoInterno = 0.1) {
+  const vao = quantidadeSeries <= 1 ? 0 : espacoInterno;
+  return escalaBanda(quantidadeSeries, [0, banda.larguraBanda], {
+    espacoInterno: vao,
+    espacoExterno: 0
+  });
+}
+exports.escalaBanda = escalaBanda;
+exports.escalaLinear = escalaLinear;
+exports.escalaSubBanda = escalaSubBanda;
+//# sourceMappingURL=index214.cjs.map

package/dist/index214.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index214.cjs","sources":["../src/components/chart/chart-escalas.ts"],"sourcesContent":["// Escalas — a ponte entre o VALOR do dado e o PIXEL do SVG.\n//\n// Duas famílias, como em qualquer gramática de gráfico:\n//   • linear  — valor contínuo → posição (eixo de valor);\n//   • banda   — índice de categoria → faixa (eixo de categoria).\n// A sub-banda é o que permite barra AGRUPADA: dentro da banda de \"Janeiro\",\n// cada série ganha a sua própria fatia.\n//\n// Livre de DOM. Todas devolvem função CHAMÁVEL com metadados anexados, pra o\n// código de desenho ficar `x(valor)` em vez de `escala.aplicar(valor)`.\n\nexport interface EscalaLinear {\n  (valor: number): number\n  /** Pixel → valor. Usado pelo tooltip e pelo crosshair. */\n  inverter(px: number): number\n  readonly dominio: readonly [number, number]\n  readonly faixa: readonly [number, number]\n}\n\n/**\n * Escala contínua. A `faixa` normalmente vem INVERTIDA no eixo Y\n * (`[base, topo]` = `[150, 10]`), porque em SVG o y cresce para baixo.\n */\nexport function escalaLinear(\n  dominio: readonly [number, number],\n  faixa: readonly [number, number],\n): EscalaLinear {\n  const [d0, d1] = dominio\n  const [f0, f1] = faixa\n  const amplitude = d1 - d0\n\n  // Domínio degenerado (série constante que escapou do dominioBonito, ou dado\n  // vazio): devolve o MEIO da faixa em vez de NaN. Um NaN aqui vira `d=\"M NaN\"`\n  // e o SVG some inteiro, sem erro no console — o pior tipo de bug.\n  const degenerado = amplitude === 0 || !Number.isFinite(amplitude)\n\n  const escala = ((valor: number): number => {\n    if (degenerado) return (f0 + f1) / 2\n    if (!Number.isFinite(valor)) return NaN\n    return f0 + ((valor - d0) / amplitude) * (f1 - f0)\n  }) as EscalaLinear\n\n  return Object.assign(escala, {\n    inverter(px: number): number {\n      if (degenerado || f1 === f0) return d0\n      return d0 + ((px - f0) / (f1 - f0)) * amplitude\n    },\n    dominio,\n    faixa,\n  })\n}\n\nexport interface EscalaBanda {\n  /** Início (x ou y) da banda `indice`. */\n  (indice: number): number\n  /** Largura útil de uma banda (já descontado o espaço interno). */\n  readonly larguraBanda: number\n  /** Distância entre inícios de bandas consecutivas. */\n  readonly passo: number\n  readonly quantidade: number\n  /** Centro da banda — onde vai o rótulo do eixo e o ponto da linha. */\n  centro(indice: number): number\n  /** Índice da banda sob a coordenada, já limitado às pontas. Para tooltip/teclado. */\n  indiceEm(px: number): number\n}\n\nexport interface OpcoesBanda {\n  /** Fração do passo virando vão ENTRE bandas (0..1). Default 0.2. */\n  espacoInterno?: number\n  /** Fração do passo virando vão nas PONTAS (0..1). Default 0.1. */\n  espacoExterno?: number\n}\n\n/**\n * Escala de categoria. Mesmo cálculo do d3-scale-band: o passo absorve os vãos\n * interno e externo, e o conjunto fica centrado na faixa.\n */\nexport function escalaBanda(\n  quantidade: number,\n  faixa: readonly [number, number],\n  opcoes: OpcoesBanda = {},\n): EscalaBanda {\n  const espacoInterno = Math.min(0.95, Math.max(0, opcoes.espacoInterno ?? 0.2))\n  const espacoExterno = Math.max(0, opcoes.espacoExterno ?? 0.1)\n  const [f0, f1] = faixa\n  const n = Math.max(0, Math.floor(quantidade))\n\n  // Sem categorias não há divisão possível — e `n` no denominador viraria /0,\n  // devolvendo Infinity pra toda posição.\n  if (n === 0) {\n    const vazia = ((_indice: number): number => f0) as EscalaBanda\n    return Object.assign(vazia, {\n      larguraBanda: 0,\n      passo: 0,\n      quantidade: 0,\n      centro: (_indice: number): number => f0,\n      indiceEm: (_px: number): number => 0,\n    })\n  }\n\n  const passo = (f1 - f0) / Math.max(1, n - espacoInterno + espacoExterno * 2)\n  const larguraBanda = passo * (1 - espacoInterno)\n  const inicio = f0 + (f1 - f0 - passo * (n - espacoInterno)) / 2\n\n  const escala = ((indice: number): number => inicio + passo * indice) as EscalaBanda\n\n  return Object.assign(escala, {\n    larguraBanda,\n    passo,\n    quantidade: n,\n    centro: (indice: number): number => inicio + passo * indice + larguraBanda / 2,\n    indiceEm(px: number): number {\n      if (passo === 0) return 0\n      const cru = Math.floor((px - inicio) / passo)\n      return Math.min(n - 1, Math.max(0, cru))\n    },\n  })\n}\n\n/**\n * Sub-bandas DENTRO de uma banda — é o que faz barra agrupada.\n *\n * Devolve posições RELATIVAS ao início da banda-mãe, então o desenho fica\n * `banda(i) + sub(s)`. Sem espaço externo de propósito: o vão nas pontas já é\n * o da banda-mãe, e somar de novo deixaria as barras do grupo espremidas.\n */\nexport function escalaSubBanda(\n  banda: EscalaBanda,\n  quantidadeSeries: number,\n  espacoInterno = 0.1,\n): EscalaBanda {\n  // Série única: não existe vão ENTRE séries pra abrir, então o espaço interno\n  // vira desperdício puro. Sem esta guarda, o caso mais comum de todos (gráfico\n  // de uma série só) sai com a barra ~10% mais estreita do que a banda permite.\n  const vao = quantidadeSeries <= 1 ? 0 : espacoInterno\n\n  return escalaBanda(quantidadeSeries, [0, banda.larguraBanda], {\n    espacoInterno: vao,\n    espacoExterno: 0,\n  })\n}\n"],"names":[],"mappings":";;AAuBO,SAAS,aACd,SACA,OACc;AACd,QAAM,CAAC,IAAI,EAAE,IAAI;AACjB,QAAM,CAAC,IAAI,EAAE,IAAI;AACjB,QAAM,YAAY,KAAK;AAKvB,QAAM,aAAa,cAAc,KAAK,CAAC,OAAO,SAAS,SAAS;AAEhE,QAAM,UAAU,CAAC,UAA0B;AACzC,QAAI,WAAY,SAAQ,KAAK,MAAM;AACnC,QAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,WAAO,MAAO,QAAQ,MAAM,aAAc,KAAK;AAAA,EACjD;AAEA,SAAO,OAAO,OAAO,QAAQ;AAAA,IAC3B,SAAS,IAAoB;AAC3B,UAAI,cAAc,OAAO,GAAI,QAAO;AACpC,aAAO,MAAO,KAAK,OAAO,KAAK,MAAO;AAAA,IACxC;AAAA,IACA;AAAA,IACA;AAAA,EAAA,CACD;AACH;AA2BO,SAAS,YACd,YACA,OACA,SAAsB,CAAA,GACT;AACb,QAAM,gBAAgB,KAAK,IAAI,MAAM,KAAK,IAAI,GAAG,OAAO,iBAAiB,GAAG,CAAC;AAC7E,QAAM,gBAAgB,KAAK,IAAI,GAAG,OAAO,iBAAiB,GAAG;AAC7D,QAAM,CAAC,IAAI,EAAE,IAAI;AACjB,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,UAAU,CAAC;AAI5C,MAAI,MAAM,GAAG;AACX,UAAM,SAAS,CAAC,YAA4B;AAC5C,WAAO,OAAO,OAAO,OAAO;AAAA,MAC1B,cAAc;AAAA,MACd,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,QAAQ,CAAC,YAA4B;AAAA,MACrC,UAAU,CAAC,QAAwB;AAAA,IAAA,CACpC;AAAA,EACH;AAEA,QAAM,SAAS,KAAK,MAAM,KAAK,IAAI,GAAG,IAAI,gBAAgB,gBAAgB,CAAC;AAC3E,QAAM,eAAe,SAAS,IAAI;AAClC,QAAM,SAAS,MAAM,KAAK,KAAK,SAAS,IAAI,kBAAkB;AAE9D,QAAM,UAAU,CAAC,WAA2B,SAAS,QAAQ;AAE7D,SAAO,OAAO,OAAO,QAAQ;AAAA,IAC3B;AAAA,IACA;AAAA,IACA,YAAY;AAAA,IACZ,QAAQ,CAAC,WAA2B,SAAS,QAAQ,SAAS,eAAe;AAAA,IAC7E,SAAS,IAAoB;AAC3B,UAAI,UAAU,EAAG,QAAO;AACxB,YAAM,MAAM,KAAK,OAAO,KAAK,UAAU,KAAK;AAC5C,aAAO,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,GAAG,GAAG,CAAC;AAAA,IACzC;AAAA,EAAA,CACD;AACH;AASO,SAAS,eACd,OACA,kBACA,gBAAgB,KACH;AAIb,QAAM,MAAM,oBAAoB,IAAI,IAAI;AAExC,SAAO,YAAY,kBAAkB,CAAC,GAAG,MAAM,YAAY,GAAG;AAAA,IAC5D,eAAe;AAAA,IACf,eAAe;AAAA,EAAA,CAChB;AACH;;;;"}

package/dist/index214.mjs

@@ -0,0 +1,63 @@
+function escalaLinear(dominio, faixa) {
+  const [d0, d1] = dominio;
+  const [f0, f1] = faixa;
+  const amplitude = d1 - d0;
+  const degenerado = amplitude === 0 || !Number.isFinite(amplitude);
+  const escala = ((valor) => {
+    if (degenerado) return (f0 + f1) / 2;
+    if (!Number.isFinite(valor)) return NaN;
+    return f0 + (valor - d0) / amplitude * (f1 - f0);
+  });
+  return Object.assign(escala, {
+    inverter(px) {
+      if (degenerado || f1 === f0) return d0;
+      return d0 + (px - f0) / (f1 - f0) * amplitude;
+    },
+    dominio,
+    faixa
+  });
+}
+function escalaBanda(quantidade, faixa, opcoes = {}) {
+  const espacoInterno = Math.min(0.95, Math.max(0, opcoes.espacoInterno ?? 0.2));
+  const espacoExterno = Math.max(0, opcoes.espacoExterno ?? 0.1);
+  const [f0, f1] = faixa;
+  const n = Math.max(0, Math.floor(quantidade));
+  if (n === 0) {
+    const vazia = ((_indice) => f0);
+    return Object.assign(vazia, {
+      larguraBanda: 0,
+      passo: 0,
+      quantidade: 0,
+      centro: (_indice) => f0,
+      indiceEm: (_px) => 0
+    });
+  }
+  const passo = (f1 - f0) / Math.max(1, n - espacoInterno + espacoExterno * 2);
+  const larguraBanda = passo * (1 - espacoInterno);
+  const inicio = f0 + (f1 - f0 - passo * (n - espacoInterno)) / 2;
+  const escala = ((indice) => inicio + passo * indice);
+  return Object.assign(escala, {
+    larguraBanda,
+    passo,
+    quantidade: n,
+    centro: (indice) => inicio + passo * indice + larguraBanda / 2,
+    indiceEm(px) {
+      if (passo === 0) return 0;
+      const cru = Math.floor((px - inicio) / passo);
+      return Math.min(n - 1, Math.max(0, cru));
+    }
+  });
+}
+function escalaSubBanda(banda, quantidadeSeries, espacoInterno = 0.1) {
+  const vao = quantidadeSeries <= 1 ? 0 : espacoInterno;
+  return escalaBanda(quantidadeSeries, [0, banda.larguraBanda], {
+    espacoInterno: vao,
+    espacoExterno: 0
+  });
+}
+export {
+  escalaBanda,
+  escalaLinear,
+  escalaSubBanda
+};
+//# sourceMappingURL=index214.mjs.map

package/dist/index214.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index214.mjs","sources":["../src/components/chart/chart-escalas.ts"],"sourcesContent":["// Escalas — a ponte entre o VALOR do dado e o PIXEL do SVG.\n//\n// Duas famílias, como em qualquer gramática de gráfico:\n//   • linear  — valor contínuo → posição (eixo de valor);\n//   • banda   — índice de categoria → faixa (eixo de categoria).\n// A sub-banda é o que permite barra AGRUPADA: dentro da banda de \"Janeiro\",\n// cada série ganha a sua própria fatia.\n//\n// Livre de DOM. Todas devolvem função CHAMÁVEL com metadados anexados, pra o\n// código de desenho ficar `x(valor)` em vez de `escala.aplicar(valor)`.\n\nexport interface EscalaLinear {\n  (valor: number): number\n  /** Pixel → valor. Usado pelo tooltip e pelo crosshair. */\n  inverter(px: number): number\n  readonly dominio: readonly [number, number]\n  readonly faixa: readonly [number, number]\n}\n\n/**\n * Escala contínua. A `faixa` normalmente vem INVERTIDA no eixo Y\n * (`[base, topo]` = `[150, 10]`), porque em SVG o y cresce para baixo.\n */\nexport function escalaLinear(\n  dominio: readonly [number, number],\n  faixa: readonly [number, number],\n): EscalaLinear {\n  const [d0, d1] = dominio\n  const [f0, f1] = faixa\n  const amplitude = d1 - d0\n\n  // Domínio degenerado (série constante que escapou do dominioBonito, ou dado\n  // vazio): devolve o MEIO da faixa em vez de NaN. Um NaN aqui vira `d=\"M NaN\"`\n  // e o SVG some inteiro, sem erro no console — o pior tipo de bug.\n  const degenerado = amplitude === 0 || !Number.isFinite(amplitude)\n\n  const escala = ((valor: number): number => {\n    if (degenerado) return (f0 + f1) / 2\n    if (!Number.isFinite(valor)) return NaN\n    return f0 + ((valor - d0) / amplitude) * (f1 - f0)\n  }) as EscalaLinear\n\n  return Object.assign(escala, {\n    inverter(px: number): number {\n      if (degenerado || f1 === f0) return d0\n      return d0 + ((px - f0) / (f1 - f0)) * amplitude\n    },\n    dominio,\n    faixa,\n  })\n}\n\nexport interface EscalaBanda {\n  /** Início (x ou y) da banda `indice`. */\n  (indice: number): number\n  /** Largura útil de uma banda (já descontado o espaço interno). */\n  readonly larguraBanda: number\n  /** Distância entre inícios de bandas consecutivas. */\n  readonly passo: number\n  readonly quantidade: number\n  /** Centro da banda — onde vai o rótulo do eixo e o ponto da linha. */\n  centro(indice: number): number\n  /** Índice da banda sob a coordenada, já limitado às pontas. Para tooltip/teclado. */\n  indiceEm(px: number): number\n}\n\nexport interface OpcoesBanda {\n  /** Fração do passo virando vão ENTRE bandas (0..1). Default 0.2. */\n  espacoInterno?: number\n  /** Fração do passo virando vão nas PONTAS (0..1). Default 0.1. */\n  espacoExterno?: number\n}\n\n/**\n * Escala de categoria. Mesmo cálculo do d3-scale-band: o passo absorve os vãos\n * interno e externo, e o conjunto fica centrado na faixa.\n */\nexport function escalaBanda(\n  quantidade: number,\n  faixa: readonly [number, number],\n  opcoes: OpcoesBanda = {},\n): EscalaBanda {\n  const espacoInterno = Math.min(0.95, Math.max(0, opcoes.espacoInterno ?? 0.2))\n  const espacoExterno = Math.max(0, opcoes.espacoExterno ?? 0.1)\n  const [f0, f1] = faixa\n  const n = Math.max(0, Math.floor(quantidade))\n\n  // Sem categorias não há divisão possível — e `n` no denominador viraria /0,\n  // devolvendo Infinity pra toda posição.\n  if (n === 0) {\n    const vazia = ((_indice: number): number => f0) as EscalaBanda\n    return Object.assign(vazia, {\n      larguraBanda: 0,\n      passo: 0,\n      quantidade: 0,\n      centro: (_indice: number): number => f0,\n      indiceEm: (_px: number): number => 0,\n    })\n  }\n\n  const passo = (f1 - f0) / Math.max(1, n - espacoInterno + espacoExterno * 2)\n  const larguraBanda = passo * (1 - espacoInterno)\n  const inicio = f0 + (f1 - f0 - passo * (n - espacoInterno)) / 2\n\n  const escala = ((indice: number): number => inicio + passo * indice) as EscalaBanda\n\n  return Object.assign(escala, {\n    larguraBanda,\n    passo,\n    quantidade: n,\n    centro: (indice: number): number => inicio + passo * indice + larguraBanda / 2,\n    indiceEm(px: number): number {\n      if (passo === 0) return 0\n      const cru = Math.floor((px - inicio) / passo)\n      return Math.min(n - 1, Math.max(0, cru))\n    },\n  })\n}\n\n/**\n * Sub-bandas DENTRO de uma banda — é o que faz barra agrupada.\n *\n * Devolve posições RELATIVAS ao início da banda-mãe, então o desenho fica\n * `banda(i) + sub(s)`. Sem espaço externo de propósito: o vão nas pontas já é\n * o da banda-mãe, e somar de novo deixaria as barras do grupo espremidas.\n */\nexport function escalaSubBanda(\n  banda: EscalaBanda,\n  quantidadeSeries: number,\n  espacoInterno = 0.1,\n): EscalaBanda {\n  // Série única: não existe vão ENTRE séries pra abrir, então o espaço interno\n  // vira desperdício puro. Sem esta guarda, o caso mais comum de todos (gráfico\n  // de uma série só) sai com a barra ~10% mais estreita do que a banda permite.\n  const vao = quantidadeSeries <= 1 ? 0 : espacoInterno\n\n  return escalaBanda(quantidadeSeries, [0, banda.larguraBanda], {\n    espacoInterno: vao,\n    espacoExterno: 0,\n  })\n}\n"],"names":[],"mappings":"AAuBO,SAAS,aACd,SACA,OACc;AACd,QAAM,CAAC,IAAI,EAAE,IAAI;AACjB,QAAM,CAAC,IAAI,EAAE,IAAI;AACjB,QAAM,YAAY,KAAK;AAKvB,QAAM,aAAa,cAAc,KAAK,CAAC,OAAO,SAAS,SAAS;AAEhE,QAAM,UAAU,CAAC,UAA0B;AACzC,QAAI,WAAY,SAAQ,KAAK,MAAM;AACnC,QAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,WAAO,MAAO,QAAQ,MAAM,aAAc,KAAK;AAAA,EACjD;AAEA,SAAO,OAAO,OAAO,QAAQ;AAAA,IAC3B,SAAS,IAAoB;AAC3B,UAAI,cAAc,OAAO,GAAI,QAAO;AACpC,aAAO,MAAO,KAAK,OAAO,KAAK,MAAO;AAAA,IACxC;AAAA,IACA;AAAA,IACA;AAAA,EAAA,CACD;AACH;AA2BO,SAAS,YACd,YACA,OACA,SAAsB,CAAA,GACT;AACb,QAAM,gBAAgB,KAAK,IAAI,MAAM,KAAK,IAAI,GAAG,OAAO,iBAAiB,GAAG,CAAC;AAC7E,QAAM,gBAAgB,KAAK,IAAI,GAAG,OAAO,iBAAiB,GAAG;AAC7D,QAAM,CAAC,IAAI,EAAE,IAAI;AACjB,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,UAAU,CAAC;AAI5C,MAAI,MAAM,GAAG;AACX,UAAM,SAAS,CAAC,YAA4B;AAC5C,WAAO,OAAO,OAAO,OAAO;AAAA,MAC1B,cAAc;AAAA,MACd,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,QAAQ,CAAC,YAA4B;AAAA,MACrC,UAAU,CAAC,QAAwB;AAAA,IAAA,CACpC;AAAA,EACH;AAEA,QAAM,SAAS,KAAK,MAAM,KAAK,IAAI,GAAG,IAAI,gBAAgB,gBAAgB,CAAC;AAC3E,QAAM,eAAe,SAAS,IAAI;AAClC,QAAM,SAAS,MAAM,KAAK,KAAK,SAAS,IAAI,kBAAkB;AAE9D,QAAM,UAAU,CAAC,WAA2B,SAAS,QAAQ;AAE7D,SAAO,OAAO,OAAO,QAAQ;AAAA,IAC3B;AAAA,IACA;AAAA,IACA,YAAY;AAAA,IACZ,QAAQ,CAAC,WAA2B,SAAS,QAAQ,SAAS,eAAe;AAAA,IAC7E,SAAS,IAAoB;AAC3B,UAAI,UAAU,EAAG,QAAO;AACxB,YAAM,MAAM,KAAK,OAAO,KAAK,UAAU,KAAK;AAC5C,aAAO,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,GAAG,GAAG,CAAC;AAAA,IACzC;AAAA,EAAA,CACD;AACH;AASO,SAAS,eACd,OACA,kBACA,gBAAgB,KACH;AAIb,QAAM,MAAM,oBAAoB,IAAI,IAAI;AAExC,SAAO,YAAY,kBAAkB,CAAC,GAAG,MAAM,YAAY,GAAG;AAAA,IAC5D,eAAe;AAAA,IACf,eAAe;AAAA,EAAA,CAChB;AACH;"}

package/dist/index215.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const RETICENCIAS = "…";
+function truncarRotulo(texto, maxPorLinha) {
+  const limpo = String(texto ?? "");
+  if (maxPorLinha <= 0) return "";
+  if (limpo.length <= maxPorLinha) return limpo;
+  return `${limpo.slice(0, Math.max(0, maxPorLinha - 1)).trimEnd()}${RETICENCIAS}`;
+}
+function fatiarPalavra(palavra, maxPorLinha) {
+  const pedacos = [];
+  for (let i = 0; i < palavra.length; i += maxPorLinha) {
+    pedacos.push(palavra.slice(i, i + maxPorLinha));
+  }
+  return pedacos;
+}
+function quebrarRotulo(texto, maxPorLinha = 16, maxLinhas = 2) {
+  const limpo = String(texto ?? "").trim();
+  if (!limpo) return [];
+  if (maxPorLinha <= 0 || maxLinhas <= 0) return [];
+  if (limpo.length <= maxPorLinha) return [limpo];
+  const palavras = limpo.split(/\s+/);
+  const linhas = [];
+  let atual = "";
+  for (const palavra of palavras) {
+    if (palavra.length > maxPorLinha) {
+      if (atual) {
+        linhas.push(atual);
+        atual = "";
+      }
+      const pedacos = fatiarPalavra(palavra, maxPorLinha);
+      linhas.push(...pedacos.slice(0, -1));
+      atual = pedacos[pedacos.length - 1] ?? "";
+      continue;
+    }
+    const tentativa = atual ? `${atual} ${palavra}` : palavra;
+    if (tentativa.length <= maxPorLinha) {
+      atual = tentativa;
+    } else {
+      if (atual) linhas.push(atual);
+      atual = palavra;
+    }
+  }
+  if (atual) linhas.push(atual);
+  if (linhas.length <= maxLinhas) return linhas;
+  const cortadas = linhas.slice(0, maxLinhas);
+  const ultima = cortadas[maxLinhas - 1];
+  cortadas[maxLinhas - 1] = truncarRotulo(`${ultima}${RETICENCIAS}`, maxPorLinha);
+  return cortadas;
+}
+exports.quebrarRotulo = quebrarRotulo;
+exports.truncarRotulo = truncarRotulo;
+//# sourceMappingURL=index215.cjs.map

package/dist/index215.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index215.cjs","sources":["../src/components/chart/chart-rotulos.ts"],"sourcesContent":["// Quebra e truncamento de rótulo de eixo.\n//\n// Diferença importante em relação ao que uma lib de canvas faz: aqui o retorno é\n// um ARRAY de linhas, não uma string com `\\n`. Em SVG cada linha vira um\n// `<tspan dy>` — não existe quebra automática dentro de `<text>`.\n//\n// O problema é real e vem do domínio: nome de município (\"Santa Bárbara do\n// Pará\") e nome de órgão não cabem embaixo de uma barra, e o default de tudo\n// que é lib é sobrepor os rótulos até virar borrão.\n\n/** Marca de corte. Caractere único pra não roubar espaço de 3 letras. */\nconst RETICENCIAS = '…'\n\n/** Corta no limite, com reticências, sem cortar no meio quando dá pra evitar. */\nexport function truncarRotulo(texto: string, maxPorLinha: number): string {\n  const limpo = String(texto ?? '')\n  if (maxPorLinha <= 0) return ''\n  if (limpo.length <= maxPorLinha) return limpo\n  return `${limpo.slice(0, Math.max(0, maxPorLinha - 1)).trimEnd()}${RETICENCIAS}`\n}\n\n/** Fatia uma palavra que sozinha já não cabe na linha (URL, código, matrícula). */\nfunction fatiarPalavra(palavra: string, maxPorLinha: number): string[] {\n  const pedacos: string[] = []\n  for (let i = 0; i < palavra.length; i += maxPorLinha) {\n    pedacos.push(palavra.slice(i, i + maxPorLinha))\n  }\n  return pedacos\n}\n\n/**\n * Quebra por palavra, respeitando um teto de linhas.\n *\n * Estourando `maxLinhas`, a ÚLTIMA linha recebe reticências — o leitor precisa\n * saber que foi cortado. Silenciosamente truncar é pior que não caber.\n */\nexport function quebrarRotulo(texto: string, maxPorLinha = 16, maxLinhas = 2): string[] {\n  const limpo = String(texto ?? '').trim()\n  if (!limpo) return []\n  if (maxPorLinha <= 0 || maxLinhas <= 0) return []\n  if (limpo.length <= maxPorLinha) return [limpo]\n\n  const palavras = limpo.split(/\\s+/)\n  const linhas: string[] = []\n  let atual = ''\n\n  for (const palavra of palavras) {\n    if (palavra.length > maxPorLinha) {\n      if (atual) {\n        linhas.push(atual)\n        atual = ''\n      }\n      const pedacos = fatiarPalavra(palavra, maxPorLinha)\n      linhas.push(...pedacos.slice(0, -1))\n      atual = pedacos[pedacos.length - 1] ?? ''\n      continue\n    }\n\n    const tentativa = atual ? `${atual} ${palavra}` : palavra\n    if (tentativa.length <= maxPorLinha) {\n      atual = tentativa\n    } else {\n      if (atual) linhas.push(atual)\n      atual = palavra\n    }\n  }\n  if (atual) linhas.push(atual)\n\n  if (linhas.length <= maxLinhas) return linhas\n\n  const cortadas = linhas.slice(0, maxLinhas)\n  const ultima = cortadas[maxLinhas - 1] as string\n  cortadas[maxLinhas - 1] = truncarRotulo(`${ultima}${RETICENCIAS}`, maxPorLinha)\n  return cortadas\n}\n"],"names":[],"mappings":";;AAWA,MAAM,cAAc;AAGb,SAAS,cAAc,OAAe,aAA6B;AACxE,QAAM,QAAQ,OAAO,SAAS,EAAE;AAChC,MAAI,eAAe,EAAG,QAAO;AAC7B,MAAI,MAAM,UAAU,YAAa,QAAO;AACxC,SAAO,GAAG,MAAM,MAAM,GAAG,KAAK,IAAI,GAAG,cAAc,CAAC,CAAC,EAAE,QAAA,CAAS,GAAG,WAAW;AAChF;AAGA,SAAS,cAAc,SAAiB,aAA+B;AACrE,QAAM,UAAoB,CAAA;AAC1B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,aAAa;AACpD,YAAQ,KAAK,QAAQ,MAAM,GAAG,IAAI,WAAW,CAAC;AAAA,EAChD;AACA,SAAO;AACT;AAQO,SAAS,cAAc,OAAe,cAAc,IAAI,YAAY,GAAa;AACtF,QAAM,QAAQ,OAAO,SAAS,EAAE,EAAE,KAAA;AAClC,MAAI,CAAC,MAAO,QAAO,CAAA;AACnB,MAAI,eAAe,KAAK,aAAa,UAAU,CAAA;AAC/C,MAAI,MAAM,UAAU,YAAa,QAAO,CAAC,KAAK;AAE9C,QAAM,WAAW,MAAM,MAAM,KAAK;AAClC,QAAM,SAAmB,CAAA;AACzB,MAAI,QAAQ;AAEZ,aAAW,WAAW,UAAU;AAC9B,QAAI,QAAQ,SAAS,aAAa;AAChC,UAAI,OAAO;AACT,eAAO,KAAK,KAAK;AACjB,gBAAQ;AAAA,MACV;AACA,YAAM,UAAU,cAAc,SAAS,WAAW;AAClD,aAAO,KAAK,GAAG,QAAQ,MAAM,GAAG,EAAE,CAAC;AACnC,cAAQ,QAAQ,QAAQ,SAAS,CAAC,KAAK;AACvC;AAAA,IACF;AAEA,UAAM,YAAY,QAAQ,GAAG,KAAK,IAAI,OAAO,KAAK;AAClD,QAAI,UAAU,UAAU,aAAa;AACnC,cAAQ;AAAA,IACV,OAAO;AACL,UAAI,MAAO,QAAO,KAAK,KAAK;AAC5B,cAAQ;AAAA,IACV;AAAA,EACF;AACA,MAAI,MAAO,QAAO,KAAK,KAAK;AAE5B,MAAI,OAAO,UAAU,UAAW,QAAO;AAEvC,QAAM,WAAW,OAAO,MAAM,GAAG,SAAS;AAC1C,QAAM,SAAS,SAAS,YAAY,CAAC;AACrC,WAAS,YAAY,CAAC,IAAI,cAAc,GAAG,MAAM,GAAG,WAAW,IAAI,WAAW;AAC9E,SAAO;AACT;;;"}

package/dist/index215.mjs

@@ -0,0 +1,53 @@
+const RETICENCIAS = "…";
+function truncarRotulo(texto, maxPorLinha) {
+  const limpo = String(texto ?? "");
+  if (maxPorLinha <= 0) return "";
+  if (limpo.length <= maxPorLinha) return limpo;
+  return `${limpo.slice(0, Math.max(0, maxPorLinha - 1)).trimEnd()}${RETICENCIAS}`;
+}
+function fatiarPalavra(palavra, maxPorLinha) {
+  const pedacos = [];
+  for (let i = 0; i < palavra.length; i += maxPorLinha) {
+    pedacos.push(palavra.slice(i, i + maxPorLinha));
+  }
+  return pedacos;
+}
+function quebrarRotulo(texto, maxPorLinha = 16, maxLinhas = 2) {
+  const limpo = String(texto ?? "").trim();
+  if (!limpo) return [];
+  if (maxPorLinha <= 0 || maxLinhas <= 0) return [];
+  if (limpo.length <= maxPorLinha) return [limpo];
+  const palavras = limpo.split(/\s+/);
+  const linhas = [];
+  let atual = "";
+  for (const palavra of palavras) {
+    if (palavra.length > maxPorLinha) {
+      if (atual) {
+        linhas.push(atual);
+        atual = "";
+      }
+      const pedacos = fatiarPalavra(palavra, maxPorLinha);
+      linhas.push(...pedacos.slice(0, -1));
+      atual = pedacos[pedacos.length - 1] ?? "";
+      continue;
+    }
+    const tentativa = atual ? `${atual} ${palavra}` : palavra;
+    if (tentativa.length <= maxPorLinha) {
+      atual = tentativa;
+    } else {
+      if (atual) linhas.push(atual);
+      atual = palavra;
+    }
+  }
+  if (atual) linhas.push(atual);
+  if (linhas.length <= maxLinhas) return linhas;
+  const cortadas = linhas.slice(0, maxLinhas);
+  const ultima = cortadas[maxLinhas - 1];
+  cortadas[maxLinhas - 1] = truncarRotulo(`${ultima}${RETICENCIAS}`, maxPorLinha);
+  return cortadas;
+}
+export {
+  quebrarRotulo,
+  truncarRotulo
+};
+//# sourceMappingURL=index215.mjs.map

package/dist/index215.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index215.mjs","sources":["../src/components/chart/chart-rotulos.ts"],"sourcesContent":["// Quebra e truncamento de rótulo de eixo.\n//\n// Diferença importante em relação ao que uma lib de canvas faz: aqui o retorno é\n// um ARRAY de linhas, não uma string com `\\n`. Em SVG cada linha vira um\n// `<tspan dy>` — não existe quebra automática dentro de `<text>`.\n//\n// O problema é real e vem do domínio: nome de município (\"Santa Bárbara do\n// Pará\") e nome de órgão não cabem embaixo de uma barra, e o default de tudo\n// que é lib é sobrepor os rótulos até virar borrão.\n\n/** Marca de corte. Caractere único pra não roubar espaço de 3 letras. */\nconst RETICENCIAS = '…'\n\n/** Corta no limite, com reticências, sem cortar no meio quando dá pra evitar. */\nexport function truncarRotulo(texto: string, maxPorLinha: number): string {\n  const limpo = String(texto ?? '')\n  if (maxPorLinha <= 0) return ''\n  if (limpo.length <= maxPorLinha) return limpo\n  return `${limpo.slice(0, Math.max(0, maxPorLinha - 1)).trimEnd()}${RETICENCIAS}`\n}\n\n/** Fatia uma palavra que sozinha já não cabe na linha (URL, código, matrícula). */\nfunction fatiarPalavra(palavra: string, maxPorLinha: number): string[] {\n  const pedacos: string[] = []\n  for (let i = 0; i < palavra.length; i += maxPorLinha) {\n    pedacos.push(palavra.slice(i, i + maxPorLinha))\n  }\n  return pedacos\n}\n\n/**\n * Quebra por palavra, respeitando um teto de linhas.\n *\n * Estourando `maxLinhas`, a ÚLTIMA linha recebe reticências — o leitor precisa\n * saber que foi cortado. Silenciosamente truncar é pior que não caber.\n */\nexport function quebrarRotulo(texto: string, maxPorLinha = 16, maxLinhas = 2): string[] {\n  const limpo = String(texto ?? '').trim()\n  if (!limpo) return []\n  if (maxPorLinha <= 0 || maxLinhas <= 0) return []\n  if (limpo.length <= maxPorLinha) return [limpo]\n\n  const palavras = limpo.split(/\\s+/)\n  const linhas: string[] = []\n  let atual = ''\n\n  for (const palavra of palavras) {\n    if (palavra.length > maxPorLinha) {\n      if (atual) {\n        linhas.push(atual)\n        atual = ''\n      }\n      const pedacos = fatiarPalavra(palavra, maxPorLinha)\n      linhas.push(...pedacos.slice(0, -1))\n      atual = pedacos[pedacos.length - 1] ?? ''\n      continue\n    }\n\n    const tentativa = atual ? `${atual} ${palavra}` : palavra\n    if (tentativa.length <= maxPorLinha) {\n      atual = tentativa\n    } else {\n      if (atual) linhas.push(atual)\n      atual = palavra\n    }\n  }\n  if (atual) linhas.push(atual)\n\n  if (linhas.length <= maxLinhas) return linhas\n\n  const cortadas = linhas.slice(0, maxLinhas)\n  const ultima = cortadas[maxLinhas - 1] as string\n  cortadas[maxLinhas - 1] = truncarRotulo(`${ultima}${RETICENCIAS}`, maxPorLinha)\n  return cortadas\n}\n"],"names":[],"mappings":"AAWA,MAAM,cAAc;AAGb,SAAS,cAAc,OAAe,aAA6B;AACxE,QAAM,QAAQ,OAAO,SAAS,EAAE;AAChC,MAAI,eAAe,EAAG,QAAO;AAC7B,MAAI,MAAM,UAAU,YAAa,QAAO;AACxC,SAAO,GAAG,MAAM,MAAM,GAAG,KAAK,IAAI,GAAG,cAAc,CAAC,CAAC,EAAE,QAAA,CAAS,GAAG,WAAW;AAChF;AAGA,SAAS,cAAc,SAAiB,aAA+B;AACrE,QAAM,UAAoB,CAAA;AAC1B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,aAAa;AACpD,YAAQ,KAAK,QAAQ,MAAM,GAAG,IAAI,WAAW,CAAC;AAAA,EAChD;AACA,SAAO;AACT;AAQO,SAAS,cAAc,OAAe,cAAc,IAAI,YAAY,GAAa;AACtF,QAAM,QAAQ,OAAO,SAAS,EAAE,EAAE,KAAA;AAClC,MAAI,CAAC,MAAO,QAAO,CAAA;AACnB,MAAI,eAAe,KAAK,aAAa,UAAU,CAAA;AAC/C,MAAI,MAAM,UAAU,YAAa,QAAO,CAAC,KAAK;AAE9C,QAAM,WAAW,MAAM,MAAM,KAAK;AAClC,QAAM,SAAmB,CAAA;AACzB,MAAI,QAAQ;AAEZ,aAAW,WAAW,UAAU;AAC9B,QAAI,QAAQ,SAAS,aAAa;AAChC,UAAI,OAAO;AACT,eAAO,KAAK,KAAK;AACjB,gBAAQ;AAAA,MACV;AACA,YAAM,UAAU,cAAc,SAAS,WAAW;AAClD,aAAO,KAAK,GAAG,QAAQ,MAAM,GAAG,EAAE,CAAC;AACnC,cAAQ,QAAQ,QAAQ,SAAS,CAAC,KAAK;AACvC;AAAA,IACF;AAEA,UAAM,YAAY,QAAQ,GAAG,KAAK,IAAI,OAAO,KAAK;AAClD,QAAI,UAAU,UAAU,aAAa;AACnC,cAAQ;AAAA,IACV,OAAO;AACL,UAAI,MAAO,QAAO,KAAK,KAAK;AAC5B,cAAQ;AAAA,IACV;AAAA,EACF;AACA,MAAI,MAAO,QAAO,KAAK,KAAK;AAE5B,MAAI,OAAO,UAAU,UAAW,QAAO;AAEvC,QAAM,WAAW,OAAO,MAAM,GAAG,SAAS;AAC1C,QAAM,SAAS,SAAS,YAAY,CAAC;AACrC,WAAS,YAAY,CAAC,IAAI,cAAc,GAAG,MAAM,GAAG,WAAW,IAAI,WAAW;AAC9E,SAAO;AACT;"}

package/dist/index216.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DOMINIO_VAZIO = { min: 0, max: 1, ticks: [0, 0.25, 0.5, 0.75, 1] };
+function passoBonito(bruto, paraCima = false) {
+  if (!Number.isFinite(bruto) || bruto <= 0) return 1;
+  const expoente = Math.floor(Math.log10(bruto));
+  const fracao = bruto / Math.pow(10, expoente);
+  let bonita;
+  if (paraCima) {
+    if (fracao < 1.5) bonita = 1;
+    else if (fracao < 3) bonita = 2;
+    else if (fracao < 7) bonita = 5;
+    else bonita = 10;
+  } else {
+    if (fracao <= 1) bonita = 1;
+    else if (fracao <= 2) bonita = 2;
+    else if (fracao <= 5) bonita = 5;
+    else bonita = 10;
+  }
+  return bonita * Math.pow(10, expoente);
+}
+function dominioBonito(min, max, opcoes = {}) {
+  const alvo = Math.max(2, Math.floor(opcoes.alvo ?? 5));
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    return { ...DOMINIO_VAZIO, ticks: [...DOMINIO_VAZIO.ticks] };
+  }
+  let baixo = Math.min(min, max);
+  let alto = Math.max(min, max);
+  if (opcoes.incluirZero) {
+    baixo = Math.min(baixo, 0);
+    alto = Math.max(alto, 0);
+  }
+  if (baixo === alto) {
+    if (baixo === 0) return { min: 0, max: 1, ticks: [0, 0.25, 0.5, 0.75, 1] };
+    const folga = Math.abs(baixo) * 0.5;
+    baixo -= folga;
+    alto += folga;
+  }
+  const amplitude = passoBonito(alto - baixo, false);
+  const passo = passoBonito(amplitude / (alvo - 1), true);
+  const inicio = Math.floor(baixo / passo) * passo;
+  const fim = Math.ceil(alto / passo) * passo;
+  const casas = Math.max(0, Math.min(10, -Math.floor(Math.log10(passo)))) + 1;
+  const quantidade = Math.round((fim - inicio) / passo);
+  const ticks = [];
+  for (let i = 0; i <= quantidade; i++) {
+    ticks.push(Number((inicio + i * passo).toFixed(casas)));
+  }
+  return { min: inicio, max: fim, ticks };
+}
+exports.dominioBonito = dominioBonito;
+exports.passoBonito = passoBonito;
+//# sourceMappingURL=index216.cjs.map