Skip to content

5. Estado compartilhado

5.1. Exemplo 15: Estado compartilhado com Pinia

Em uma aplicação, certos dados interessam a muitos componentes: o usuário logado, o carrinho de compras etc. O Exemplo 11 compartilhava esses dados com [provide] / [inject], enquanto o Exemplo 14 usava um módulo com [ref] . [Pinia], a biblioteca oficial do [Vue.js] para estado compartilhado, organiza isso em stores e as torna visíveis na extensão [Vue.js devtools].

Ela é instalada em [main.ts]:

// =========================================================================
// 15-pinia/src/main.ts
// -------------------------------------------------------------------------
// app.use(createPinia()): o Pinia é instalado, a biblioteca oficial do Vue.js
// para o gerenciamento de estado COMPARTILHADO. Os "stores" definidos
// a seguir são acessíveis de qualquer componente.
// =========================================================================

import { createApp } from 'vue';
import { createPinia } from 'pinia';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';

createApp(App).use(createPinia()).mount('#app');

A primeira store, o carrinho de compras:

// =========================================================================
// 15-pinia/src/stores/cart.ts - um STORE do Pinia
// -------------------------------------------------------------------------
// defineStore('cart', () => { ... }): um store escrito como um composable
// (estilo "setup"):
//   - os refs são o ESTADO do store;
//   - os valores computed, seus GETTERS (valores calculados);
//   - as funções, suas ACTIONS (o que modifica o estado).
// Diferença em relação a um composable (exemplo 11): o store existe em apenas UMA
// cópia para toda a aplicação. Todos os componentes que chamam
// useCartStore() recebem o MESMO carrinho. Ele vive enquanto a aplicação
// viver: sobrevive à remoção de um componente... mas não ao recarregamento
// da página (F5), que reinicia a aplicação.
// =========================================================================

import { computed, ref } from 'vue';
import { defineStore } from 'pinia';

export interface Item {
  label: string;
  price: number;
}

export const useCartStore = defineStore('cart', () => {
  const items = ref<Item[]>([]);

  const count = computed(() => items.value.length);
  const total = computed(() => items.value.reduce((s, a) => s + a.price, 0));

  function add(item: Item): void {
    items.value.push(item);
  }
  function clear(): void {
    items.value = [];
  }

  // tudo o que é retornado faz parte do store
  return { items, count, total, add, clear };
});
  • linhas 24–39: [defineStore(name, function)] define uma store no estilo “setup”, como um composable: os [ref] são seu estado, os [computed] são seus getters, e as funções são suas ações; ela expõe o que a função retorna;
  • A diferença em relação a um composable: há apenas uma instância da store para toda a aplicação. Todos os componentes que chamam [useCartStore()] recebem o MESMO carrinho de compras. Ela vive enquanto a aplicação viver: sobrevive à remoção de um componente... mas não ao recarregamento da página (F5), que reinicia a aplicação.

Uma segunda store, porém, sobrevive ao recarregamento da página:

// =========================================================================
// 15-pinia/src/stores/preferences.ts - um store que sobrevive ao F5
// -------------------------------------------------------------------------
// Para que um dado sobreviva ao recarregamento da página, ou ao fechamento
// do navegador, ele deve ser armazenado NO navegador: localStorage (um
// pequeno dicionário chave -> string, específico de cada site).
//   - na inicialização, o store lê o localStorage novamente;
//   - watch(..., { deep: true }) reescreve o localStorage a cada mudança.
// NUNCA armazene dados sensíveis ali (senha, token): qualquer script
// da página pode ler o localStorage.
// =========================================================================

import { ref, watch } from 'vue';
import { defineStore } from 'pinia';

const KEY = 'example15.preferences';

interface Preferences {
  dark: boolean;
  size: number; // tamanho do texto, em px
}

function read(): Preferences {
  try {
    return { dark: false, size: 16, ...JSON.parse(localStorage.getItem(KEY) ?? '{}') };
  } catch {
    return { dark: false, size: 16 }; // conteúdo ilegível: valores padrão
  }
}

export const usePreferencesStore = defineStore('preferences', () => {
  const preferences = ref<Preferences>(read());

  watch(preferences, (p) => localStorage.setItem(KEY, JSON.stringify(p)), { deep: true });

  return { preferences };
});
  • Linhas 23–29: na inicialização, o navegador relê o [localStorage], um pequeno dicionário chave/valor que o navegador armazena para cada site, mesmo depois de fechado. Se o conteúdo for ilegível, os valores padrão são usados;
  • Linha 34: [{ deep: true }]: o [watch] também reage às mudanças nas propriedades do objeto. Cada mudança é regravada no [localStorage].

NUNCA armazene dados sensíveis (senhas, tokens) no [localStorage]: qualquer script executado na página pode ler o [localStorage].

Os componentes:

<!-- 15-pinia/src/components/Shop.vue - ADICIONA ao carrinho compartilhado -->
<script setup lang="ts">
import { useCartStore, type Item } from '../stores/cart';

