godeep-states 1.0.0

package/dist/runtime/stores/dados-cadastrais.js

@@ -0,0 +1,89 @@
+import { defineStore } from "pinia";
+import { alerta } from "../utils/alerta.js";
+import { traduzirClienteResponse, reverterCliente } from "godeep-types/translate";
+export const storeDadosCadastrais = defineStore("dados-cadastrais", {
+  state: () => ({
+    dados: null,
+    tipoPessoa: "PF",
+    carregando: false,
+    salvando: false
+  }),
+  getters: {
+    recuperarDados: (state) => state.dados,
+    dadosCarregando: (state) => state.carregando,
+    dadosSalvando: (state) => state.salvando
+  },
+  actions: {
+    resetarDados() {
+      this.dados = null;
+      this.carregando = false;
+      this.salvando = false;
+    },
+    async buscarDadosCadastrais(token, tipoCliente) {
+      this.carregando = true;
+      try {
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        const resposta = await $fetch(
+          "/api/front-api/clientes",
+          {
+            method: "GET",
+            headers: { "X-ACCESS-TOKEN": token }
+          }
+        );
+        if (!resposta?.dados)
+          throw new Error("Dados do cliente n\xE3o encontrados");
+        const tipoPessoa = resposta.dados.tipoPessoa || tipoCliente || "PF";
+        this.dados = traduzirClienteResponse(
+          resposta.dados,
+          tipoPessoa
+        );
+        this.tipoPessoa = tipoPessoa;
+        return { sucesso: true, dados: this.dados };
+      } catch (error) {
+        this.dados = null;
+        alerta.adicionar({
+          titulo: "Erro ao carregar dados",
+          descricao: "N\xE3o foi poss\xEDvel carregar seus dados cadastrais.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async atualizarDadosCadastrais(token, dadosAtualizados) {
+      this.salvando = true;
+      try {
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        const tipoCliente = "cpf" in dadosAtualizados ? "PF" : "PJ";
+        await $fetch(`/api/front-api/clientes/${tipoCliente}`, {
+          method: "PUT",
+          headers: { "X-ACCESS-TOKEN": token },
+          body: reverterCliente(dadosAtualizados)
+        });
+        this.dados = dadosAtualizados;
+        alerta.adicionar({
+          titulo: "Dados atualizados!",
+          descricao: "Seus dados cadastrais foram atualizados com sucesso.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: true };
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro ao atualizar",
+          descricao: "N\xE3o foi poss\xEDvel atualizar seus dados. Verifique os campos e tente novamente.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.salvando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

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

@@ -0,0 +1,7 @@
+import type { StorefrontEndereco } from 'godeep-types/types';
+export declare const storeEnderecos: import("pinia").StoreDefinition<"enderecos", {
+    enderecos: StorefrontEndereco[];
+    endereco: StorefrontEndereco;
+    carregando: boolean;
+    salvando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/enderecos.js

@@ -0,0 +1,217 @@
+import { defineStore } from "pinia";
+import { alerta } from "../utils/alerta.js";
+import { traduzirEnderecosCliente } from "godeep-types/translate";
+export const storeEnderecos = defineStore("enderecos", {
+  state: () => ({
+    enderecos: [],
+    endereco: {
+      id: "",
+      destinatario: "",
+      cep: "",
+      endereco: "",
+      logradouro: "",
+      numero: "",
+      complemento: "",
+      bairro: "",
+      estado: "",
+      cidade: "",
+      nomeEndereco: "",
+      tipo: ""
+    },
+    carregando: false,
+    salvando: false
+  }),
+  getters: {
+    recuperarEnderecos: (state) => state.enderecos,
+    recuperarEndereco: (state) => state.endereco,
+    enderecosCarregando: (state) => state.carregando,
+    enderecosSalvando: (state) => state.salvando
+  },
+  actions: {
+    resetarEnderecos() {
+      this.enderecos = [];
+      this.endereco = {
+        id: "",
+        destinatario: "",
+        cep: "",
+        endereco: "",
+        logradouro: "",
+        numero: "",
+        complemento: "",
+        bairro: "",
+        estado: "",
+        cidade: "",
+        nomeEndereco: "",
+        tipo: ""
+      };
+      this.carregando = false;
+    },
+    async buscarEnderecos(token) {
+      try {
+        this.carregando = true;
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        const resposta = await $fetch(
+          "/api/front-api/clientes/enderecos",
+          {
+            method: "GET",
+            headers: { "X-ACCESS-TOKEN": token }
+          }
+        );
+        this.enderecos = traduzirEnderecosCliente(resposta);
+        return { sucesso: true, enderecos: this.enderecos };
+      } catch (error) {
+        this.enderecos = [];
+        alerta.adicionar({
+          titulo: "Erro ao carregar endere\xE7os",
+          descricao: "N\xE3o foi poss\xEDvel carregar seus endere\xE7os.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async buscarEndereco(token, id) {
+      try {
+        this.carregando = true;
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        const resposta = await $fetch(
+          `/api/front-api/clientes/enderecos/${id}`,
+          {
+            headers: { "X-ACCESS-TOKEN": token }
+          }
+        );
+        this.endereco = traduzirEnderecosCliente(
+          resposta
+        )[0];
+        return { sucesso: true, endereco: this.endereco };
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro ao carregar endere\xE7o",
+          descricao: "N\xE3o foi poss\xEDvel carregar o endere\xE7o.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async cadastrarEndereco(token, endereco) {
+      this.carregando = true;
+      try {
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        await $fetch("/api/front-api/clientes/enderecos/cadastrar", {
+          method: "POST",
+          headers: { "X-ACCESS-TOKEN": token },
+          body: endereco
+        });
+        alerta.adicionar({
+          titulo: "Endere\xE7o cadastrado!",
+          descricao: "O endere\xE7o foi cadastrado com sucesso.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        this.endereco = endereco;
+        await this.buscarEnderecos(token);
+        return { sucesso: true };
+      } catch (error) {
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async atualizarEndereco(token, id, endereco) {
+      try {
+        this.carregando = true;
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        await $fetch(`/api/front-api/clientes/enderecos/atualizar/${id}`, {
+          method: "PUT",
+          headers: { "X-ACCESS-TOKEN": token },
+          body: endereco
+        });
+        alerta.adicionar({
+          titulo: "Endere\xE7o atualizado!",
+          descricao: "O endere\xE7o foi atualizado com sucesso.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        await this.buscarEnderecos(token);
+        return { sucesso: true };
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro ao atualizar endere\xE7o",
+          descricao: "N\xE3o foi poss\xEDvel atualizar o endere\xE7o. Verifique os campos e tente novamente.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async deletarEndereco(token, id) {
+      try {
+        this.carregando = true;
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        await $fetch(`/api/front-api/clientes/enderecos/${id}`, {
+          method: "DELETE",
+          headers: { "X-ACCESS-TOKEN": token }
+        });
+        alerta.adicionar({
+          titulo: "Endere\xE7o removido!",
+          descricao: "O endere\xE7o foi removido com sucesso.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        await this.buscarEnderecos(token);
+        return { sucesso: true };
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro ao remover endere\xE7o",
+          descricao: "N\xE3o foi poss\xEDvel remover o endere\xE7o.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async definirComoPrincipal(token, id) {
+      try {
+        this.carregando = true;
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        const endereco = this.enderecos.find((e) => e.id === id);
+        if (!endereco) throw new Error("Endere\xE7o n\xE3o encontrado");
+        await $fetch(`/api/front-api/clientes/enderecos/atualizar/${id}`, {
+          method: "PUT",
+          headers: { "X-ACCESS-TOKEN": token },
+          body: { ...endereco, tipo: "Principal" }
+        });
+        alerta.adicionar({
+          titulo: "Endere\xE7o definido como principal!",
+          descricao: "O endere\xE7o foi definido como principal com sucesso.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        await this.buscarEnderecos(token);
+        return { sucesso: true };
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro ao definir como principal",
+          descricao: "N\xE3o foi poss\xEDvel definir o endere\xE7o como principal.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

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

@@ -0,0 +1,7 @@
+import type { StorefrontFavoritoResponse } from 'godeep-types/types';
+export declare const favoritosDefault: StorefrontFavoritoResponse;
+export declare const storeFavoritos: import("pinia").StoreDefinition<"favoritos", {
+    listaIds: string[];
+    favoritos: StorefrontFavoritoResponse;
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/favoritos.js

@@ -0,0 +1,120 @@
+import { traduzirFavoritos } from "godeep-types/translate";
+import { defineStore } from "pinia";
+import { storeLogin } from "./login.js";
+import { alerta } from "../utils/alerta.js";
+export const favoritosDefault = {
+  produtos: []
+};
+export const storeFavoritos = defineStore("favoritos", {
+  state: () => ({
+    listaIds: [],
+    favoritos: favoritosDefault,
+    carregando: false
+  }),
+  getters: {
+    recuperarListaIds: (state) => state.listaIds,
+    recuperarListaIdsCarregando: (state) => state.carregando,
+    produtoFavoritado: (state) => (produtoId) => state.listaIds.includes(produtoId),
+    produtoFavoritadoCarregando: (state) => state.carregando,
+    recuperarFavoritos: (state) => state.favoritos,
+    recuperarFavoritosCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarFavoritos() {
+      this.listaIds = [];
+      this.favoritos = favoritosDefault;
+      this.carregando = false;
+    },
+    async verificarUsuarioLogado() {
+      const loginStore = storeLogin();
+      const token = loginStore.usuario?.token;
+      if (!token) {
+        alerta.adicionar({
+          titulo: "Erro",
+          descricao: "Usu\xE1rio n\xE3o logado",
+          cor: "error",
+          variantes: ["outline"]
+        });
+        return null;
+      }
+      return token;
+    },
+    async buscarFavoritos() {
+      const token = await this.verificarUsuarioLogado();
+      if (!token) {
+        return;
+      }
+      try {
+        this.carregando = true;
+        const response = await $fetch("/api/front-api/favoritos", {
+          method: "GET",
+          headers: { "X-ACCESS-TOKEN": token }
+        });
+        const favoritosTraduzidos = traduzirFavoritos(response);
+        this.favoritos = favoritosTraduzidos ?? favoritosDefault;
+        this.carregando = false;
+      } catch {
+        this.favoritos = favoritosDefault;
+        this.carregando = false;
+      }
+    },
+    async adicionarFavorito(produtoId) {
+      try {
+        const token = await this.verificarUsuarioLogado();
+        if (!token) {
+          return;
+        }
+        this.carregando = true;
+        await $fetch(
+          `/api/front-api/favoritos/${produtoId}`,
+          {
+            method: "POST",
+            headers: { "X-ACCESS-TOKEN": token }
+          }
+        );
+        if (!this.listaIds.includes(produtoId)) {
+          this.listaIds.push(produtoId);
+        }
+        this.carregando = false;
+      } catch {
+        this.listaIds = [];
+        this.carregando = false;
+      }
+    },
+    async removerFavorito(produtoId) {
+      const token = await this.verificarUsuarioLogado();
+      if (!token) {
+        return;
+      }
+      try {
+        const response = await $fetch(`/api/front-api/favoritos/${produtoId}`, {
+          method: "DELETE",
+          headers: { "X-ACCESS-TOKEN": token }
+        });
+        if (response.mensagens && response.mensagens.length > 0) {
+          alerta.adicionar({
+            titulo: "Produto removido dos favoritos",
+            descricao: response.mensagens[0],
+            cor: "success",
+            variantes: ["outline"]
+          });
+          this.listaIds = this.listaIds.filter((id) => id !== produtoId);
+          this.buscarFavoritos();
+        }
+      } catch {
+        this.listaIds = [];
+        this.carregando = false;
+      }
+    },
+    async toggleFavorito(produtoId) {
+      if (this.listaIds.includes(produtoId)) {
+        await this.removerFavorito(produtoId);
+      } else {
+        await this.adicionarFavorito(produtoId);
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

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

@@ -0,0 +1,9 @@
+import type { StorefrontFiltroPreco, StorefrontFiltroSecao, StorefrontSubcategoriaItem } from 'godeep-types/types';
+export declare const storeFiltros: import("pinia").StoreDefinition<"filtros", {
+    filtros: StorefrontFiltroSecao[];
+    subcategorias: StorefrontSubcategoriaItem[];
+    faixasPreco: StorefrontFiltroPreco[];
+    carregando: boolean;
+    erro: string;
+    slug: string;
+}, {}, {}>;

package/dist/runtime/stores/filtros.js

@@ -0,0 +1,63 @@
+import { traduzirParametros } from "godeep-types/translate";
+import { defineStore } from "pinia";
+function normalizarSlug(slug) {
+  let valor = slug.startsWith("/") ? slug.slice(1) : slug;
+  valor = valor.replace(/^categorias\//, "");
+  return valor.startsWith("categorias/") ? valor : `categorias/${valor}`;
+}
+export const storeFiltros = defineStore("filtros", {
+  state: () => ({
+    filtros: [],
+    subcategorias: [],
+    faixasPreco: [],
+    carregando: false,
+    erro: "",
+    slug: ""
+  }),
+  getters: {
+    recuperarFiltros: (state) => state.filtros,
+    recuperarSubcategorias: (state) => state.subcategorias,
+    recuperarFaixasPreco: (state) => state.faixasPreco,
+    filtrosCarregando: (state) => state.carregando,
+    recuperarErro: (state) => state.erro
+  },
+  actions: {
+    resetarFiltros() {
+      this.filtros = [];
+      this.subcategorias = [];
+      this.faixasPreco = [];
+      this.carregando = false;
+      this.erro = "";
+      this.slug = "";
+    },
+    async buscarFiltros(slug) {
+      const slugNormalizado = normalizarSlug(slug);
+      this.slug = slugNormalizado;
+      try {
+        this.carregando = true;
+        const resposta = await $fetch(
+          "/api/front-api/parametros",
+          {
+            method: "GET",
+            params: { slug: slugNormalizado }
+          }
+        );
+        const traduzido = traduzirParametros(resposta);
+        this.filtros = traduzido.filtros;
+        this.subcategorias = traduzido.subcategorias;
+        this.faixasPreco = traduzido.faixasPreco;
+        this.erro = "";
+      } catch {
+        this.filtros = [];
+        this.subcategorias = [];
+        this.faixasPreco = [];
+        this.erro = "Erro ao carregar filtros";
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

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

@@ -0,0 +1,5 @@
+import type { StorefrontCmsHome } from 'godeep-types/types';
+export declare const storeHome: import("pinia").StoreDefinition<"home", {
+    home: StorefrontCmsHome[];
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/home.js

@@ -0,0 +1,59 @@
+import { traduzirCmsHome } from "godeep-types/translate";
+import { defineStore } from "pinia";
+import { storeVitrine } from "./vitrine.js";
+import { storeBanners } from "./banner.js";
+export const storeHome = defineStore("home", {
+  state: () => ({
+    home: [],
+    carregando: false
+  }),
+  getters: {
+    recuperarHome: (state) => state.home,
+    homeCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarHome() {
+      this.home = [];
+      this.carregando = false;
+    },
+    async buscarHome() {
+      try {
+        this.carregando = true;
+        const url = "/mocks/home.json";
+        const response = await $fetch(
+          url
+        );
+        const homeTraduzido = traduzirCmsHome(response);
+        console.log("homeTraduzido", homeTraduzido);
+        this.home = homeTraduzido ?? {};
+        const vitrineStore = storeVitrine();
+        const vitrines = homeTraduzido.filter((item) => item.tipoComponente === "vitrine" && item.slug);
+        await Promise.all(
+          vitrines.map((item) => {
+            const slug = item.slug === "mock" ? `mock-${item.idComponente}` : item.slug;
+            return vitrineStore.buscarVitrine(slug, true);
+          })
+        );
+        const bannerStore = storeBanners();
+        const banners = homeTraduzido.filter((item) => item.tipoComponente === "banner");
+        await Promise.all(
+          banners.map((item) => {
+            return bannerStore.buscarBanners(
+              item.posicaoComponente ?? "",
+              item.localizacao ?? "",
+              item.tipo ?? "",
+              item.slug ?? ""
+            );
+          })
+        );
+        this.carregando = false;
+      } catch {
+        this.home = [];
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

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

@@ -0,0 +1,13 @@
+import type { StorefrontEsqueceuSenhaTokenResponse, StorefrontRedefinirSenhaResponse, StorefrontUsuario } from 'godeep-types/types';
+export declare const storeLogin: import("pinia").StoreDefinition<"login", {
+    esqueceuSenhaToken: StorefrontEsqueceuSenhaTokenResponse;
+    redefinirSenhaResposta: StorefrontRedefinirSenhaResponse;
+    usuario: StorefrontUsuario;
+    carregando: boolean;
+    dadosLembrarMe: {
+        email: string;
+        senha: string;
+    } | null;
+    emailEnviado: boolean;
+    mensagemEsqueceuSenha: string;
+}, {}, {}>;