acai-ui 1.65.5

package/dist/index17.mjs

@@ -0,0 +1,420 @@
+import { QTree, QMenu, QList, QItem, QItemSection, ClosePopup, copyToClipboard } from "quasar";
+import { defineComponent, ref, computed, watch, nextTick, onMounted, onUnmounted, openBlock, createElementBlock, createVNode, Transition, withCtx, normalizeClass, withDirectives, createElementVNode, withKeys, withModifiers, vModelText, toDisplayString, createCommentVNode, createBlock, createTextVNode } from "vue";
+import _sfc_main$1 from "./index23.mjs";
+import { notificacao } from "./index91.mjs";
+const _hoisted_1 = { class: "log-container" };
+const _hoisted_2 = ["onKeydown"];
+const _hoisted_3 = {
+  key: 0,
+  class: "log-filter__info"
+};
+const _hoisted_4 = {
+  key: 1,
+  class: "log-filter__nav"
+};
+const _hoisted_5 = ["data-node-id"];
+const _hoisted_6 = ["innerHTML"];
+const _hoisted_7 = ["innerHTML"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "acai-ui-error-log-json-tree",
+  props: {
+    value: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const expandidos = ref([]);
+    const ehObjetoPlano = (valor) => typeof valor === "object" && valor !== null && !Array.isArray(valor) && !(valor instanceof Date);
+    const formatarPrimitivo = (valor) => {
+      if (typeof valor === "string") return JSON.stringify(valor);
+      if (typeof valor === "number" || typeof valor === "boolean")
+        return String(valor);
+      if (valor === null) return "null";
+      if (valor === void 0) return "undefined";
+      if (valor instanceof Date) return valor.toISOString();
+      return String(valor);
+    };
+    const truncar = (texto, limite = 80) => texto.length <= limite ? texto : `${texto.slice(0, limite - 3)}...`;
+    const extrairResumo = (key, valor) => {
+      if (key === "message" && typeof valor === "string") return truncar(valor);
+      if (key === "name" && typeof valor === "string") return truncar(valor);
+      if (key === "config" && ehObjetoPlano(valor)) {
+        const method = String(valor.method ?? "").toUpperCase();
+        const url = String(valor.url ?? "");
+        const baseURL = String(valor.baseURL ?? "");
+        const destino = baseURL && url ? `${baseURL}${url}` : url || baseURL;
+        return [method, destino].filter(Boolean).join(" ") || "Object";
+      }
+      if (key === "response" && ehObjetoPlano(valor)) {
+        const status = valor.status ?? "";
+        const data = ehObjetoPlano(valor.data) ? valor.data : null;
+        const message = data && typeof data.message === "string" ? truncar(data.message) : "";
+        const tipo = data && typeof data.tipo === "string" ? data.tipo : "";
+        return [status ? `status ${status}` : "", message, tipo].filter(Boolean).join(" | ") || "Object";
+      }
+      if (key === "data" && ehObjetoPlano(valor)) {
+        const message = typeof valor.message === "string" ? truncar(valor.message) : "";
+        const tipo = typeof valor.tipo === "string" ? valor.tipo : "";
+        return [message, tipo].filter(Boolean).join(" | ") || "Object";
+      }
+      return null;
+    };
+    const formatarResumo = (key, valor) => {
+      const resumoCustom = extrairResumo(key, valor);
+      if (resumoCustom) return { display: resumoCustom, valueType: typeof valor };
+      if (Array.isArray(valor))
+        return { display: `Array(${valor.length})`, valueType: "array" };
+      if (ehObjetoPlano(valor))
+        return {
+          display: `Object(${Object.keys(valor).length})`,
+          valueType: "object"
+        };
+      if (valor === null) return { display: "null", valueType: "null" };
+      if (valor === void 0)
+        return { display: "undefined", valueType: "undefined" };
+      return { display: formatarPrimitivo(valor), valueType: typeof valor };
+    };
+    const montarNo = (key, valor, caminho) => {
+      if (Array.isArray(valor)) {
+        const children = valor.map(
+          (item, index) => montarNo(`[${index}]`, item, `${caminho}[${index}]`)
+        );
+        const resumo2 = formatarResumo(key, valor);
+        return {
+          id: caminho,
+          key,
+          display: resumo2.display,
+          valueType: resumo2.valueType,
+          rawValue: valor,
+          children
+        };
+      }
+      if (ehObjetoPlano(valor)) {
+        const children = Object.entries(valor).map(
+          ([k, v]) => montarNo(k, v, `${caminho}.${k}`)
+        );
+        const resumo2 = formatarResumo(key, valor);
+        return {
+          id: caminho,
+          key,
+          display: resumo2.display,
+          valueType: resumo2.valueType,
+          rawValue: valor,
+          children
+        };
+      }
+      const resumo = formatarResumo(key, valor);
+      return {
+        id: caminho,
+        key,
+        display: resumo.display,
+        valueType: resumo.valueType,
+        rawValue: valor
+      };
+    };
+    const nos = computed(() => {
+      const valor = props.value;
+      if (ehObjetoPlano(valor))
+        return Object.entries(valor).map(([k, v]) => montarNo(k, v, k));
+      if (Array.isArray(valor))
+        return valor.map((item, i) => montarNo(`[${i}]`, item, `[${i}]`));
+      return [montarNo("valor", valor, "valor")];
+    });
+    const montarExpansaoAutomatica = (valor) => {
+      if (!ehObjetoPlano(valor)) return [];
+      const responseData = ehObjetoPlano(valor.response) ? valor.response.data : void 0;
+      const chavesExpandidas = ["response"];
+      if (ehObjetoPlano(responseData)) {
+        chavesExpandidas.push("response.data");
+        if (Array.isArray(responseData.campos))
+          chavesExpandidas.push("response.data.campos");
+        if (responseData.informacao)
+          chavesExpandidas.push("response.data.informacao");
+      }
+      return chavesExpandidas;
+    };
+    watch(
+      () => props.value,
+      (valor) => {
+        expandidos.value = montarExpansaoAutomatica(valor);
+      },
+      { immediate: true }
+    );
+    const filtroVisivel = ref(false);
+    const termoBusca = ref("");
+    const matchAtual = ref(0);
+    const filtroInputRef = ref(null);
+    const coletarMatches = (lista, termo) => {
+      const resultado = [];
+      const baixo = termo.toLowerCase();
+      const varrer = (nodes) => {
+        for (const no of nodes) {
+          if (no.key.toLowerCase().includes(baixo))
+            resultado.push({ nodeId: no.id, field: "key" });
+          if (no.display.toLowerCase().includes(baixo))
+            resultado.push({ nodeId: no.id, field: "display" });
+          if (no.children) varrer(no.children);
+        }
+      };
+      varrer(lista);
+      return resultado;
+    };
+    const todasMatches = computed(() => {
+      if (!termoBusca.value) return [];
+      return coletarMatches(nos.value, termoBusca.value);
+    });
+    const totalMatches = computed(() => todasMatches.value.length);
+    const obterIdsAncestral = (id) => {
+      const ancestrais = [];
+      let atual = id;
+      while (true) {
+        const pos = Math.max(atual.lastIndexOf("."), atual.lastIndexOf("["));
+        if (pos <= 0) break;
+        atual = atual.slice(0, pos);
+        ancestrais.push(atual);
+      }
+      return ancestrais;
+    };
+    async function scrollParaMatch(index) {
+      const match = todasMatches.value[index];
+      if (!match) return;
+      const ancestrais = obterIdsAncestral(match.nodeId);
+      expandidos.value = [.../* @__PURE__ */ new Set([...expandidos.value, ...ancestrais])];
+      await nextTick();
+      const el = document.querySelector(
+        `[data-node-id="${CSS.escape(match.nodeId)}"]`
+      );
+      el == null ? void 0 : el.scrollIntoView({ block: "center", behavior: "smooth" });
+    }
+    watch(termoBusca, async (novo) => {
+      matchAtual.value = 0;
+      if (novo) {
+        const idsParaExpandir = /* @__PURE__ */ new Set();
+        for (const match of todasMatches.value) {
+          for (const id of obterIdsAncestral(match.nodeId)) idsParaExpandir.add(id);
+        }
+        expandidos.value = [.../* @__PURE__ */ new Set([...expandidos.value, ...idsParaExpandir])];
+        await nextTick();
+        await nextTick();
+        await scrollParaMatch(0);
+      } else {
+        expandidos.value = montarExpansaoAutomatica(props.value);
+      }
+    });
+    async function irParaProximo() {
+      if (totalMatches.value === 0) return;
+      matchAtual.value = (matchAtual.value + 1) % totalMatches.value;
+      await scrollParaMatch(matchAtual.value);
+    }
+    async function irParaAnterior() {
+      if (totalMatches.value === 0) return;
+      matchAtual.value = (matchAtual.value - 1 + totalMatches.value) % totalMatches.value;
+      await scrollParaMatch(matchAtual.value);
+    }
+    function escapeHtml(texto) {
+      return texto.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    }
+    function escapeRegex(texto) {
+      return texto.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function destacarTexto(texto, nodeId, campo) {
+      const escapado = escapeHtml(texto);
+      if (!termoBusca.value) return escapado;
+      const matchAtualObj = todasMatches.value[matchAtual.value];
+      const esteEhAtual = (matchAtualObj == null ? void 0 : matchAtualObj.nodeId) === nodeId && (matchAtualObj == null ? void 0 : matchAtualObj.field) === campo;
+      const termo = escapeRegex(escapeHtml(termoBusca.value));
+      return escapado.replace(
+        new RegExp(`(${termo})`, "gi"),
+        (match) => `<mark class="log-highlight${esteEhAtual ? " log-highlight--ativo" : ""}">${match}</mark>`
+      );
+    }
+    function handleKeydown(e) {
+      if (e.ctrlKey && e.key === "f") {
+        e.preventDefault();
+        abrirFiltro();
+      }
+      if (e.key === "Escape" && filtroVisivel.value) fecharFiltro();
+    }
+    onMounted(() => document.addEventListener("keydown", handleKeydown));
+    onUnmounted(() => document.removeEventListener("keydown", handleKeydown));
+    function abrirFiltro() {
+      filtroVisivel.value = true;
+      nextTick(() => {
+        var _a;
+        return (_a = filtroInputRef.value) == null ? void 0 : _a.focus();
+      });
+    }
+    function fecharFiltro() {
+      filtroVisivel.value = false;
+      termoBusca.value = "";
+    }
+    async function copiarObjeto(valor) {
+      await copyToClipboard(JSON.stringify(valor, null, 2));
+      notificacao({ color: "positive", message: "Objeto copiado." });
+    }
+    async function copiarTexto(display) {
+      await copyToClipboard(display.replace(/^"|"$/g, ""));
+      notificacao({ color: "positive", message: "Valor copiado." });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(Transition, { name: "log-filter-fade" }, {
+          default: withCtx(() => [
+            filtroVisivel.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: normalizeClass(["log-filter", {
+                "log-filter--sem-resultado": termoBusca.value && totalMatches.value === 0
+              }])
+            }, [
+              createVNode(_sfc_main$1, {
+                name: "search",
+                color: "grey-5",
+                size: "14px"
+              }),
+              withDirectives(createElementVNode("input", {
+                ref_key: "filtroInputRef",
+                ref: filtroInputRef,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => termoBusca.value = $event),
+                class: "log-filter__input",
+                placeholder: "Filtrar por key ou valor...",
+                onKeydown: [
+                  withKeys(fecharFiltro, ["esc"]),
+                  withKeys(withModifiers(irParaProximo, ["exact", "prevent"]), ["enter"]),
+                  withKeys(withModifiers(irParaAnterior, ["shift", "prevent"]), ["enter"])
+                ]
+              }, null, 40, _hoisted_2), [
+                [vModelText, termoBusca.value]
+              ]),
+              termoBusca.value ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(totalMatches.value > 0 ? `${matchAtual.value + 1} de ${totalMatches.value}` : "Sem resultados"), 1)) : createCommentVNode("", true),
+              totalMatches.value > 1 ? (openBlock(), createElementBlock("div", _hoisted_4, [
+                createVNode(_sfc_main$1, {
+                  name: "keyboard_arrow_up",
+                  color: "grey-5",
+                  size: "18px",
+                  class: "cursor-pointer",
+                  onClick: irParaAnterior
+                }),
+                createVNode(_sfc_main$1, {
+                  name: "keyboard_arrow_down",
+                  color: "grey-5",
+                  size: "18px",
+                  class: "cursor-pointer",
+                  onClick: irParaProximo
+                })
+              ])) : createCommentVNode("", true),
+              createVNode(_sfc_main$1, {
+                name: "close",
+                color: "grey-5",
+                size: "14px",
+                class: "cursor-pointer",
+                onClick: fecharFiltro
+              })
+            ], 2)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }),
+        createVNode(QTree, {
+          expanded: expandidos.value,
+          "onUpdate:expanded": _cache[1] || (_cache[1] = ($event) => expandidos.value = $event),
+          nodes: nos.value,
+          "node-key": "id",
+          dense: "",
+          class: "log-tree"
+        }, {
+          "default-header": withCtx((slotProps) => [
+            createElementVNode("div", {
+              class: "log-node",
+              "data-node-id": slotProps.node.id
+            }, [
+              createElementVNode("span", {
+                class: "log-key",
+                innerHTML: destacarTexto(slotProps.node.key, slotProps.node.id, "key")
+              }, null, 8, _hoisted_6),
+              _cache[4] || (_cache[4] = createElementVNode("span", { class: "log-sep" }, ":", -1)),
+              createElementVNode("span", {
+                class: normalizeClass(["log-value", `log-value--${slotProps.node.valueType}`]),
+                innerHTML: destacarTexto(
+                  slotProps.node.display,
+                  slotProps.node.id,
+                  "display"
+                )
+              }, null, 10, _hoisted_7),
+              createVNode(QMenu, {
+                "touch-position": "",
+                "context-menu": ""
+              }, {
+                default: withCtx(() => [
+                  createVNode(QList, {
+                    dense: "",
+                    class: "log-ctx"
+                  }, {
+                    default: withCtx(() => [
+                      withDirectives((openBlock(), createBlock(QItem, {
+                        clickable: "",
+                        onClick: ($event) => copiarObjeto(slotProps.node.rawValue)
+                      }, {
+                        default: withCtx(() => [
+                          createVNode(QItemSection, { side: "" }, {
+                            default: withCtx(() => [
+                              createVNode(_sfc_main$1, {
+                                name: "data_object",
+                                size: "xs",
+                                color: "grey-5"
+                              })
+                            ]),
+                            _: 1
+                          }),
+                          createVNode(QItemSection, null, {
+                            default: withCtx(() => [..._cache[2] || (_cache[2] = [
+                              createTextVNode("Copiar objeto", -1)
+                            ])]),
+                            _: 1
+                          })
+                        ]),
+                        _: 1
+                      }, 8, ["onClick"])), [
+                        [ClosePopup]
+                      ]),
+                      withDirectives((openBlock(), createBlock(QItem, {
+                        clickable: "",
+                        onClick: ($event) => copiarTexto(slotProps.node.display)
+                      }, {
+                        default: withCtx(() => [
+                          createVNode(QItemSection, { side: "" }, {
+                            default: withCtx(() => [
+                              createVNode(_sfc_main$1, {
+                                name: "text_fields",
+                                size: "xs",
+                                color: "grey-5"
+                              })
+                            ]),
+                            _: 1
+                          }),
+                          createVNode(QItemSection, null, {
+                            default: withCtx(() => [..._cache[3] || (_cache[3] = [
+                              createTextVNode("Copiar valor", -1)
+                            ])]),
+                            _: 1
+                          })
+                        ]),
+                        _: 1
+                      }, 8, ["onClick"])), [
+                        [ClosePopup]
+                      ])
+                    ]),
+                    _: 2
+                  }, 1024)
+                ]),
+                _: 2
+              }, 1024)
+            ], 8, _hoisted_5)
+          ]),
+          _: 1
+        }, 8, ["expanded", "nodes"])
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=index17.mjs.map

package/dist/index17.mjs.map

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

package/dist/index170.cjs

@@ -0,0 +1,38 @@
+"use strict";
+const quasar = require("quasar");
+const vue = require("vue");
+const statusBadge = require("./index75.cjs");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "acai-ui-badge",
+  props: {
+    label: {},
+    color: {},
+    status: { type: [String, Boolean, null] },
+    outline: { type: Boolean, default: false },
+    uppercase: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const resolvido = vue.computed(
+      () => props.status !== void 0 ? statusBadge.statusBadge(props.status) : null
+    );
+    const corResolvida = vue.computed(() => {
+      var _a;
+      return props.color ?? ((_a = resolvido.value) == null ? void 0 : _a.color) ?? "primary";
+    });
+    const rotuloResolvido = vue.computed(() => {
+      var _a;
+      return props.label ?? ((_a = resolvido.value) == null ? void 0 : _a.label) ?? "";
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(quasar.QBadge, {
+        class: vue.normalizeClass(["acai-ui-badge", { "text-uppercase": __props.uppercase }]),
+        color: corResolvida.value,
+        label: rotuloResolvido.value,
+        outline: __props.outline
+      }, null, 8, ["class", "color", "label", "outline"]);
+    };
+  }
+});
+module.exports = _sfc_main;
+//# sourceMappingURL=index170.cjs.map