const cart = useCartStore();
const products: Item[] = [
  { label: 'Consultation', price: 30 },
  { label: 'Vaccine', price: 12.5 },
];
</script>

<template>
  <div class="card p-3 h-100">
    <h2 class="h6">Shop</h2>
    <button v-for="p in products" :key="p.label" class="btn btn-sm btn-outline-primary mb-2" @click="cart.add(p)">
      + {{ p.label }} (€{{ p.price }})
    </button>
  </div>
</template>
  • Linha 5: a store é usada como um objeto reativo: [cart.add(p)];
<!--
  15-pinia/src/components/CartSummary.vue - READS the same cart
  storeToRefs: to DESTRUCTURE a store without losing reactivity
  (const { count } = cart would give a simple, frozen copy).
-->
<script setup lang="ts">
import { storeToRefs } from 'pinia';
import { useCartStore } from '../stores/cart';

const cart = useCartStore();
const { count, total } = storeToRefs(cart);
</script>

<template>
  <div class="card p-3 h-100">
    <h2 class="h6">Cart</h2>
    <p class="mb-2">{{ count }} item(s), €{{ total }}</p>
    <!-- as actions, por sua vez, podem ser desestruturadas ou chamadas diretamente -->
    <button class="btn btn-sm btn-outline-danger align-self-start" :disabled="count === 0" @click="cart.clear()">Clear</button>
  </div>
</template>
  • linha 11: para desestruturar uma store sem perder a reatividade. [const { count } = cart] retornaria uma simples cópia, congelada no valor atual; [storeToRefs] retorna instâncias de [ref] ligadas à store. As ações, por outro lado, podem ser desestruturadas ou chamadas diretamente.
<!-- 15-pinia/src/components/LocalCounter.vue - um estado LOCAL, que desaparece com o componente -->
<script setup lang="ts">
import { ref } from 'vue';
const clicks = ref(0);
</script>

<template>
  <div class="card p-3 h-100">
    <h2 class="h6">Local state</h2>
    <button class="btn btn-sm btn-outline-secondary align-self-start" @click="clicks++">{{ clicks }} click(s)</button>
  </div>
</template>
<!--
  =========================================================================
  15-pinia/src/App.vue - three "scopes" of data on the client side
  -------------------------------------------------------------------------
  Same question as example 23 of the NestJS course (application,
  request, client scope), transposed to the browser:
    - the LOCAL state of a component (LocalCounter) disappears with it;
    - the state of a STORE (the cart) is shared by all the components and
      survives their removal - but not F5;
    - the state stored in localStorage (the preferences) survives F5 and the
      closing of the browser.
  Uncheck then check the box again, then reload the page: compare.
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
import { usePreferencesStore } from './stores/preferences';
import Shop from './components/Shop.vue';
import CartSummary from './components/CartSummary.vue';
import LocalCounter from './components/LocalCounter.vue';

const prefs = usePreferencesStore();
const areaVisible = ref(true);
</script>

<template>
  <div :class="{ 'bg-dark text-light': prefs.preferences.dark }" :style="{ fontSize: prefs.preferences.size + 'px' }" class="min-vh-100">
    <div class="container py-4">
      <h1 class="h3 mb-3">Example 15 - a shared state with Pinia</h1>
      <div class="d-flex flex-wrap gap-4 mb-3">
        <label class="form-check-label"><input v-model="prefs.preferences.dark" type="checkbox" class="form-check-input"> dark theme</label>
        <label>text size <input v-model.number="prefs.preferences.size" type="range" min="12" max="22"> {{ prefs.preferences.size }} px</label>
        <label class="form-check-label"><input v-model="areaVisible" type="checkbox" class="form-check-input"> show the area</label>
      </div>
      <div v-if="areaVisible" class="row g-3 text-body">
        <div class="col-md-4"><Shop /></div>
        <div class="col-md-4"><CartSummary /></div>
        <div class="col-md-4"><LocalCounter /></div>
      </div>
      <p class="mt-3 mb-2">Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
      <div class="text-body"><CartSummary /></div>
    </div>
  </div>
</template>
  • Linha 35: desmarcar “mostrar a área” remove os três componentes da página;
  • linha 41: um segundo resumo do mesmo carrinho de compras, fora da área.

Mesma pergunta do Exemplo 23 do curso [NestJS] (escopos de aplicação, de requisição e de cliente), adaptada para o navegador:

Dado
Onde?
Duração
O contador de LocalCounter
o estado local do componente
desaparece junto com o componente
o carrinho de compras
uma store Pinia
toda a aplicação, até o F5
as preferências
uma store Pinia + localStorage
sobrevive ao F5 e ao fechamento do navegador

Dois itens adicionados e dois cliques:

Image

A seção foi removida e o tema escuro foi selecionado: o carrinho de compras continua lá; se a seção for exibida novamente, o contador local volta a zero:

Image