godeep-states 1.0.0

package/dist/runtime/stores/busca.js

@@ -0,0 +1,51 @@
+import { traduzirResultadosBusca } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storeBusca = defineStore("busca", {
+  state: () => ({
+    resultados: [],
+    carregando: false,
+    mostrarResultados: false,
+    abrirResultados: false,
+    maisBuscados: false
+  }),
+  getters: {
+    recuperarBuscaResultados: (state) => state.resultados,
+    buscaCarregando: (state) => state.carregando,
+    buscaMostrarResultados: (state) => state.mostrarResultados
+  },
+  actions: {
+    toggleAbrirResultados() {
+      this.abrirResultados = !this.abrirResultados;
+    },
+    async resetarBusca() {
+      this.resultados = [];
+      this.carregando = false;
+      this.mostrarResultados = false;
+      this.abrirResultados = false;
+    },
+    async busca(termo) {
+      if (termo.trim().length === 0) {
+        return;
+      }
+      try {
+        this.carregando = true;
+        const resultadosTraduzidos = traduzirResultadosBusca(await $fetch("/api/front-api/f1search/autocomplete", { method: "POST", body: JSON.stringify({ busca: termo }) }));
+        this.resultados = resultadosTraduzidos;
+        this.mostrarResultados = true;
+        this.carregando = false;
+        this.maisBuscados = false;
+      } catch {
+        this.resultados = [];
+        this.carregando = false;
+        this.mostrarResultados = false;
+      }
+    },
+    async irParaBusca(termo) {
+      const router = useRouter();
+      router.push({ path: "/busca", query: { q: termo } });
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/cadastro.d.ts

@@ -0,0 +1,6 @@
+import type { StorefrontCamposCadastroResponse, CadastroCompleto } from 'godeep-types/types';
+export declare const storeCadastro: import("pinia").StoreDefinition<"cadastro", {
+    carregando: boolean;
+    camposObrigatorios: StorefrontCamposCadastroResponse;
+    camposCadastro: CadastroCompleto;
+}, {}, {}>;

package/dist/runtime/stores/cadastro.js

@@ -0,0 +1,117 @@
+import { defineStore } from "pinia";
+import { useRouter } from "#imports";
+import { alerta } from "../utils/alerta.js";
+import { extrairMensagensErro } from "../utils/erros.js";
+import {
+  reverterCadastroPF,
+  reverterCadastroPJ,
+  traduzirCamposCadastroResponse
+} from "godeep-types/translate";
+export const storeCadastro = defineStore("cadastro", {
+  state: () => ({
+    carregando: false,
+    camposObrigatorios: {},
+    camposCadastro: {}
+  }),
+  getters: {
+    recuperarCamposObrigatorios: (state) => state.camposObrigatorios,
+    recuperarCamposCadastro: (state) => state.camposCadastro
+  },
+  actions: {
+    resetarCadastro() {
+      this.carregando = false;
+      this.camposObrigatorios = {};
+      this.camposCadastro = {};
+    },
+    async cadastrarPF(dados) {
+      this.carregando = true;
+      const router = useRouter();
+      const fallback = "N\xE3o foi poss\xEDvel criar sua conta. Verifique os dados e tente novamente.";
+      try {
+        await $fetch("/api/front-api/clientes/PF", {
+          method: "POST",
+          body: reverterCadastroPF(dados)
+        });
+        alerta.adicionar({
+          titulo: "Cadastro realizado com sucesso!",
+          descricao: "Sua conta foi criada. Voc\xEA j\xE1 pode fazer login.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        setTimeout(() => {
+          router.push("/");
+        }, 2e3);
+        return { sucesso: true, mensagensErro: {} };
+      } catch (error) {
+        const { mensagemGeral, mensagensErro } = extrairMensagensErro(
+          error,
+          fallback
+        );
+        alerta.adicionar({
+          titulo: "Erro no cadastro",
+          descricao: mensagemGeral,
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error, mensagensErro };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async cadastrarPJ(dados) {
+      this.carregando = true;
+      const router = useRouter();
+      const fallback = "N\xE3o foi poss\xEDvel cadastrar sua empresa. Verifique os dados e tente novamente.";
+      try {
+        await $fetch("/api/front-api/clientes/PJ", {
+          method: "POST",
+          body: reverterCadastroPJ(dados)
+        });
+        alerta.adicionar({
+          titulo: "Cadastro realizado com sucesso!",
+          descricao: "Sua empresa foi cadastrada. Voc\xEA j\xE1 pode fazer login.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        setTimeout(() => {
+          router.push("/");
+          this.resetarCadastro();
+        }, 2e3);
+        return { sucesso: true, mensagensErro: {} };
+      } catch (error) {
+        const { mensagemGeral, mensagensErro } = extrairMensagensErro(
+          error,
+          fallback
+        );
+        alerta.adicionar({
+          titulo: "Erro no cadastro",
+          descricao: mensagemGeral,
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error, mensagensErro };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async buscarCamposCadastro() {
+      try {
+        console.log("Iniciando busca de campos de cadastro...");
+        const data = await $fetch(
+          "/api/front-api/clientes-validation",
+          {
+            method: "GET"
+          }
+        );
+        console.log("Dados recebidos:", data);
+        this.camposObrigatorios = traduzirCamposCadastroResponse(data);
+      } catch (error) {
+        console.error("Erro ao buscar campos de cadastro:", error);
+        throw error;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/carrinho.d.ts

@@ -0,0 +1,8 @@
+import type { StorefrontCarrinho, StorefrontCarrinhoInfo } from 'godeep-types/types';
+export declare const storeCarrinho: import("pinia").StoreDefinition<"carrinho", {
+    carrinho: StorefrontCarrinho;
+    isLoaded: boolean;
+    carrinhoAberto: boolean;
+    cartId: string;
+    info: StorefrontCarrinhoInfo;
+}, {}, {}>;

package/dist/runtime/stores/carrinho.js

@@ -0,0 +1,219 @@
+import { traduzirCarrinho, traduzirCarrinhoProduto } from "godeep-types/translate";
+import { defineStore } from "pinia";
+import { navigateTo } from "#imports";
+import { alerta } from "../utils/alerta.js";
+const carrinhoDefault = {
+  id: "",
+  produtos: []
+};
+const infoDefault = {
+  valorTotalAVista: "",
+  valorTotalAPrazo: "",
+  valorFrete: 0,
+  valorProdutosAPrazo: "",
+  valorProdutosAVista: "",
+  valorNominalProdutos: "",
+  quantidadeItens: 0,
+  numeroMaximoParcelas: 0,
+  valorParcela: "",
+  valorDescontoProdutos: 0,
+  valorTotalEmbalagens: 0
+};
+export const storeCarrinho = defineStore("carrinho", {
+  state: () => ({
+    carrinho: carrinhoDefault,
+    isLoaded: false,
+    carrinhoAberto: false,
+    cartId: "",
+    info: infoDefault
+  }),
+  getters: {
+    totalItens: (state) => (state.carrinho?.produtos ?? []).reduce(
+      (total, item) => total + item.quantidade,
+      0
+    ),
+    quantidadeProdutos: (state) => state.carrinho?.produtos?.length || 0,
+    carrinhoVazio: (state) => !state.carrinho?.produtos || state.carrinho.produtos.length === 0
+  },
+  actions: {
+    preencherCarrinho(produtos, cartId, info) {
+      const produtosTraduzidos = produtos?.length ? produtos.map((produto) => traduzirCarrinhoProduto(produto)) : [];
+      const carrinhoTraduzido = traduzirCarrinho(cartId, {
+        ...info,
+        produtos
+      });
+      this.carrinho = {
+        id: cartId ?? "",
+        produtos: produtosTraduzidos,
+        info: carrinhoTraduzido.info
+      };
+      this.info = carrinhoTraduzido.info ?? infoDefault;
+      this.cartId = cartId ?? "";
+      this.isLoaded = true;
+      this.carrinhoAberto = true;
+    },
+    async alterarQuantidadeProdutoCarrinho(idProduto, quantidade) {
+      try {
+        const response = await $fetch(
+          `/api/front-api/basket/${idProduto}/v2`,
+          {
+            method: "PUT",
+            headers: {
+              "cart-id": this.cartId
+            },
+            body: {
+              qtd: quantidade
+            }
+          }
+        );
+        this.preencherCarrinho(
+          response.data?.produtos ?? [],
+          response?.basket?.cart_id ?? response?.cartId ?? "",
+          response?.data ?? infoDefault
+        );
+      } catch (error) {
+        console.error("Erro ao alterar quantidade do produto:", error);
+        this.carrinho = carrinhoDefault;
+        this.info = infoDefault;
+        this.isLoaded = true;
+        this.carrinhoAberto = false;
+      }
+    },
+    async adicionarProdutosCarrinho(produtos) {
+      const itensCarrinho = Array.isArray(this.carrinho?.produtos) ? this.carrinho.produtos : [];
+      let algumAlterado = false;
+      const itensParaAdicionar = [];
+      for (const itemNovo of produtos) {
+        const existente = itensCarrinho.find((item) => item.id === itemNovo.id);
+        if (existente && existente.id) {
+          const novaQuantidade = existente.quantidade + itemNovo.quantidade;
+          algumAlterado = true;
+          await this.alterarQuantidadeProdutoCarrinho(
+            existente.id,
+            novaQuantidade
+          );
+        } else {
+          itensParaAdicionar.push(itemNovo);
+        }
+      }
+      if (itensParaAdicionar.length > 0) {
+        try {
+          const response = await $fetch(
+            "/api/front-api/basket/v2",
+            {
+              method: "POST",
+              body: {
+                basket: {
+                  cart_id: this.cartId,
+                  products: itensParaAdicionar.map((item) => ({
+                    id: item.id,
+                    quantidade: item.quantidade
+                  }))
+                }
+              }
+            }
+          );
+          this.preencherCarrinho(
+            response.data?.produtos ?? [],
+            response?.cartId ?? response?.basket?.cart_id ?? "",
+            response?.data ?? infoDefault
+          );
+        } catch (error) {
+          console.error("Erro ao adicionar ao carrinho:", error);
+          this.carrinho = carrinhoDefault;
+          this.isLoaded = true;
+          this.carrinhoAberto = false;
+        }
+      }
+      if (algumAlterado) return;
+    },
+    async removerItemCarrinho(idProduto) {
+      try {
+        const response = await $fetch(
+          `/api/front-api/basket/${idProduto}/v2`,
+          {
+            method: "DELETE",
+            headers: {
+              "cart-id": this.cartId
+            }
+          }
+        );
+        this.preencherCarrinho(
+          response.data?.produtos ?? [],
+          response?.cartId ?? response?.basket?.cart_id ?? "",
+          response?.data ?? infoDefault
+        );
+      } catch (error) {
+        console.error("Erro ao remover produto do carrinho:", error);
+        this.carrinho = carrinhoDefault;
+        this.info = infoDefault;
+        this.isLoaded = true;
+        this.carrinhoAberto = false;
+      }
+    },
+    async limparCarrinho() {
+      try {
+        const response = await $fetch(
+          "/api/front-api/delete-carrinho",
+          {
+            method: "POST",
+            body: {
+              cartId: this.cartId
+            }
+          }
+        );
+        this.preencherCarrinho(
+          response.data?.produtos ?? [],
+          response?.cartId ?? response?.basket?.cart_id ?? "",
+          response?.data ?? infoDefault
+        );
+      } catch (error) {
+        console.error("Erro ao limpar carrinho:", error);
+        this.carrinho = carrinhoDefault;
+        this.info = infoDefault;
+        this.isLoaded = true;
+        this.carrinhoAberto = false;
+      }
+    },
+    async finalizar() {
+      try {
+        const response = await $fetch("/api/front-api/checkout", {
+          method: "GET",
+          headers: {
+            "cart.id": this.cartId,
+            "Cookie": `cart.id=${this.cartId}`,
+            "sec-fetch-site": "same-origin",
+            "origin": "checkout-newfront.f1b2c.com.br",
+            "referer": "checkout-newfront.f1b2c.com.br",
+            "user-agent": "Mozilla/5.0",
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-language": "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7",
+            "accept-encoding": "gzip, deflate, br",
+            "connection": "keep-alive",
+            "cache-control": "max-age=0",
+            "upgrade-insecure-requests": "1"
+          }
+        });
+        if (response?.urlCheckout) {
+          await navigateTo(
+            `https://${response.urlCheckout}/meu-carrinho?cart-id=${this.cartId}`,
+            { external: true }
+          );
+        } else {
+          await navigateTo("/", { external: false });
+          alerta.adicionar({
+            titulo: "Erro ao finalizar compra",
+            descricao: "Por favor, tente novamente mais tarde",
+            cor: "error",
+            variantes: ["dashed", "soft"]
+          });
+        }
+      } catch (error) {
+        console.error("Erro ao finalizar compra:", error);
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/categoria.d.ts

@@ -0,0 +1,10 @@
+import type { StorefrontCategoriaListagem } from 'godeep-types/types';
+type FiltrosSelecionados = Record<string, string[]>;
+export declare const storeCategoria: import("pinia").StoreDefinition<"categoria", {
+    categoria: StorefrontCategoriaListagem;
+    carregando: boolean;
+    paginaAtual: number;
+    ordenacao: string;
+    filtrosAtivos: FiltrosSelecionados;
+}, {}, {}>;
+export {};

package/dist/runtime/stores/categoria.js

@@ -0,0 +1,137 @@
+import { traduzirCategoriaListagem } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storeCategoria = defineStore("categoria", {
+  state: () => ({
+    categoria: {},
+    carregando: false,
+    paginaAtual: 1,
+    ordenacao: "",
+    filtrosAtivos: {}
+  }),
+  getters: {
+    recuperarCategoria: (state) => state.categoria,
+    categoriaCarregando: (state) => state.carregando,
+    recuperarProdutos: (state) => state.categoria?.produtos ?? [],
+    totalPaginas: (state) => state.categoria?.paginador?.ultimaPagina ?? 1,
+    recuperarPaginaAtual: (state) => state.categoria?.paginador?.paginaAtual ?? state.paginaAtual,
+    recuperarOrdenacao: (state) => state.ordenacao,
+    recuperarFiltros: (state) => state.filtrosAtivos
+  },
+  actions: {
+    resetarCategoria() {
+      this.categoria = {};
+      this.carregando = false;
+      this.paginaAtual = 1;
+      this.ordenacao = "";
+      this.filtrosAtivos = {};
+    },
+    definirPagina(pagina) {
+      this.paginaAtual = pagina > 0 ? pagina : 1;
+    },
+    definirOrdenacao(ordenacao) {
+      this.ordenacao = ordenacao;
+      this.paginaAtual = 1;
+    },
+    alternarFiltro(secaoId, valor) {
+      const valoresAtuais = this.filtrosAtivos[secaoId] ?? [];
+      const existe = valoresAtuais.includes(valor);
+      this.filtrosAtivos = {
+        ...this.filtrosAtivos,
+        [secaoId]: existe ? valoresAtuais.filter((item) => item !== valor) : [...valoresAtuais, valor]
+      };
+      if (this.filtrosAtivos[secaoId]?.length === 0) {
+        const { [secaoId]: _, ...resto } = this.filtrosAtivos;
+        this.filtrosAtivos = resto;
+      }
+      this.paginaAtual = 1;
+    },
+    aplicarFiltroPreco(min, max) {
+      this.filtrosAtivos = {
+        ...this.filtrosAtivos,
+        preco: [`${min}:${max}`]
+      };
+      this.paginaAtual = 1;
+    },
+    limparFiltros() {
+      this.filtrosAtivos = {};
+      this.paginaAtual = 1;
+    },
+    carregarFiltrosDaUrl(query) {
+      const filtros = {};
+      const processar = (chave, destino) => {
+        const valor = query[chave];
+        if (!valor) return;
+        const lista = Array.isArray(valor) ? valor : [valor];
+        const strings = lista.filter(
+          (item) => typeof item === "string"
+        );
+        if (strings.length > 0) {
+          filtros[destino] = strings;
+        }
+      };
+      processar("precos", "preco");
+      processar("marcas", "marca");
+      processar("filtro", "filtro");
+      processar("grade", "grade");
+      const pagina = query.page;
+      if (pagina && typeof pagina === "string") {
+        const numero = Number.parseInt(pagina);
+        if (!Number.isNaN(numero) && numero > 0) {
+          this.paginaAtual = numero;
+        }
+      }
+      const order = query.order;
+      if (order && typeof order === "string") {
+        this.ordenacao = order;
+      }
+      this.filtrosAtivos = filtros;
+    },
+    construirParametros(slug) {
+      const parametros = {
+        slug,
+        page: this.paginaAtual
+      };
+      if (this.ordenacao) {
+        parametros.order = this.ordenacao;
+      }
+      Object.entries(this.filtrosAtivos).forEach(([secao, valores]) => {
+        if (!valores || valores.length === 0) return;
+        if (secao === "preco") {
+          parametros.precos = valores;
+        } else if (secao === "marca") {
+          parametros.marcas = valores;
+        } else if (secao === "filtro") {
+          parametros.filtro = valores;
+        } else if (secao === "grade") {
+          parametros.grade = valores[0] ?? "";
+        }
+      });
+      return parametros;
+    },
+    normalizarSlug(path) {
+      return path.startsWith("/") ? path.slice(1) : path;
+    },
+    async buscarCategoria(path) {
+      try {
+        this.carregando = true;
+        const slug = this.normalizarSlug(path);
+        const parametros = this.construirParametros(slug);
+        const resposta = await $fetch(
+          "/api/front-api/categorias",
+          {
+            method: "GET",
+            params: parametros
+          }
+        );
+        this.categoria = resposta ? traduzirCategoriaListagem(resposta) : {};
+      } catch {
+        this.categoria = {};
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/configuracoes.d.ts

@@ -0,0 +1,16 @@
+import type { StorefrontConfiguracoes } from 'godeep-types/types';
+export declare const storeConfiguracoes: import("pinia").StoreDefinition<"configuracoes", {
+    configuracoes: StorefrontConfiguracoes;
+    carregando: boolean;
+    logotipo: string;
+    logotipoRodape: string;
+    favicon: string;
+    nomeLoja: string;
+    fraseRodape: string;
+    mensagemTopo: string;
+    emailSAC: string;
+    telefoneSAC: string;
+    horarioAtendimento: string;
+    enderecoLoja: string;
+    enderecoGoogleMaps: string;
+}, {}, {}>;

package/dist/runtime/stores/configuracoes.js

@@ -0,0 +1,85 @@
+import { traduzirConfiguracoes } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storeConfiguracoes = defineStore("configuracoes", {
+  state: () => ({
+    configuracoes: {},
+    carregando: false,
+    logotipo: "",
+    logotipoRodape: "",
+    favicon: "",
+    nomeLoja: "",
+    fraseRodape: "",
+    mensagemTopo: "",
+    emailSAC: "",
+    telefoneSAC: "",
+    horarioAtendimento: "",
+    enderecoLoja: "",
+    enderecoGoogleMaps: ""
+  }),
+  getters: {
+    recuperarConfiguracoes: (state) => state.configuracoes,
+    configuracoesCarregando: (state) => state.carregando,
+    dadosLoja: (state) => state.configuracoes?.dadosLoja,
+    layout: (state) => state.configuracoes?.layout,
+    modulos: (state) => state.configuracoes?.modulos,
+    parametros: (state) => state.configuracoes?.parametros,
+    logotipo: (state) => {
+      const dado = state.configuracoes?.dadosLoja;
+      if (dado?.logotipo?.real) return dado.logotipo.real;
+      if (dado?.logotipo?.urlResizer && dado?.logotipo?.urlParametro) {
+        return `${dado.logotipo.urlResizer}${dado.logotipo.urlParametro}`;
+      }
+      return "/logo.svg";
+    },
+    logotipoRodape: (state) => {
+      const dado = state.configuracoes?.dadosLoja;
+      if (dado?.logotipoRodape?.real) return dado.logotipoRodape.real;
+      if (dado?.logotipoRodape?.urlResizer && dado?.logotipoRodape?.urlParametro) {
+        return `${dado.logotipoRodape.urlResizer}${dado.logotipoRodape.urlParametro}`;
+      }
+      return state.configuracoes?.dadosLoja?.logotipo?.real ?? "/logo.svg";
+    },
+    favicon: (state) => state.configuracoes?.dadosLoja?.favicon ?? "/favicon.ico",
+    nomeLoja: (state) => state.configuracoes?.dadosLoja?.nomeFantasia ?? state.configuracoes?.dadosLoja?.nomeLoja ?? state.configuracoes?.dadosLoja?.razaoSocial ?? "Loja",
+    fraseRodape: (state) => state.configuracoes?.dadosLoja?.fraseRodape ?? "",
+    mensagemTopo: (state) => state.configuracoes?.layout?.topo?.mensagem ?? "",
+    emailSAC: (state) => state.configuracoes?.dadosLoja?.emailSAC ?? "",
+    telefoneSAC: (state) => state.configuracoes?.dadosLoja?.telefoneSAC ?? "",
+    horarioAtendimento: (state) => state.configuracoes?.dadosLoja?.horarioAtendimento ?? "",
+    enderecoLoja: (state) => state.configuracoes?.dadosLoja?.enderecoLoja ?? "",
+    enderecoGoogleMaps: (state) => state.configuracoes?.dadosLoja?.enderecoGoogleMaps ?? "",
+    numeroWhatsapp: (state) => state.configuracoes?.dadosLoja?.numeroWhatsapp ?? "",
+    exibirWhatsapp: (state) => state.configuracoes?.dadosLoja?.exibirWhatsapp === true,
+    copyright: (_getters) => {
+      const frase = _getters.fraseRodape;
+      if (frase) return frase;
+      const ano = (/* @__PURE__ */ new Date()).getFullYear();
+      const nome = _getters.nomeLoja;
+      return `\xA9 ${ano} ${nome}, todos os direitos reservados.`;
+    },
+    moduloAtivo: (state) => (nomeModulo) => {
+      const modulo = state.configuracoes?.modulos?.[nomeModulo];
+      return modulo?.ativo === true;
+    }
+  },
+  actions: {
+    resetarConfiguracoes() {
+      this.configuracoes = {};
+      this.carregando = false;
+    },
+    async buscarConfiguracoes() {
+      try {
+        this.carregando = true;
+        const resposta = await $fetch("/api/front-api/configuracoes");
+        this.configuracoes = resposta ? traduzirConfiguracoes(resposta) : {};
+        this.carregando = false;
+      } catch {
+        this.carregando = false;
+        this.configuracoes = {};
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/dados-cadastrais.d.ts

@@ -0,0 +1,7 @@
+import type { StorefrontDadosCadastrais, StorefrontDadosCadastraisPF, StorefrontDadosCadastraisPJ, TipoCadastro } from 'godeep-types/types';
+export declare const storeDadosCadastrais: import("pinia").StoreDefinition<"dados-cadastrais", {
+    dados: StorefrontDadosCadastrais | StorefrontDadosCadastraisPF | StorefrontDadosCadastraisPJ | null;
+    tipoPessoa: TipoCadastro;
+    carregando: boolean;
+    salvando: boolean;
+}, {}, {}>;