package/dist/index170.cjs.map

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

package/dist/index170.mjs

@@ -0,0 +1,39 @@
+import { QBadge } from "quasar";
+import { defineComponent, computed, openBlock, createBlock, normalizeClass } from "vue";
+import { statusBadge } from "./index75.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "acai-ui-badge",
+  props: {
+    label: {},
+    color: {},
+    status: { type: [String, Boolean, null] },
+    outline: { type: Boolean, default: false },
+    uppercase: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const resolvido = computed(
+      () => props.status !== void 0 ? statusBadge(props.status) : null
+    );
+    const corResolvida = computed(() => {
+      var _a;
+      return props.color ?? ((_a = resolvido.value) == null ? void 0 : _a.color) ?? "primary";
+    });
+    const rotuloResolvido = computed(() => {
+      var _a;
+      return props.label ?? ((_a = resolvido.value) == null ? void 0 : _a.label) ?? "";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(QBadge, {
+        class: normalizeClass(["acai-ui-badge", { "text-uppercase": __props.uppercase }]),
+        color: corResolvida.value,
+        label: rotuloResolvido.value,
+        outline: __props.outline
+      }, null, 8, ["class", "color", "label", "outline"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=index170.mjs.map

package/dist/index170.mjs.map

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

package/dist/index172.cjs

@@ -0,0 +1,5 @@
+"use strict";
+const acaiUiDrawer_vue_vue_type_script_setup_true_lang = require("./index12.cjs");
+;/* empty css          */
+module.exports = acaiUiDrawer_vue_vue_type_script_setup_true_lang;
+//# sourceMappingURL=index172.cjs.map

package/dist/index172.cjs.map

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

package/dist/index172.mjs

@@ -0,0 +1,6 @@
+import _sfc_main from "./index12.mjs";
+/* empty css         */
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=index172.mjs.map

package/dist/index172.mjs.map

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