acai-ui 1.65.5

package/dist/index4.mjs

@@ -0,0 +1,613 @@
+import { defineComponent, useId, ref, computed, openBlock, createElementBlock, toDisplayString, createCommentVNode, createBlock, createElementVNode, normalizeClass, normalizeStyle, createVNode, unref, renderSlot, Fragment, renderList, createTextVNode } from "vue";
+import { QSpinner, QIcon } from "quasar";
+import ChartCartesiano from "./index191.mjs";
+import ChartGauge from "./index192.mjs";
+import ChartPizza from "./index193.mjs";
+import ChartLegenda from "./index194.mjs";
+import ChartTabela from "./index195.mjs";
+import { resumoGrafico, tabelaDeDados, anuncioPonto } from "./index196.mjs";
+import { normalizarEntrada, limitarCategorias, resolverCor } from "./index197.mjs";
+import { resolverFormatador } from "./index198.mjs";
+import { montarPlanoPizza, montarPlanoGauge, montarPlanoCartesiano } from "./index199.mjs";
+import { svgChartParaImagem } from "./index94.mjs";
+import { useTamanhoElemento } from "./index99.mjs";
+import { usePreferencias } from "./index98.mjs";
+import { alturaAutomatica } from "./index200.mjs";
+const _hoisted_1 = ["aria-labelledby"];
+const _hoisted_2 = {
+  key: 0,
+  class: "acai-chart__estado",
+  role: "status",
+  "aria-label": "Carregando gráfico"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "acai-chart__estado acai-chart__estado--vazio"
+};
+const _hoisted_4 = ["width", "height", "viewBox", "aria-labelledby"];
+const _hoisted_5 = { key: 0 };
+const _hoisted_6 = ["id", "patternTransform"];
+const _hoisted_7 = ["width", "height"];
+const _hoisted_8 = {
+  class: "acai-chart__vivo",
+  "aria-live": "polite",
+  "aria-atomic": "true"
+};
+const _hoisted_9 = {
+  key: 2,
+  class: "acai-chart__acoes"
+};
+const _hoisted_10 = ["aria-expanded"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "acai-ui-chart",
+  props: {
+    type: { default: "bar" },
+    labels: {},
+    series: {},
+    data: {},
+    title: {},
+    description: {},
+    valueLabel: {},
+    categoryLabel: {},
+    height: { default: 320 },
+    horizontal: { type: Boolean },
+    autoHeight: { type: Boolean },
+    stacked: { type: [Boolean, String] },
+    innerRadius: {},
+    curve: { default: "linear" },
+    gauge: {},
+    valueFormat: {},
+    valueDecimals: {},
+    labelFormat: {},
+    min: {},
+    max: {},
+    includeZero: { type: Boolean },
+    ticks: {},
+    palette: {},
+    colorBy: {},
+    thresholds: {},
+    showGrid: { type: Boolean, default: true },
+    showLegend: { type: [Boolean, String], default: "auto" },
+    legendPosition: { default: "bottom" },
+    showValues: { type: [Boolean, String], default: "auto" },
+    showTooltip: { type: Boolean, default: true },
+    maxCategories: {},
+    otherLabel: { default: "Outros" },
+    loading: { type: Boolean },
+    empty: { default: "Sem dados para exibir." },
+    emptyIcon: { default: "bar_chart" },
+    dataTable: { type: [String, Boolean], default: "hidden" },
+    tableToggle: { type: Boolean, default: true },
+    patterns: { type: [Boolean, String], default: "auto" }
+  },
+  emits: ["point-click", "point-focus", "legend-toggle"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const idBase = useId();
+    const idTitulo = `${idBase}-t`;
+    const idDesc = `${idBase}-d`;
+    const idTabela = `${idBase}-tab`;
+    const PADROES = [
+      { indice: 0, angulo: 45 },
+      { indice: 1, angulo: 135 },
+      { indice: 2, angulo: 0 },
+      { indice: 3, angulo: 90 },
+      { indice: 4, angulo: 20 }
+    ];
+    const caixaRef = ref(null);
+    const svgRef = ref(null);
+    const { preferencias } = usePreferencias();
+    const ocultasLocal = ref(/* @__PURE__ */ new Set());
+    const focado = ref(null);
+    const focoVisivel = ref(false);
+    const tabelaAberta = ref(props.dataTable === "visible");
+    const anuncio = ref("");
+    const ponteiro = ref(null);
+    const horizontal = computed(() => props.horizontal === true);
+    const dados = computed(() => {
+      var _a;
+      const bruto = normalizarEntrada({
+        ...props,
+        series: (_a = props.series) == null ? void 0 : _a.map((s, i) => ({
+          ...s,
+          hidden: s.hidden === true || ocultasLocal.value.has(i)
+        }))
+      });
+      const teto = props.maxCategories ?? (props.type === "pie" || props.type === "donut" ? 6 : 12);
+      return limitarCategorias(bruto, teto, props.otherLabel);
+    });
+    const amostra = computed(
+      () => dados.value.series.flatMap((s) => s.pontos.map((p) => p.valor).filter((v) => v !== null))
+    );
+    const formatar = computed(
+      () => resolverFormatador(props.valueFormat, props.valueDecimals, amostra.value)
+    );
+    const seriesVisiveis = computed(() => dados.value.series.filter((s) => !s.oculta));
+    const alturaBase = computed(() => {
+      if (props.autoHeight) return alturaAutomatica(dados.value.rotulos.length);
+      return typeof props.height === "number" ? props.height : 320;
+    });
+    const { largura, altura: alturaMedida, remedir } = useTamanhoElemento(caixaRef, {
+      largura: 640,
+      altura: 320
+    });
+    const alturaSvg = computed(() => props.autoHeight ? alturaBase.value : alturaMedida.value);
+    const estiloArea = computed(() => ({
+      height: props.autoHeight ? `${alturaBase.value}px` : typeof props.height === "number" ? `${props.height}px` : props.height
+    }));
+    const mostrarLegenda = computed(() => {
+      if (props.showLegend !== "auto") return props.showLegend === true;
+      if (ehMedidor.value) return false;
+      return ehCircular.value || dados.value.series.length > 1;
+    });
+    const compacto = computed(() => {
+      if (ehMedidor.value) return planoGauge.value.compacto;
+      return ehCircular.value ? planoPizza.value.compacto : plano.value.compacto;
+    });
+    const legendaLateral = computed(
+      () => mostrarLegenda.value && props.legendPosition === "right" && !compacto.value
+    );
+    const itensLegenda = computed(() => {
+      if (!ehCircular.value) return dados.value.series;
+      const serie = dados.value.series[0];
+      if (!serie) return [];
+      return serie.pontos.map((ponto, i) => ({
+        ...serie,
+        indice: i,
+        nome: ponto.rotulo,
+        tipo: "bar",
+        cor: resolverCor(ponto, serie, colorByEfetivo.value, props.thresholds ?? []),
+        oculta: false
+      }));
+    });
+    const mostrarValores = computed(() => {
+      if (props.showValues !== "auto") return props.showValues === true;
+      return dados.value.rotulos.length * seriesVisiveis.value.length <= 12;
+    });
+    const padroesAtivos = computed(() => {
+      if (props.patterns === true) return true;
+      if (props.patterns === false) return false;
+      return preferencias.daltonismo === "acromatopsia" || preferencias.altoContraste;
+    });
+    const ehCircular = computed(() => props.type === "pie" || props.type === "donut");
+    const ehMedidor = computed(() => props.type === "gauge");
+    const dominioMedidor = computed(() => ({
+      min: props.min ?? 0,
+      max: props.max ?? 100
+    }));
+    const colorByEfetivo = computed(() => {
+      var _a;
+      if (props.colorBy) return props.colorBy;
+      if (ehMedidor.value) return (((_a = props.thresholds) == null ? void 0 : _a.length) ?? 0) > 0 ? "threshold" : "series";
+      return ehCircular.value ? "point" : "series";
+    });
+    const planoPizza = computed(
+      () => montarPlanoPizza({
+        dados: dados.value,
+        largura: largura.value,
+        altura: alturaSvg.value,
+        formatar: formatar.value,
+        // Rosca sem `innerRadius` explícito usa 0.6: furo menor que isso vira uma
+        // pizza com um pontinho no meio, sem a legibilidade que a rosca traz.
+        raioInterno: props.innerRadius ?? (props.type === "donut" ? 0.6 : 0),
+        colorBy: colorByEfetivo.value,
+        thresholds: props.thresholds ?? []
+      })
+    );
+    const planoGauge = computed(
+      () => {
+        var _a, _b, _c, _d, _e, _f;
+        return montarPlanoGauge({
+          dados: dados.value,
+          largura: largura.value,
+          altura: alturaSvg.value,
+          formatar: formatar.value,
+          min: dominioMedidor.value.min,
+          max: dominioMedidor.value.max,
+          ...((_a = props.gauge) == null ? void 0 : _a.startAngle) === void 0 ? {} : { anguloInicio: props.gauge.startAngle },
+          ...((_b = props.gauge) == null ? void 0 : _b.endAngle) === void 0 ? {} : { anguloFim: props.gauge.endAngle },
+          ...((_c = props.gauge) == null ? void 0 : _c.thickness) === void 0 ? {} : { espessura: props.gauge.thickness },
+          ponteiro: ((_d = props.gauge) == null ? void 0 : _d.pointer) === true,
+          bandas: ((_e = props.gauge) == null ? void 0 : _e.bands) === true,
+          legenda: ((_f = props.gauge) == null ? void 0 : _f.caption) ?? "",
+          colorBy: colorByEfetivo.value,
+          thresholds: props.thresholds ?? []
+        });
+      }
+    );
+    const plano = computed(
+      () => montarPlanoCartesiano({
+        dados: dados.value,
+        largura: largura.value,
+        altura: alturaSvg.value,
+        formatar: formatar.value,
+        horizontal: horizontal.value,
+        empilhado: props.stacked === true || props.stacked === "percent",
+        percentual: props.stacked === "percent",
+        curva: props.curve,
+        ...props.includeZero === void 0 ? {} : { incluirZero: props.includeZero },
+        min: props.min,
+        max: props.max,
+        ...props.ticks === void 0 ? {} : { ticksAlvo: props.ticks },
+        colorBy: colorByEfetivo.value,
+        thresholds: props.thresholds ?? [],
+        mostrarValores: mostrarValores.value,
+        temTitulo: false,
+        temLegenda: false,
+        ...props.legendPosition ? { posicaoLegenda: props.legendPosition } : {}
+      })
+    );
+    const descricaoFinal = computed(
+      () => props.description ?? resumoGrafico(dados.value, {
+        tipo: props.type,
+        titulo: props.title,
+        formatar: formatar.value,
+        ...ehMedidor.value ? { medidor: dominioMedidor.value } : {}
+      })
+    );
+    const tabela = computed(
+      () => tabelaDeDados(dados.value, formatar.value, props.categoryLabel ?? "Categoria")
+    );
+    const legendaTabela = computed(
+      () => props.title ? `${props.title} — dados do gráfico` : "Dados do gráfico"
+    );
+    function alternarSerie(indice) {
+      if (ehCircular.value) return;
+      const proximo = new Set(ocultasLocal.value);
+      if (proximo.has(indice)) proximo.delete(indice);
+      else proximo.add(indice);
+      ocultasLocal.value = proximo;
+      emit("legend-toggle", { seriesIndex: indice, hidden: proximo.has(indice) });
+    }
+    function eventoDoPonto(indiceSerie, indicePonto) {
+      const serie = dados.value.series[indiceSerie];
+      const ponto = serie == null ? void 0 : serie.pontos[indicePonto];
+      if (!serie || !ponto) return null;
+      return {
+        seriesIndex: indiceSerie,
+        seriesName: serie.nome,
+        index: indicePonto,
+        label: ponto.rotulo,
+        value: ponto.valor,
+        formatted: ponto.valor === null ? "—" : formatar.value(ponto.valor),
+        meta: ponto.meta
+      };
+    }
+    function mover(deltaPonto, deltaSerie, indicePontoAbsoluto) {
+      const nPontos = dados.value.rotulos.length;
+      const visiveis = seriesVisiveis.value;
+      if (nPontos === 0 || visiveis.length === 0) return;
+      const atual = focado.value ?? { indiceSerie: visiveis[0].indice, indicePonto: -1 };
+      const ordemAtual = Math.max(
+        0,
+        visiveis.findIndex((s) => s.indice === atual.indiceSerie)
+      );
+      const alvoPonto = indicePontoAbsoluto ?? atual.indicePonto + deltaPonto;
+      const proximoPonto = Math.min(nPontos - 1, Math.max(0, alvoPonto));
+      const proximaOrdem = Math.min(visiveis.length - 1, Math.max(0, ordemAtual + deltaSerie));
+      focado.value = {
+        indiceSerie: visiveis[proximaOrdem].indice,
+        indicePonto: proximoPonto
+      };
+      anuncio.value = anuncioPonto(
+        dados.value,
+        focado.value.indiceSerie,
+        focado.value.indicePonto,
+        formatar.value
+      );
+      const evento = eventoDoPonto(focado.value.indiceSerie, focado.value.indicePonto);
+      if (evento) emit("point-focus", evento);
+    }
+    function aoTeclar(e) {
+      const nPontos = dados.value.rotulos.length;
+      switch (e.key) {
+        case "ArrowRight":
+          mover(1, 0);
+          break;
+        case "ArrowLeft":
+          mover(-1, 0);
+          break;
+        case "ArrowDown":
+          mover(0, 1);
+          break;
+        case "ArrowUp":
+          mover(0, -1);
+          break;
+        case "Home":
+          mover(0, 0, 0);
+          break;
+        case "End":
+          mover(0, 0, nPontos - 1);
+          break;
+        case "Enter":
+        case " ": {
+          if (!focado.value) return;
+          const evento = eventoDoPonto(focado.value.indiceSerie, focado.value.indicePonto);
+          if (evento) emit("point-click", evento);
+          break;
+        }
+        case "Escape":
+          focado.value = null;
+          anuncio.value = "";
+          break;
+        case "t":
+        case "T":
+          tabelaAberta.value = !tabelaAberta.value;
+          break;
+        default:
+          return;
+      }
+      focoVisivel.value = true;
+      e.preventDefault();
+    }
+    function aoMoverPonteiro(e) {
+      var _a;
+      if (!props.showTooltip || dados.value.vazio) return;
+      const caixa = (_a = svgRef.value) == null ? void 0 : _a.getBoundingClientRect();
+      if (!caixa) return;
+      const x = e.clientX - caixa.left;
+      const y = e.clientY - caixa.top;
+      ponteiro.value = { x, y };
+      const indice = indiceSobCursor(x, y);
+      if (indice === null) return;
+      const serie = seriesVisiveis.value[0];
+      if (!serie) return;
+      focado.value = { indiceSerie: serie.indice, indicePonto: indice };
+      focoVisivel.value = false;
+    }
+    function indiceSobCursor(x, y) {
+      if (ehMedidor.value) return null;
+      if (ehCircular.value) {
+        const p = planoPizza.value;
+        const dx = x - p.cx;
+        const dy = y - p.cy;
+        const raio = Math.hypot(dx, dy);
+        if (raio > p.raioExterno || raio < p.raioInterno) return null;
+        let angulo = Math.atan2(dy, dx) * 180 / Math.PI;
+        const fatia = p.fatias.find((f) => {
+          let a = angulo;
+          while (a < f.anguloInicioBruto) a += 360;
+          while (a >= f.anguloInicioBruto + 360) a -= 360;
+          return a <= f.anguloFimBruto;
+        });
+        return fatia ? fatia.indicePonto : null;
+      }
+      const cats = plano.value.categorias;
+      if (cats.length === 0) return null;
+      const coordenada = horizontal.value ? y : x;
+      let melhor = 0;
+      let menorDistancia = Infinity;
+      cats.forEach((cat, i) => {
+        const d = Math.abs(cat.centro - coordenada);
+        if (d < menorDistancia) {
+          menorDistancia = d;
+          melhor = i;
+        }
+      });
+      return melhor;
+    }
+    function aoSairPonteiro() {
+      ponteiro.value = null;
+      if (!focoVisivel.value) focado.value = null;
+    }
+    function aoClicar() {
+      if (!focado.value) return;
+      const evento = eventoDoPonto(focado.value.indiceSerie, focado.value.indicePonto);
+      if (evento) emit("point-click", evento);
+    }
+    const tooltipVisivel = computed(
+      () => props.showTooltip && !ehMedidor.value && focado.value !== null && !dados.value.vazio
+    );
+    const rotuloDoFoco = computed(
+      () => focado.value ? dados.value.rotulos[focado.value.indicePonto] ?? "" : ""
+    );
+    const pontosDoFoco = computed(() => {
+      if (!focado.value) return [];
+      const i = focado.value.indicePonto;
+      return seriesVisiveis.value.map((serie) => {
+        const ponto = serie.pontos[i];
+        if (!ponto) return null;
+        return {
+          seriesIndex: serie.indice,
+          seriesName: serie.nome,
+          formatted: ponto.valor === null ? "—" : formatar.value(ponto.valor),
+          cor: resolverCor(ponto, serie, colorByEfetivo.value, props.thresholds ?? [])
+        };
+      }).filter((p) => p !== null);
+    });
+    const estiloTooltip = computed(() => {
+      if (ponteiro.value) {
+        return { left: `${ponteiro.value.x}px`, top: `${ponteiro.value.y}px` };
+      }
+      if (ehCircular.value) {
+        const fatia = focado.value ? planoPizza.value.fatias.find((f) => {
+          var _a;
+          return f.indicePonto === ((_a = focado.value) == null ? void 0 : _a.indicePonto);
+        }) : null;
+        return { left: `${(fatia == null ? void 0 : fatia.rotuloX) ?? planoPizza.value.cx}px`, top: `${(fatia == null ? void 0 : fatia.rotuloY) ?? planoPizza.value.cy}px` };
+      }
+      const cat = focado.value ? plano.value.categorias[focado.value.indicePonto] : null;
+      return { left: `${(cat == null ? void 0 : cat.centro) ?? 0}px`, top: `${plano.value.area.y}px` };
+    });
+    async function exportarImagem(opcoes = {}) {
+      const svg = svgRef.value;
+      if (!svg) {
+        throw new Error(
+          "acai-ui-chart: nada desenhado para exportar (gráfico carregando ou sem dados)."
+        );
+      }
+      return svgChartParaImagem(svg, opcoes);
+    }
+    __expose({ remedir, exportarImagem });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("figure", {
+        class: "acai-chart",
+        role: "group",
+        "aria-labelledby": __props.title ? idTitulo : void 0
+      }, [
+        __props.title ? (openBlock(), createElementBlock("figcaption", {
+          key: 0,
+          id: idTitulo,
+          class: "acai-chart__titulo"
+        }, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+        mostrarLegenda.value && __props.legendPosition === "bottom" ? (openBlock(), createBlock(ChartLegenda, {
+          key: 1,
+          class: "acai-chart__legenda",
+          series: itensLegenda.value,
+          posicao: "bottom",
+          onToggle: alternarSerie
+        }, null, 8, ["series"])) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: normalizeClass(["acai-chart__corpo", { "acai-chart__corpo--lateral": legendaLateral.value }])
+        }, [
+          createElementVNode("div", {
+            ref_key: "caixaRef",
+            ref: caixaRef,
+            class: "acai-chart__area",
+            style: normalizeStyle(estiloArea.value)
+          }, [
+            __props.loading ? (openBlock(), createElementBlock("div", _hoisted_2, [
+              createVNode(unref(QSpinner), { size: "28px" })
+            ])) : dados.value.vazio ? (openBlock(), createElementBlock("div", _hoisted_3, [
+              renderSlot(_ctx.$slots, "empty", {}, () => [
+                createVNode(unref(QIcon), {
+                  name: __props.emptyIcon,
+                  size: "32px"
+                }, null, 8, ["name"]),
+                createElementVNode("span", null, toDisplayString(__props.empty), 1)
+              ])
+            ])) : (openBlock(), createElementBlock("svg", {
+              key: 2,
+              ref_key: "svgRef",
+              ref: svgRef,
+              class: "acai-chart__svg",
+              width: unref(largura),
+              height: alturaSvg.value,
+              viewBox: `0 0 ${unref(largura)} ${alturaSvg.value}`,
+              role: "img",
+              tabindex: "0",
+              "aria-labelledby": `${idTitulo} ${idDesc}`,
+              onKeydown: aoTeclar,
+              onBlur: _cache[0] || (_cache[0] = ($event) => focado.value = null),
+              onPointerleave: aoSairPonteiro,
+              onPointermove: aoMoverPonteiro,
+              onClick: aoClicar
+            }, [
+              createElementVNode("title", { id: idTitulo }, toDisplayString(__props.title || "Gráfico"), 1),
+              createElementVNode("desc", { id: idDesc }, toDisplayString(descricaoFinal.value), 1),
+              padroesAtivos.value ? (openBlock(), createElementBlock("defs", _hoisted_5, [
+                (openBlock(), createElementBlock(Fragment, null, renderList(PADROES, (p) => {
+                  return createElementVNode("pattern", {
+                    key: p.indice,
+                    id: `${unref(idBase)}-p${p.indice}`,
+                    width: "6",
+                    height: "6",
+                    patternUnits: "userSpaceOnUse",
+                    patternTransform: `rotate(${p.angulo})`
+                  }, [..._cache[2] || (_cache[2] = [
+                    createElementVNode("line", {
+                      x1: "0",
+                      y1: "0",
+                      x2: "0",
+                      y2: "6",
+                      stroke: "var(--acai-chart-surface)",
+                      "stroke-width": "2.5",
+                      opacity: "0.85"
+                    }, null, -1)
+                  ])], 8, _hoisted_6);
+                }), 64))
+              ])) : createCommentVNode("", true),
+              ehMedidor.value ? (openBlock(), createBlock(ChartGauge, {
+                key: 1,
+                plano: planoGauge.value
+              }, null, 8, ["plano"])) : ehCircular.value ? (openBlock(), createBlock(ChartPizza, {
+                key: 2,
+                plano: planoPizza.value,
+                padroes: padroesAtivos.value,
+                "id-padrao": unref(idBase),
+                focado: focado.value,
+                atenuar: focoVisivel.value
+              }, null, 8, ["plano", "padroes", "id-padrao", "focado", "atenuar"])) : (openBlock(), createBlock(ChartCartesiano, {
+                key: 3,
+                plano: plano.value,
+                "mostrar-grade": __props.showGrid,
+                padroes: padroesAtivos.value,
+                "id-padrao": unref(idBase),
+                focado: focado.value,
+                atenuar: focoVisivel.value
+              }, null, 8, ["plano", "mostrar-grade", "padroes", "id-padrao", "focado", "atenuar"])),
+              focoVisivel.value ? (openBlock(), createElementBlock("rect", {
+                key: 4,
+                class: "acai-chart__foco",
+                x: "1",
+                y: "1",
+                width: unref(largura) - 2,
+                height: alturaSvg.value - 2,
+                rx: "4"
+              }, null, 8, _hoisted_7)) : createCommentVNode("", true)
+            ], 40, _hoisted_4)),
+            tooltipVisivel.value ? (openBlock(), createElementBlock("div", {
+              key: 3,
+              class: "acai-chart__tooltip",
+              style: normalizeStyle(estiloTooltip.value),
+              role: "tooltip"
+            }, [
+              renderSlot(_ctx.$slots, "tooltip", {
+                pontos: pontosDoFoco.value,
+                label: rotuloDoFoco.value
+              }, () => [
+                createElementVNode("strong", null, toDisplayString(rotuloDoFoco.value), 1),
+                (openBlock(true), createElementBlock(Fragment, null, renderList(pontosDoFoco.value, (p) => {
+                  return openBlock(), createElementBlock("span", {
+                    key: p.seriesIndex,
+                    class: "acai-chart__tooltip-linha"
+                  }, [
+                    createElementVNode("i", {
+                      class: "acai-chart__tooltip-cor",
+                      style: normalizeStyle({ background: p.cor })
+                    }, null, 4),
+                    dados.value.series.length > 1 ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+                      createTextVNode(toDisplayString(p.seriesName) + ":", 1)
+                    ], 64)) : createCommentVNode("", true),
+                    createTextVNode(" " + toDisplayString(p.formatted), 1)
+                  ]);
+                }), 128))
+              ])
+            ], 4)) : createCommentVNode("", true)
+          ], 4),
+          mostrarLegenda.value && legendaLateral.value ? (openBlock(), createBlock(ChartLegenda, {
+            key: 0,
+            class: "acai-chart__legenda acai-chart__legenda--lateral",
+            series: itensLegenda.value,
+            posicao: "right",
+            onToggle: alternarSerie
+          }, null, 8, ["series"])) : createCommentVNode("", true)
+        ], 2),
+        createElementVNode("div", _hoisted_8, toDisplayString(anuncio.value), 1),
+        __props.tableToggle && !dados.value.vazio ? (openBlock(), createElementBlock("div", _hoisted_9, [
+          createElementVNode("button", {
+            type: "button",
+            class: "acai-chart__botao-tabela",
+            "aria-expanded": tabelaAberta.value,
+            "aria-controls": idTabela,
+            onClick: _cache[1] || (_cache[1] = ($event) => tabelaAberta.value = !tabelaAberta.value)
+          }, toDisplayString(tabelaAberta.value ? "Ocultar dados" : "Ver dados em tabela"), 9, _hoisted_10)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", { id: idTabela }, [
+          __props.dataTable !== false && !dados.value.vazio ? (openBlock(), createBlock(ChartTabela, {
+            key: 0,
+            tabela: tabela.value,
+            legenda: legendaTabela.value,
+            visivel: tabelaAberta.value || __props.dataTable === "visible"
+          }, null, 8, ["tabela", "legenda", "visivel"])) : createCommentVNode("", true)
+        ]),
+        renderSlot(_ctx.$slots, "footer")
+      ], 8, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=index4.mjs.map

package/dist/index4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index4.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}