Skip to content

6. Capítulo 5 - O cliente [Vue.js] da aplicação [RdvMedecins]

Este capítulo detalha, arquivo por arquivo, o conteúdo da pasta [rdvmedecins-vuejs-client] incluída neste documento, usando o formato adotado ao longo de todo o curso: código-fonte numerado linha a linha, seguido de uma seção intitulada “Vamos comentar este código:”. Cada pasta de projeto contém também o seu próprio [README.md].

6.1. Visão geral da arquitetura

Como no documento original, e como nas variantes [Angular] e [React] deste curso, o cliente segue uma arquitetura em camadas, que chamaremos aqui de V-Services (View-Services).

Vale notar uma diferença de terminologia: no AngularJS 1.x, a View (o template HTML) e o Controller (a classe JavaScript associada) eram duas entidades distintas, ligadas pelo $scope. No [Vue.js], elas são combinadas em uma única entidade, o componente [.vue] (veja o capítulo anterior) — exatamente como no [Angular] e no [React], embora a forma seja diferente (um arquivo com três blocos, em vez de uma classe ou de uma função) — razão pela qual, daqui em diante, falaremos simplesmente de “componentes” onde o documento original distinguia entre view e controller.

Como no documento original, os componentes NUNCA se comunicam diretamente por HTTP: esse papel é reservado exclusivamente à camada de serviços (neste caso, o composable [useAppointmentService()] e o composable [useAuth()]). Trata-se de um princípio de projeto que se aplica igualmente ao AngularJS 1.x, ao [Angular], ao [React], ou ao [Vue.js] — ele não mudou.

6.2. Estrutura do projeto

Esta estrutura segue diretamente o fluxo do documento original (login, seleção de médico/data, exibição da agenda, marcação de consulta), apenas organizada aqui em componentes [Vue.js] em vez de controllers/views separados do AngularJS 1.x, componentes standalone ([Angular]) ou componentes funcionais ([React]). Em comparação com as outras duas variantes deste curso:

  • o componente raiz cabe em um único arquivo (App.vue, mais README.md) em vez de três ([Angular]: app.ts/app.html/app.css) ou de três também no lado do [React] (App.tsx/App.css/README.md): [<template>] e [<script setup>] mesclam, no mesmo arquivo, o que o [JSX] já havia mesclado no lado do [React] - e App.vue, assim como App.tsx, não tem arquivo de configuração da aplicação equivalente a app.config.ts;
  • Uma pasta `core/composables/` aparece no lugar de `core/context/` no lado do [React] (que, por sua vez, está ausente no lado do [Angular]): ela contém os composables que atuam como serviços injetáveis ([SettingsService], [AuthService], [LanguageService]) na variante [Angular] — esse mecanismo (composables + [provide]/[inject]) foi introduzido no capítulo anterior, junto com um exemplo genérico (veja o capítulo anterior, “Lógica compartilhada”).

[Bootstrap] 5 é usado em todas as views (importado em main.ts; veja abaixo) — uma evolução direta do Bootstrap 3, já usado pelo documento original, sem alterações em relação às variantes [Angular] e [React] deste curso.

6.3. Arquivos de configuração do projeto

6.3.1. package.json

{
  "name": "rdvmedecins-vue-client",
  "version": "0.0.0",
  "scripts": {
    "dev": "vite",
    "start": "vite",
    "build": "vue-tsc -b && vite build",
    "preview": "vite preview"
  },
  "private": true,
  "packageManager": "npm@10.9.7",
  "dependencies": {
    "vue": "^3.5.0",
    "vue-i18n": "^11.0.0",
    "bootstrap": "^5.3.3"
  },
  "devDependencies": {
    "@vitejs/plugin-vue": "^5.2.0",
    "prettier": "^3.8.1",
    "typescript": "~5.8.0",
    "vite": "^6.0.0",
    "vue-tsc": "^2.2.0"
  }
}

Vamos comentar este código:

  • Linhas 5–8: ["scripts": { … }] — os comandos [npm run <name>] disponíveis. [start] (como dev) inicia o servidor de desenvolvimento do [Vite] com recarga automática sempre que um arquivo-fonte é modificado, na porta 4200 (veja vite.config.ts abaixo) - a mesma porta das variantes [Angular] e [React] deste curso;
  • Linha 7: ["build": "vue-tsc -b && vite build",] — diferença notável em relação ao [React] ([tsc -b && vite build]): o [vue-tsc] substitui o compilador TypeScript padrão por uma variante capaz de verificar também os tipos DENTRO de [<template>] (por exemplo, um [v-model] em uma propriedade inexistente, ou um [:doctors] que não corresponde ao tipo esperado por [defineProps]) - de modo muito parecido com o que o [Angular] faz com sua opção strictTemplates, ao passo que o [React] simplesmente verifica o [JSX] como qualquer outro TypeScript;
  • Linhas 12–16: ["dependencies": { … }] — os pacotes necessários para a execução no navegador: [vue] (o núcleo do framework), [vue-i18n] (tradução FR/EN; veja abaixo), [bootstrap] (somente a folha de estilos). Ao contrário das variantes [Angular] e [React] deste curso, não há um equivalente separado de [@angular/router]/[react-i18next] (o vue-i18n incorpora seu próprio mecanismo; veja i18n.ts) nem do RxJS;
  • linhas 17–23: ["devDependencies": { … }] — pacotes necessários apenas durante o desenvolvimento: [@vitejs/plugin-vue] (conversão dos arquivos [.vue] em JavaScript e recarga a quente), TypeScript, [vue-tsc] (veja acima) e o próprio [Vite] . Ao contrário do [React] ([@types/react], [@types/react-dom]), o [Vue.js] não exige pacotes de tipos separados: a própria biblioteca é escrita em TypeScript.

Ao contrário do servidor [NestJS] (módulo [commonjs], veja o Capítulo 3), este projeto é executado como módulos ECMAScript nativos (import/export) — exatamente como as variantes [Angular] e [React] deste curso.

6.3.2. vite.config.ts

1
2
3
4
5
6
7
8
9
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';

export default defineConfig({
  plugins: [vue()],
  server: {
    port: 4200,
  },
});

Vamos comentar este código:

  • linha 5: [plugins: [vue()],] — habilita a transformação dos arquivos [.vue] (separação dos três blocos, compilação do [<template>] de acordo com o modo de renderização) e a recarga a quente - o equivalente, para o [Vue.js], do que o [@vitejs/plugin-react]() fazia para o [JSX] no lado do [React] (veja o capítulo anterior) e do que o [@angular/build:dev-server] faz pelo [Angular] nos bastidores;
  • linhas 6–8: [server: { port: 4200, },] — define a porta do servidor de desenvolvimento como 4200, a mesma do [ng serve] no lado do [Angular] e do cliente [React] deste curso — uma escolha puramente didática, para que as três variantes do curso permaneçam intercambiáveis sem mudar seu fluxo de trabalho.

Este arquivo não tem equivalente no projeto AngularJS 1.x original; no lado do [Angular] deste curso, [angular.json] cumpre essa função; no lado do [NestJS] (Capítulo 3), é o [nest-cli.json].

6.3.3. tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "useDefineForClassFields": true,
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "skipLibCheck": true,

    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "isolatedModules": true,
    "moduleDetection": "force",
    "noEmit": true,

    "strict": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true
  },
  "include": ["src"]
}

Vamos detalhar este código:

  • linha 15: ["strict": true,] — como o [tsconfig.json] das variantes [Angular] e [React] deste curso, o modo estrito completo do TypeScript está ativo: toda variável deve ter um tipo determinável, e todo valor null ou undefined deve ser tratado explicitamente;
  • linhas 18–19: ["noUnusedLocals": true, "noUnusedParameters": true,] — sinaliza, durante a compilação, qualquer variável ou parâmetro declarado mas nunca usado — a mesma configuração do [React];
  • Linha 13: ["noEmit": true] — o TypeScript é usado aqui apenas para a VERIFICAÇÃO de tipos ([npm run build] inicia primeiro [vue-tsc -b], que falha se ocorrer um erro de tipo, inclusive em um [<template>]; veja package.json acima): é o [Vite] (por meio do esbuild) que realmente produz o JavaScript executado pelo navegador.

Ao contrário do arquivo [tsconfig.json] gerado a partir do [React] ([jsx: ‘react-jsx’]), este arquivo não contém nenhuma configuração específica do framework: é o [vue-tsc] (e não o compilador TypeScript padrão) que determina, previamente, como analisar um arquivo [.vue] — um mecanismo separado deste arquivo de configuração, ao contrário do [React], em que o suporte a [JSX] é configurado diretamente aqui.

6.4. Inicialização da aplicação

6.4.1. index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>RdvMedecins - Vue.js client</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" type="image/x-icon" href="/favicon.ico">
</head>
<body>
  <div id="app"></div>
  <script type="module" src="/src/main.ts"></script>
</body>
</html>

Vamos comentar este código:

  • linha 2: [<html lang="en">] — assim como no [Angular] e no [React], como esta página HTML é estática (carregada pelo navegador ANTES de a aplicação [Vue.js] iniciar), ela não pode refletir imediatamente uma seleção de idioma feita depois pelo usuário;
  • linha 10: [<div id="app"></div>] — o único elemento que esta página contém inicialmente, e que o [Vue.js] preenche por inteiro depois de montado (veja main.ts abaixo) - o equivalente exato de <app-root></app-root> no lado do [Angular], de <div id="root"></div> no lado do [React] e de [ng-app="rdvmedecinsApp"] na tag <html> do documento original (AngularJS 1.x, 2014); somente o identificador muda (convenção do [Vue.js]: "app");
  • linha 11: [<script type="module" src="/src/main.ts"></script>] — como no [React], é o index.html que referencia diretamente main.ts (uma convenção específica do [Vite]), e não o contrário. Em desenvolvimento, o [Vite] transforma e serve este arquivo em tempo real; em produção ([npm run build]), ele é, naturalmente, compilado previamente.

Como nas outras duas variantes, há um único ponto de entrada para toda a aplicação: essa é a própria definição de uma aplicação web de página única (SPA), como já descrito no documento original.

6.4.2. src/main.ts

import { createApp } from 'vue';

import 'bootstrap/dist/css/bootstrap.min.css';
import './index.css';

import { i18n } from './i18n';
import { createSettingsStore, SettingsKey } from './app/core/composables/settings.composable';
import { createAuthStore, AuthKey } from './app/core/composables/auth.composable';
import { createLanguageStore, LanguageKey } from './app/core/composables/language.composable';
import App from './app/App.vue';

const app = createApp(App);

app.use(i18n);

const settingsStore = createSettingsStore();
app.provide(SettingsKey, settingsStore);

const authStore = createAuthStore(settingsStore);
app.provide(AuthKey, authStore);

const languageStore = createLanguageStore();
app.provide(LanguageKey, languageStore);

const container = document.getElementById('app');
if (!container) {
  throw new Error('Element #app not found in index.html');
}

app.mount(container);

Vamos comentar este código:

  • linha 12: [const app = createApp(App);] — o equivalente direto de [bootstrapApplication(App, appConfig)] no lado do [Angular] e de [createRoot(...).render(...)] no lado do [React]: [createApp(...)] cria uma instância da aplicação (mas ainda não a monta; veja a linha 30);
  • linha 14: [app.use(i18n);] — instala o plugin [vue-i18n]: a partir de agora, [useI18n()] pode ser usado no [<script setup>] de qualquer componente;
  • linhas 16–23: [const settingsStore = createSettingsStore(); app.provide(SettingsKey, settingsStore); …] — os três pares [createXxxStore()] + [app.provide(...)] de core/composables/ (veja abaixo) tornam [useSettings()], [useAuth()] e [useLanguage()] utilizáveis a partir de qualquer componente descendente - o equivalente dos três [provideXxx()] de [app.config.ts] no lado do [Angular] ([providers: [...]]), mas expresso aqui como uma SEQUÊNCIA de chamadas de função, e não como um array de providers ou, no lado do [React], como um ANINHAMENTO de componentes [Provider] em torno do componente raiz - nenhum aninhamento visual é necessário aqui, ao contrário do [React] (compare com main.tsx do cliente React deste curso: <SettingsProvider><AuthProvider>...) ;
  • linhas 16, 19: [const settingsStore = … const authStore = createAuthStore(settingsStore);] — a ORDEM das chamadas importa: [createAuthStore(...)] exige que [settingsStore] já exista (para ler [apiBaseUrl]) — por isso ele é passado diretamente como parâmetro, e não por meio de uma injeção do [Vue.js]: nesta etapa, nenhum componente existe ainda, de modo que [inject()] não ajudaria em nada;
  • linha 22: [const languageStore = createLanguageStore();] — chamado DEPOIS de [app.use(i18n)] (linha 14): este composable exige que o plugin [vue-i18n] já esteja instalado;
  • linha 30: [app.mount(container);] — monta de fato a aplicação no elemento #app de index.html — separado de [createApp(App)] (linha 12) justamente para dar tempo a que as linhas intermediárias (app.use, app.provide) configurem a aplicação antes de ela ser exibida.

Como os clientes [Angular] e [React] deste curso (página única, sem tabela de rotas), este cliente, [Vue.js], NÃO usa roteador: App.vue exibe a tela de login ou o restante da aplicação, dependendo de [useAuth().isLoggedIn] — um simples [v-if] basta; um roteador ([vue-router] ou outro) não agregaria nenhum valor a uma aplicação de página única.

6.4.3. src/i18n.ts

import { createI18n } from 'vue-i18n';

export type Language = 'fr' | 'en';

const loadedDictionaries = new Set<Language>();

export const i18n = createI18n({
  legacy: false,
  locale: navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en',
  fallbackLocale: 'en',
  messages: {},
});

export async function loadDictionary(language: Language): Promise<void> {
  if (loadedDictionaries.has(language)) {
    return;
  }
  const httpResponse = await fetch(`/i18n/${language}.json`);
  const dictionary = (await httpResponse.json()) as Record<string, unknown>;
  i18n.global.setLocaleMessage(language, dictionary);
  loadedDictionaries.add(language);
}

Vamos comentar este código:

  • linha 8: [legacy: false,] — habilita o modo “Composition API” do [vue-i18n]: [useI18n()] nos componentes (como [useTranslation()] no lado do [React]), em vez de [this.$t] (o modo antigo, destinado à Options API do [Vue.js] 2);
  • linhas 9–11: [locale: navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en', fallbackLocale: 'en', messages: {},] — idioma de inicialização (francês se o idioma do navegador começar com 'fr', inglês caso contrário), idioma de fallback (inglês) se uma chave estiver ausente do dicionário atual, e dicionários vazios na inicialização - [language.composable.ts] (veja abaixo) substitui imediatamente [locale] pela seleção armazenada em localStorage, se houver;
  • linhas 14–22: [export async function loadDictionary(language: Language): Promise<void> { …] — ao contrário do [i18next-http-backend] (React) ou do [TranslateHttpLoader] (Angular), o [vue-i18n] NÃO fornece nativamente um “loader”: ele simplesmente espera receber os dicionários já carregados, por meio de [setLocaleMessage(...)]. Esta função reconstrói, portanto, manualmente o que o [HttpBackend] fazia automaticamente no lado do [React]: ela usa [fetch] para recuperar o arquivo [/i18n/<language>.json] (EXATAMENTE a mesma URL das outras duas variantes deste curso) e depois salva seu conteúdo no [vue-i18n];
  • linhas 15–17: [if (loadedDictionaries.has(language)) { return; }] — evita baixar novamente um idioma já encontrado durante a sessão — a mesma otimização do cache interno do [i18next-http-backend] no lado do [React].

6.4.4. src/index.css

body {
  background-color: #f5f7fa;
}

.free-slot {
  cursor: pointer;
}

.free-slot:hover {
  background-color: #e9f7ef;
}

Vamos comentar este código:

  • linha 1: [body { background-color: #f5f7fa; }] — idêntico às outras duas variantes: um cinza muito claro em vez do branco puro padrão, para que os cards do [Bootstrap] (fundo branco, .card) se destaquem levemente do fundo da página;
  • linhas 5–11: [.free-slot { cursor: pointer; } .free-slot:hover { … }] — aplicado às linhas da tabela da agenda que representam um horário disponível (veja Schedule.vue, [:class="scheduleSlot.appointment === null ? ‘free-slot’ : undefined"] abaixo): o cursor assume a forma de uma mão em toda a linha, e o fundo fica levemente verde ao passar o mouse — aqui, ao contrário do cliente [React] deste curso (em que o cursor “pointer” era aplicado ao próprio botão “Reservar”), a linha inteira da tabela é clicável, como pretendido no documento original.

Este arquivo contém estilos globais, em oposição aos estilos “locais” que um componente [Vue.js] pode definir em seu próprio bloco [<style scoped>] (não usado neste projeto: [Bootstrap] e index.css bastam para tudo o que este documento implementa) — o mesmo princípio do [Angular] e do [React] (arquivos de estilo separados por componente).

6.5. A camada core/models

6.5.1. src/app/core/models/appointment.models.ts

// envelope comum a todas as respostas do servidor (veja ServerResponse<T> no lado NestJS)
export interface ServerResponse<T> {
  status: number; // 0 = sucesso, qualquer outro valor = falha (veja ResponseStatus no lado do servidor)
  data: T | null;
}

export interface Doctor {
  id: number;
  title: string;
  lastName: string;
  firstName: string;
}

// [Client] aqui significa um PACIENTE do consultório médico - não confundir com "cliente HTTP"!
export interface Client {
  id: number;
  title: string;
  lastName: string;
  firstName: string;
}

export interface SlotJson {
  id: number;
  startHour: number;
  startMinute: number;
  endHour: number;
  endMinute: number;
}

export interface AppointmentJson {
  id: number;
  day: string; // formato "yyyy-MM-dd"
  client: Client | null;
  slot: SlotJson | null;
}

export interface ScheduleSlot {
  slot: SlotJson;
  appointment: AppointmentJson | null;
}

export interface DoctorDaySchedule {
  doctor: Doctor;
  day: string;
  slots: ScheduleSlot[];
}

export type Role = 'ADMIN' | 'USER';

export interface LoginResult {
  accessToken: string;
  login: string;
  name: string;
  role: Role;
}

Vamos comentar este código:

  • As interfaces em si são uma cópia ESTRITA das variantes [Angular] e [React] deste curso (simplesmente reescritas, como todo o cliente): as interfaces TypeScript que descrevem os dados trocados com o servidor não dependem de nenhum framework — é TypeScript “puro”, que corresponde exatamente à classe [ServerResponse]<T> e às entidades [TypeORM] do servidor [NestJS] (Capítulo 3);
  • [Role]/[LoginResult]—cópias exatas dos tipos do servidor de mesmo nome (src/entities/user.entity.ts, auth/login-result.model.ts, Capítulo 3).

No AngularJS 1.x (2014), o JavaScript puro não permitia descrever dessa forma o formato de dados esperado. Com o TypeScript—usado pelas três variantes deste curso—, um erro de digitação no nome de um campo é sinalizado antes mesmo de o programa ser executado, já na compilação.

6.6. A camada core/composables

Para este cliente, [Vue.js], este diretório desempenha o mesmo papel que core/context/ desempenhava para o cliente [React] neste curso (veja o capítulo anterior, “Compartilhando lógica”): ele reúne os três composables que servem, neste caso, como serviços injetáveis ([SettingsService], [AuthService] e parte de [LanguageService]) do lado [Angular].

6.6.1. src/app/core/composables/settings.composable.ts

import { inject, reactive, type InjectionKey } from 'vue';

export interface SettingsStore {
  apiBaseUrl: string;
  setApiBaseUrl: (url: string) => void;
}

export const SettingsKey: InjectionKey<SettingsStore> = Symbol('SettingsStore');

export function createSettingsStore(): SettingsStore {
  const store = reactive<SettingsStore>({
    apiBaseUrl: 'http://localhost:8080',
    setApiBaseUrl(url: string) {
      store.apiBaseUrl = url;
    },
  });
  return store;
}

export function useSettings(): SettingsStore {
  const store = inject(SettingsKey);
  if (!store) {
    throw new Error('useSettings() must be called after app.provide(SettingsKey, ...) (see src/main.ts)');
  }
  return store;
}

Vamos comentar este código:

  • linha 8: [export const SettingsKey: InjectionKey<SettingsStore> = Symbol('SettingsStore');] — a chave de injeção (veja o capítulo anterior) — um [Symbol] tipado, em vez de uma simples string;
  • linhas 10–18: [export function createSettingsStore(): SettingsStore { …] — substitui exatamente [readonly apiBaseUrl = signal(‘http://localhost:8080’);] por [SettingsService] do lado [Angular]: o mesmo valor padrão, com a mesma possibilidade de modificá-lo pelo campo “Server URL” da view inicial do documento original; [reactive(...)] (em vez de [ref()]) é escolhido aqui porque o store inclui VÁRIAS propriedades (apiBaseUrl e sua função de atualização)—[store.apiBaseUrl] é lido e escrito diretamente, sem [.value];
  • Linhas 20–26: [export function useSettings(): SettingsStore { …] — o composable que os componentes chamam ([const settings = useSettings();]), equivalente direto de [inject(SettingsService)] do lado [Angular] e de [useSettings()] do lado [React].

6.6.2. src/app/core/composables/auth.composable.ts

Port de [AuthService]: trata o login do usuário, chama [POST /login], armazena o token JWT recebido (e a identidade/papel que o acompanha) e garante que ele sobreviva a um recarregamento da página usando [localStorage]. Este é o único lugar da aplicação que, junto com [core/services/appointment.service.ts] (veja abaixo), se comunica com o servidor por HTTP.

import { inject, reactive, type InjectionKey } from 'vue';
import type { LoginResult, ServerResponse, Role } from '../models/appointment.models';
import type { SettingsStore } from './settings.composable';

interface StoredSession {
  accessToken: string;
  login: string;
  name: string;
  role: Role;
}

const STORAGE_KEY = 'rdvmedecins.session';

function readStoredSession(): StoredSession | null {
  try {
    const raw = localStorage.getItem(STORAGE_KEY);
    return raw ? (JSON.parse(raw) as StoredSession) : null;
  } catch {
    return null;
  }
}

export interface AuthStore {
  isLoggedIn: boolean;
  login: string | null;
  name: string | null;
  role: Role | null;
  isAdmin: boolean;
  accessToken: string | null;
  logIn: (login: string, password: string) => Promise<LoginResult>;
  logOut: () => void;
}

export const AuthKey: InjectionKey<AuthStore> = Symbol('AuthStore');

export function createAuthStore(settings: SettingsStore): AuthStore {
  const initialSession = readStoredSession();

  function applySession(session: StoredSession | null): void {
    store.isLoggedIn = session !== null;
    store.login = session?.login ?? null;
    store.name = session?.name ?? null;
    store.role = session?.role ?? null;
    store.isAdmin = session?.role === 'ADMIN';
    store.accessToken = session?.accessToken ?? null;
    if (session) {
      localStorage.setItem(STORAGE_KEY, JSON.stringify(session));
    } else {
      localStorage.removeItem(STORAGE_KEY);
    }
  }

  const store = reactive<AuthStore>({
    isLoggedIn: initialSession !== null,
    login: initialSession?.login ?? null,
    name: initialSession?.name ?? null,
    role: initialSession?.role ?? null,
    isAdmin: initialSession?.role === 'ADMIN',
    accessToken: initialSession?.accessToken ?? null,

    async logIn(login: string, password: string): Promise<LoginResult> {
      const httpResponse = await fetch(`${settings.apiBaseUrl}/login`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ login, password }),
      });
      const envelope = (await httpResponse.json()) as ServerResponse<LoginResult>;
      if (envelope.status !== 0 || envelope.data === null) {
        throw new Error('Login failed');
      }
      const result = envelope.data;
      applySession(result);
      return result;
    },

    logOut(): void {
      applySession(null);
    },
  });

  return store;
}

export function useAuth(): AuthStore {
  const store = inject(AuthKey);
  if (!store) {
    throw new Error('useAuth() must be called after app.provide(AuthKey, ...) (see src/main.ts)');
  }
  return store;
}

Vamos analisar este código:

  • linhas 14–21: [function readStoredSession(): StoredSession | null { …] — protegida por um bloco try/catch, assim como [Angular] e [React]: [localStorage] pode estar indisponível (navegação privada muito restritiva) ou conter um valor corrompido—nesse caso, simplesmente assumimos que não há sessão;
  • linha 37: [const initialSession = readStoredSession();] — chamada apenas uma vez, quando o store é construído (em src/main.ts) - exatamente o mesmo papel desempenhado pelo inicializador [useState(readStoredSession)] do lado [React] ou por [signal(readStoredSession())] do lado [Angular]. Se o usuário recarrega a página depois de fazer login, ele continua conectado;
  • linhas 39–51: [function applySession(session: StoredSession | null): void { …] — extrai o que [logIn()] e [logOut()] têm em comum: atualizar as propriedades reativas do store E sincronizar [localStorage] em uma única etapa—uma pequena função interna, ausente da versão equivalente [React] (que repetia essa lógica em cada uma das duas funções, por falta de um ponto de escrita comum igualmente natural);
  • linhas 53–79: [const store = reactive<AuthStore>({ … });] — mesmo princípio de settings.composable.ts: um único objeto [reactive], no qual cada propriedade (isLoggedIn, login, accessToken…) é modificada—NO LUGAR—por [applySession()] em vez de substituída por um novo objeto—ao contrário de [AuthContext] do lado [React], que precisa reconstruir um novo objeto [value] com [useMemo]() a cada alteração (veja o capítulo anterior); [Vue.js] não precisa fazer isso aqui: apenas os componentes que leem uma propriedade que realmente mudou são redesenhados automaticamente;
  • linhas 61–74: [async logIn(login: string, password: string): Promise<LoginResult> { …] — equivale a: POST /login, corpo JSON { login, password }; como no lado [React] (fetch/async-await), as etapas fluem naturalmente de cima para baixo, sem um operador RxJS dedicado (ao contrário de [AuthService.logIn()] do lado [Angular], que retorna um Observable e salva a sessão em um operador tap() separado);
  • linhas 76–78: [logOut(): void { applySession(null); },] — puramente local (sem chamada ao servidor): um token JWT não é “revogado” no lado do servidor neste port; ele expira por conta própria após JWT_EXPIRES_IN (veja o .env do servidor, Capítulo 3).

6.6.3. src/app/core/composables/language.composable.ts

Port de parte de [LanguageService]: centraliza a troca de idioma da interface (francês/inglês) sobre [vue-i18n] (veja i18n.ts acima).

import { inject, reactive, watch, type InjectionKey } from 'vue';
import { loadDictionary, i18n, type Language } from '../../../i18n';

const STORAGE_KEY = 'rdvmedecins.language';

export interface LanguageStore {
  currentLanguage: Language;
  changeLanguage: (language: Language) => void;
}

export const LanguageKey: InjectionKey<LanguageStore> = Symbol('LanguageStore');

export function createLanguageStore(): LanguageStore {
  const store = reactive<LanguageStore>({
    currentLanguage: i18n.global.locale.value as Language,
    changeLanguage(language: Language) {
      localStorage.setItem(STORAGE_KEY, language);
      applyLanguage(language);
    },
  });

  function applyLanguage(language: Language): void {
    void loadDictionary(language).then(() => {
      i18n.global.locale.value = language;
      document.documentElement.lang = language;
    });
  }

  watch(i18n.global.locale, (newLanguage) => {
    store.currentLanguage = newLanguage as Language;
  });

  const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null;
  if (savedLanguage && savedLanguage !== store.currentLanguage) {
    applyLanguage(savedLanguage);
  } else {
    applyLanguage(store.currentLanguage);
  }

  return store;
}

export function useLanguage(): LanguageStore {
  const store = inject(LanguageKey);
  if (!store) {
    throw new Error('useLanguage() must be called after app.provide(LanguageKey, ...) (see src/main.ts)');
  }
  return store;
}

Vamos comentar este código:

  • Linha 15: [currentLanguage: i18n.global.locale.value as Language,] — [vue-i18n] já expõe seu idioma atual como um [ref] reativo ([i18n.global.locale]): [LanguageStore] não cria um estado separado; ele simplesmente o REPUBLICA sob um nome estável (currentLanguage)—exatamente o mesmo conceito que no [Angular], em que [LanguageService] simplesmente republicava [this.translate.currentLang] sob outro nome;
  • linhas 22–27: [function applyLanguage(language: Language): void { …] — [loadDictionary(language)] (veja i18n.ts) obtém, se necessário, o dicionário correspondente; ENTÃO, uma vez resolvido, passamos para [i18n.global.locale.value]—ao contrário de [i18n.changeLanguage(...)] do lado [React] (que faz as duas coisas de uma vez); aqui, como [vue-i18n] não tem um “loader” embutido (veja i18n.ts), este composable orquestra as duas etapas por conta própria;
  • linhas 29–31: [watch(i18n.global.locale, (newLanguage) => { store.currentLanguage = newLanguage as Language; });] — [watch(source, callback)] reexecuta o callback toda vez que o valor observado muda—o equivalente, para uma única propriedade, de [useEffect](..., [dep]) do lado [React] ou de [effect()] do lado [Angular]. Esta linha é o que realmente realiza a “republicação” mencionada no início deste arquivo: [store.currentLanguage] permanece SEMPRE sincronizado com [i18n.global.locale], independentemente de como este último tenha mudado;
  • linhas 33–38: [const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null; …] — no primeiríssimo carregamento: se o usuário já havia selecionado um idioma em uma visita anterior, ele é restaurado; caso contrário, mantém-se o idioma inicial definido em i18n.ts (inglês, ou francês para um navegador em francês)—mas SEU dicionário ainda precisa ser carregado, o que o próprio i18n.ts não faz—exatamente o papel desempenhado por [useEffect](..., []) de language.context.tsx do lado [React], executado apenas uma vez durante a configuração.

Equivalente ao botão “FR / EN” do cliente AngularJS 1.x original, que na época se baseava na biblioteca [angular-translate] —a predecessora, dentro do ecossistema AngularJS 1.x, de [ngx-translate] ([Angular]), seguida por [i18next] ([React]) e [vue-i18n] ([Vue.js]).

6.7. Dicionários de tradução (public/i18n/)

[loadDictionary()] (veja i18n.ts acima) carrega um desses dois arquivos por meio de uma requisição [HTTP GET /i18n/<language>.json] sempre que o idioma muda (ou é usado pela primeira vez). [vue-i18n] resolve então cada chave ("LOGIN.TITLE", "SCHEDULE.FREE"…) por meio do hook [useI18n() (function t(...))] usado em todos os componentes do diretório features/ (veja mais adiante neste capítulo).

6.7.1. public/i18n/fr.json

{
  "APP": {
    "TITLE": "RdvMedecins - portage NestJS / Vue.js",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "SUBMITTING": "Connexion...",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
    "DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
    "DEMO_ACCOUNTS_OR": "ou",
    "DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
  },
  "DOCTOR_DAY_PICKER": { "...": "..." },
  "SCHEDULE": { "...": "..." },
  "BOOKING_DIALOG": { "...": "..." }
}

Vamos comentar este código:

  • Este arquivo espelha, chave a chave, os arquivos das variantes [Angular] e [React] deste curso (as mesmas seções de DOCTOR_DAY_PICKER/SCHEDULE/BOOKING_DIALOG, não reproduzidas aqui por razões de espaço; veja o arquivo fornecido para os detalhes), com duas exceções: a linha 3 ([TITLE]), que agora se refere a [Vue.js] em vez de [React]; e quatro chaves novas ([DEMO_ACCOUNTS_*], linhas 14–17) exibidas por Login.vue (veja abaixo) para mostrar as duas contas de demonstração diretamente na tela de login—um pequeno recurso de conveniência que não existe nas outras duas versões deste curso;
  • Um objeto JSON aninhado, com uma seção por componente; [vue-i18n] o achata em um dicionário plano, em que cada chave completa ("LOGIN.TITLE") é formada pela concatenação do caminho com pontos—exatamente como [i18next] o faz [React], e como [TranslateService] o faz [Angular].

6.7.2. public/i18n/en.json

1
2
3
4
5
6
{
  "APP": {
    "TITLE": "RdvMedecins - NestJS / Vue.js port",
    "...": "..."
  }
}

Vamos analisar este código:

  • linha 3: ["TITLE": "RdvMedecins - NestJS / Vue.js port",] — apenas o subtítulo muda: “[RdvMedecins]” permanece igual nos dois idiomas; é o nome próprio da aplicação.

Os dois arquivos devem permanecer estruturalmente idênticos (as mesmas chaves em ambos): isso garante que uma chave exista nos dois idiomas. As partes que NÃO são traduzidas permanecem inalteradas em relação às variantes [Angular] e [React] deste curso: as mensagens de erro retornadas pelo servidor [NestJS] permanecem em inglês, qualquer que seja o idioma selecionado no cliente, e os nomes dos médicos e dos pacientes vêm diretamente do banco de dados.

6.8. A camada core/interceptors

6.8.1. src/app/core/interceptors/auth.interceptor.ts

Nem [Vue.js] nem [React] possuem um interceptor HTTP embutido como [HttpClient]/[withInterceptors([...])] do lado [Angular]. Este arquivo reimplementa o mesmo conceito como um composable que encapsula [fetch]: é o equivalente moderno dos interceptors de $http do AngularJS 1.x já encontrados no documento original (capítulo “Exemplo 6”).

import { useAuth } from '../composables/auth.composable';

export function useAuthFetch(): (path: string, options?: RequestInit) => Promise<Response> {
  const auth = useAuth();

  return async function authFetch(path: string, options: RequestInit = {}): Promise<Response> {
    const headers = new Headers(options.headers);
    if (auth.accessToken) {
      headers.set('Authorization', `Bearer ${auth.accessToken}`);
    }

    const response = await fetch(path, { ...options, headers });

    if (response.status === 401) {
      auth.logOut();
    }

    return response;
  };
}

Vamos analisar este código:

  • linha 3: [export function useAuthFetch(): (path: string, options?: RequestInit) => Promise<Response> {] — ao contrário de [authInterceptor] do lado [Angular] (uma função registrada de uma vez por todas em [app.config.ts], que é então aplicada automaticamente a cada chamada de [HttpClient]), [useAuthFetch()] é um composable que cada chamador (aqui, [useAppointmentService()], veja abaixo) deve chamar explicitamente e usar no lugar de [fetch()]—a mesma abordagem do lado [React]; ao contrário do [React] ([useCallback](...)), aqui não é necessário guardar a função retornada: o corpo de um [<script setup>] é executado apenas UMA vez por instância de componente, portanto é construído apenas uma vez;
  • linhas 8–10: [if (auth.accessToken) { headers.set(‘Authorization’, …); }] — o equivalente direto de [request.clone({ setHeaders: { Authorization: … } })] do lado [Angular]. Ao contrário de uma requisição [HttpClient] (que é imutável), as opções de [fetch] são simplesmente um objeto JavaScript: não há necessidade de criar uma cópia “clonada” dele; basta construir o objeto [headers] antes da chamada;
  • linhas 14–16: [if (response.status === 401) { auth.logOut(); }] — mesmo princípio de [Angular] (catchError + HttpErrorResponse.status === 401): um 401 durante uma sessão significa que o token não é mais válido; o cliente é desconectado de forma elegante; [fetch] não rejeita sua Promise como erro por causa de um status HTTP (ao contrário de um Observable [HttpClient])—e por isso este teste examina [response.status] diretamente, sem um bloco try/catch;
  • linha 18: [return response;] — a resposta (potencialmente um 401) é mesmo assim devolvida como está ao chamador, que continua responsável por tratar as consequências (veja useAppointmentService(), extract<T>(), abaixo) - O interceptor não deve esconder o erro do código chamador.

Seria possível adicionar manualmente [Authorization: Bearer ...] a cada um dos métodos de [useAppointmentService()]. Um composable compartilhado evita essa repetição, oferecendo o mesmo benefício de um interceptor [Angular]: a pergunta “Como autenticamos uma requisição?” é respondida em um único lugar.

6.9. A camada core/services

6.9.1. src/app/core/services/appointment.service.ts

Port de [AppointmentService]: a ÚNICA parte da aplicação (junto com [core/composables/auth.composable.ts] para o login em si) que se comunica com o servidor via HTTP e com [NestJS]. É o equivalente direto do serviço [dao] apresentado no capítulo “Exemplo 6: Serviços HTTP” do documento original (que usava o serviço $http do AngularJS).

import { useAuthFetch } from '../interceptors/auth.interceptor';
import { useSettings } from '../composables/settings.composable';
import type { DoctorDaySchedule, Client, Doctor, ServerResponse, AppointmentJson } from '../models/appointment.models';

async function extract<T>(httpResponse: Response): Promise<T> {
  const envelope = (await httpResponse.json()) as ServerResponse<T>;
  if (envelope.status !== 0) {
    throw new Error(`The server responded with error status ${envelope.status}`);
  }
  return envelope.data as T;
}

export function useAppointmentService() {
  const authFetch = useAuthFetch();
  const settings = useSettings();

  async function getAllDoctors(): Promise<Doctor[]> {
    const httpResponse = await authFetch(`${settings.apiBaseUrl}/getAllDoctors`);
    return extract<Doctor[]>(httpResponse);
  }

  async function getAllClients(): Promise<Client[]> {
    const httpResponse = await authFetch(`${settings.apiBaseUrl}/getAllClients`);
    return extract<Client[]>(httpResponse);
  }

  async function getDoctorScheduleOfDay(doctorId: number, day: string): Promise<DoctorDaySchedule> {
    const httpResponse = await authFetch(
      `${settings.apiBaseUrl}/getDoctorScheduleOfDay/${doctorId}/${day}`,
    );
    return extract<DoctorDaySchedule>(httpResponse);
  }

  async function addAppointment(day: string, clientId: number, slotId: number): Promise<AppointmentJson> {
    const httpResponse = await authFetch(`${settings.apiBaseUrl}/addAppointment`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ day, clientId, slotId }),
    });
    return extract<AppointmentJson>(httpResponse);
  }

  async function deleteAppointment(appointmentId: number): Promise<void> {
    const httpResponse = await authFetch(`${settings.apiBaseUrl}/deleteAppointment`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ appointmentId }),
    });
    await extract<null>(httpResponse);
  }

  return { getAllDoctors, getAllClients, getDoctorScheduleOfDay, addAppointment, deleteAppointment };
}

Vamos comentar este código:

  • linha 5: [async function extract<T>(httpResponse: Response): Promise<T> {] — em vez de repetir o “se status !== 0, é um erro” em cada função pública, nós o centralizamos aqui uma única vez—que é exatamente o papel de [AppointmentService.extract()] em relação ao [Angular] e de [extract<T>()] em relação ao [React];
  • Linha 13: [export function useAppointmentService() {]—um composable que é lido e usado exatamente como [inject(AppointmentService)] do lado [Angular]: ele é chamado uma vez no início do [<script setup>] de um componente, e depois as funções que ele retorna são utilizadas;
  • linhas 17–20: [async function getAllDoctors(): Promise<Doctor[]> { …] — ao contrário do [React] ([useCallback](..., [authFetch, apiBaseUrl])), nenhuma dessas funções precisa ser guardada em cache entre renderizações: um [<script setup>] [Vue.js] é executado apenas uma vez por instância de componente (veja auth.interceptor.ts acima) - esse detalhe técnico, necessário do lado [React], desaparece completamente aqui;
  • cada função corresponde exatamente a uma das onze rotas do controller [NestJS] (Capítulo 3)—na verdade, os mesmos nomes aparecem nos dois lados (getAllDoctors, addAppointment, deleteAppointment…), o que facilita comparar o lado do servidor e o do cliente, assim como com [Angular] e [React].

Ao contrário de [AuthStore.logIn()] (capítulo anterior), nenhum dos métodos deste composable precisa reter dados após a chamada: é o componente chamador (App.vue) que decide o que fazer com o resultado (doctors.value = result, schedule.value = result…) - a mesma separação de responsabilidades vista com [Angular] e [React], em que [AppointmentService] e [useAppointmentService()] não sabem nada sobre o estado exibido na tela.

6.10. A camada features: os quatro componentes

6.10.1. src/app/features/login/Login.vue

Port de [login.component.ts/.html] ([Angular]) e de [Login.tsx] ([React]): a tela de login, equivalente à view [login.html] do cliente AngularJS 1.x original (a primeira view exibida pela aplicação). Este componente não conhece nada sobre a agenda ou as consultas: ele apenas coleta um par (nome de usuário, senha), o encaminha para [AuthStore.logIn(...)] e exibe eventuais erros.

<script setup lang="ts">
import { ref } from 'vue';
import { useI18n } from 'vue-i18n';
import { useAuth } from '../../core/composables/auth.composable';

const { t } = useI18n();
const auth = useAuth();

const login = ref('');
const password = ref('');
const submitting = ref(false);
const error = ref<string | null>(null);

async function onSubmit(): Promise<void> {
  if (login.value.trim() === '' || password.value === '') {
    return;
  }
  error.value = null;
  submitting.value = true;
  try {
    await auth.logIn(login.value, password.value);
    submitting.value = false;
  } catch {
    submitting.value = false;
    error.value = 'LOGIN.ERROR';
  }
}
</script>

<template>
  <div class="row justify-content-center">
    <div class="col-sm-8 col-md-6 col-lg-4">
      <form class="card p-4" @submit.prevent="onSubmit">
        <h5 class="card-title mb-3">{{ t('LOGIN.TITLE') }}</h5>

        <div v-if="error" class="alert alert-danger py-2" role="alert">
          {{ t(error) }}
        </div>

        <div class="mb-3">
          <label class="form-label" for="input-login">
            {{ t('LOGIN.LOGIN_LABEL') }}
          </label>
          <input id="input-login" type="text" class="form-control"
            autocomplete="username" v-model="login" />
        </div>

        <div class="mb-3">
          <label class="form-label" for="input-password">
            {{ t('LOGIN.PASSWORD_LABEL') }}
          </label>
          <input id="input-password" type="password" class="form-control"
            autocomplete="current-password" v-model="password" />
        </div>

        <button type="submit" class="btn btn-primary w-100" :disabled="submitting">
          {{ submitting ? t('LOGIN.SUBMITTING') : t('LOGIN.SUBMIT') }}
        </button>

        <p class="text-muted small mt-3 mb-0">
          {{ t('LOGIN.DEMO_ACCOUNTS_PREFIX') }} <code>admin</code> / <code>admin</code>
          {{ t('LOGIN.DEMO_ACCOUNTS_ADMIN') }} {{ t('LOGIN.DEMO_ACCOUNTS_OR') }} <code>user</code> /
          <code>user</code> {{ t('LOGIN.DEMO_ACCOUNTS_USER') }}.
        </p>
      </form>
    </div>
  </div>
</template>

Vamos analisar este código:

  • linha 6: [const { t } = useI18n();] — um componente standalone [Angular] declara, em seu decorador [@Component], os pipes que utiliza ([imports: [TranslatePipe]]); um componente [Vue.js], assim como um componente [React], não tem nada equivalente a declarar: [useI18n()] é simplesmente importado e chamado, como qualquer outra função;
  • linhas 9–12: [const login = ref(''); const password = ref(''); …] — um estado puramente local do formulário (o que o usuário está digitando no momento) — o equivalente dos valores [signal()] locais do componente [Angular] e de [useState()] do lado [React] (aqui, um [ref] por valor em vez de um [value, setValue] par);
  • linha 33: [@submit.prevent="onSubmit"] — uma diferença deliberada em relação à variante [Angular] deste curso: em vez de escutar (keyup.enter) cada campo separadamente, este componente usa um verdadeiro elemento <form> e seu evento nativo [submit]—tanto a tecla Enter quanto um clique no botão “Log in” (type="submit") disparam então [onSubmit()]; o modificador [.prevent] impede automaticamente o comportamento padrão do navegador (recarregar a página)—o equivalente do [event?.preventDefault()] explícito do lado do cliente, mas expresso diretamente no [<template>] em vez de no código TypeScript;
  • linhas 44–45: [autocomplete="username" v-model="login"] — [v-model] vincula o campo e o [login] [ref] nos dois sentidos (leitura E escrita) em um único atributo—uma simplificação em comparação com [React] ([value={login} onChange={(e) => setLogin(e.target.value)}], dois atributos separados) e com [Angular] ([[(ngModel)]] ou [[value]]+(input), conforme o caso);
  • linhas 23–26: [catch { submitting.value = false; error.value = ‘LOGIN.ERROR’; }] — um par nome de usuário/senha inválido faz [logIn()] falhar com uma exceção JavaScript (lançada por auth.composable.ts, veja acima): “LOGIN.ERROR” é exibido ao usuário, sem tentar distinguir entre um nome de usuário inexistente e uma senha incorreta—exatamente a mesma abordagem dos casos de [Angular] e [React]. Armazenar uma CHAVE de tradução em vez de um texto já resolvido tem a mesma vantagem que nas outras duas variantes: se o usuário trocar de idioma enquanto esta mensagem é exibida, ela se traduz automaticamente ([t(error)], linha 37, reavaliado automaticamente).

Este componente reúne em um ÚNICO arquivo [.vue] o que o [Angular] separa em dois (login.component.ts para a lógica, login.component.html para o template): [<template>] É para o template, [<script setup>] É para a lógica, no mesmo arquivo—exatamente como [Login.tsx] já fazia do lado [React] com o [JSX] retornado por sua função.

6.10.2. src/app/features/doctor-day-picker/DoctorDayPicker.vue

Port de [doctor-day-picker.component.ts/.html] ([Angular]) e de [DoctorDayPicker.tsx] ([React]): o componente que permite selecionar um médico e uma data e depois solicitar a visualização de sua agenda. Conceitualmente equivalente aos exemplos 7 a 10 do cliente AngularJS 1.x original.

<script setup lang="ts">
import { ref } from 'vue';
import { useI18n } from 'vue-i18n';
import type { Doctor } from '../../core/models/appointment.models';

defineProps<{
  doctors: Doctor[];
}>();

const emit = defineEmits<{
  search: [criteria: { doctorId: number; day: string }];
}>();

const { t } = useI18n();

const selectedDoctorId = ref<number | null>(null);
const selectedDay = ref<string>(
  new Date().toISOString().slice(0, 10),
);

function onSearchClick(): void {
  if (selectedDoctorId.value === null) {
    return;
  }
  emit('search', { doctorId: selectedDoctorId.value, day: selectedDay.value });
}
</script>

<template>
  <div class="card p-3 mb-3">
    <div class="row g-2 align-items-end">
      <div class="col-sm-5">
        <label class="form-label" for="select-doctor">
          {{ t('DOCTOR_DAY_PICKER.DOCTOR_LABEL') }}
        </label>
        <select id="select-doctor" class="form-select" v-model="selectedDoctorId">
          <option :value="null">{{ t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR') }}</option>
          <option v-for="doctor in doctors" :key="doctor.id" :value="doctor.id">
            {{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}
          </option>
        </select>
      </div>

      <div class="col-sm-4">
        <label class="form-label" for="input-day">
          {{ t('DOCTOR_DAY_PICKER.DAY_LABEL') }}
        </label>
        <input id="input-day" type="date" class="form-control" v-model="selectedDay" />
      </div>

      <div class="col-sm-3">
        <button type="button" class="btn btn-primary w-100"
          :disabled="selectedDoctorId === null" @click="onSearchClick">
          {{ t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE') }}
        </button>
      </div>
    </div>
  </div>
</template>

Vamos analisar este código:

  • linhas 6–8: [defineProps<{ doctors: Doctor[]; }>();] — um [input.required<Doctor[]>()] [Angular] torna-se uma PROP [Vue.js]; ao contrário do [React] (um objeto `props` desestruturado, sem declaração de tipo separada), [defineProps<...>()] é uma função reconhecida pelo compilador do [Vue.js] em tempo de compilação: ela nem sequer existe mais no JavaScript final;
  • Linhas 10–12: [const emit = defineEmits<{ search: [criteria: { … }]; }>();] — um [output<...>()] [Angular] torna-se aqui um EVENTO declarado - [App.vue] o escutará com [@search="onSearchSchedule"] (veja abaixo), exatamente como se inscrevia no evento (search) do template [Angular]; já no [React], tratava-se de uma simples prop de função ([onSearch]) - [Vue.js] distingue aqui, de forma mais explícita, entradas e saídas, como o [Angular];
  • linhas 21–26: [function onSearchClick(): void { … emit(‘search’, { … }); }] — [emit(‘search’, ...)] dispara o evento—o equivalente direto de [search.emit(...)] do lado [Angular] e da chamada de função recebida como prop ([onSearch(...)]) do lado [React];
  • linha 36: [select id="select-doctor" class="form-select" v-model="selectedDoctorId"] — [v-model] em um <select> vincula diretamente o valor selecionado a [selectedDoctorId.value]—uma simplificação em comparação com o [React] (:value e @change separados, veja o capítulo anterior) e com o [Angular] ([(ngModel)] ou [value]+(change), conforme o caso);
  • linhas 38–40: [option v-for="doctor in doctors" :key="doctor.id" :value="doctor.id"] — [v-for] + [:key] é o equivalente no [Vue.js] de [.map(...)] + [key={...}] do lado [React] (e de [@for (doctor of doctors(); track doctor.id)] do lado [Angular]): nos três casos, um identificador estável especifica como reconhecer um médico já exibido caso ele seja redesenhado.

6.10.3. src/app/features/schedule/Schedule.vue

Port de [schedule.component.ts/.html] ([Angular]) e de [Schedule.tsx] ([React]): exibe a agenda de um médico em um determinado dia. Equivalente aos exemplos 8 e 9 do cliente AngularJS 1.x original. Desde que a autenticação foi adicionada, este componente também recebe [canEdit]: quando definido como false (papel USER), os botões “Book”/“Cancel” desaparecem—a agenda continua visível, mas em modo somente leitura.

<script setup lang="ts">
import { useI18n } from 'vue-i18n';
import type { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';

defineProps<{
  schedule: DoctorDaySchedule | null;
  canEdit: boolean;
}>();

const emit = defineEmits<{
  book: [slot: SlotJson];
  cancel: [appointment: AppointmentJson];
}>();

const { t } = useI18n();

function formatTime(h: number, m: number): string {
  return `${h}:${m.toString().padStart(2, '0')}`;
}

function onSlotClick(scheduleSlot: ScheduleSlot, canEdit: boolean): void {
  if (!canEdit) {
    return;
  }
  if (scheduleSlot.appointment === null) {
    emit('book', scheduleSlot.slot);
  } else {
    emit('cancel', scheduleSlot.appointment);
  }
}
</script>

<template>
  <p v-if="schedule === null" class="text-muted">{{ t('SCHEDULE.EMPTY_STATE') }}</p>

  <div v-else class="card p-3">
    <h5>
      {{ t('SCHEDULE.TITLE_PREFIX') }} {{ schedule.day }} - {{ schedule.doctor.title }}
      {{ schedule.doctor.firstName }} {{ schedule.doctor.lastName }}
    </h5>

    <table class="table table-hover align-middle">
      <thead>
        <tr>
          <th>{{ t('SCHEDULE.COLUMN_SLOT') }}</th>
          <th>{{ t('SCHEDULE.COLUMN_STATUS') }}</th>
          <th></th>
        </tr>
      </thead>
      <tbody>
        <tr v-for="scheduleSlot in schedule.slots" :key="scheduleSlot.slot.id"
          :class="scheduleSlot.appointment === null ? 'free-slot' : undefined">
          <td>
            {{ formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute) }} -
            {{ formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute) }}
          </td>
          <td>
            <span v-if="scheduleSlot.appointment === null" class="badge text-bg-success">
              {{ t('SCHEDULE.FREE') }}
            </span>
            <span v-else class="badge text-bg-secondary">
              {{ scheduleSlot.appointment.client?.title }} {{ scheduleSlot.appointment.client?.firstName }}
              {{ scheduleSlot.appointment.client?.lastName }}
            </span>
          </td>
          <td>
            <button v-if="canEdit" type="button"
              :class="'btn btn-sm ' + (scheduleSlot.appointment === null ? 'btn-outline-success' : 'btn-outline-danger')"
              @click="onSlotClick(scheduleSlot, canEdit)">
              {{ scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT') }}
            </button>
          </td>
        </tr>
      </tbody>
    </table>
  </div>
</template>

Vamos comentar este código:

  • linhas 34, 36: [p v-if="schedule === null" … div v-else …] — [v-if]/[v-else] substituem o “retorno antecipado” (early return) usado no [React] ([if (schedule === null) return <p>...</p>;]): enquanto nenhuma busca tiver sido realizada (ou a agenda estiver vazia), apenas a mensagem de estado vazio é incluída no DOM, sem sequer construir a tabela que vem a seguir;
  • linha 7: [canEdit: boolean;] — um recurso novo introduzido pela autenticação, semelhante ao [Angular] e ao [React]: App.vue envia [auth.isAdmin] a ele (veja abaixo). Quando definido como false (papel USER), o botão “Book”/“Cancel” nem sequer existe no DOM (linha 67, [v-if="canEdit"])—ele não fica apenas acinzentado ou desabilitado, está completamente ausente;
  • Linhas 58–64: [span v-if="scheduleSlot.appointment === null" … span v-else …] — [v-if]/[v-else] substituem o operador ternário usado do lado [React]—badge [Bootstrap] verde (“Free”) ou cinza (nome do paciente), conforme o estado do horário;
  • linha 67: [button v-if="canEdit" type="button"] — ao contrário do [React] (o operador [&&], {canEdit && (…)}), [v-if] basta, por si só, aqui no [Vue.js]: não existe um equivalente no [Vue.js] de [&&] a usar para “exibir somente se verdadeiro, caso contrário nada”—[v-if] faz exatamente isso sozinho;
  • linha 70: [{{ scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT') }}] — como no lado [Angular] (em que um pipe pode ser usado em qualquer expressão de template) e no lado [React], [t(...)] é uma função JavaScript comum: ela pode ser usada diretamente em uma expressão [{{ }}], sem nenhuma sintaxe especial.

Este componente não faz nenhuma chamada HTTP por conta própria: ele exibe os dados recebidos por props e notifica seu pai (App.vue) das intenções do usuário por meio dos [book]/[cancel] eventos —exatamente a mesma separação de responsabilidades que entre [Angular] e [React].

6.10.4. src/app/features/booking-dialog/BookingDialog.vue

Port de [booking-dialog.component.ts/.html] ([Angular]) e de [BookingDialog.tsx] ([React]): a janela (modal) que permite selecionar um paciente para agendar um horário disponível. Equivalente ao Exemplo 9 do cliente AngularJS 1.x original.

<script setup lang="ts">
import { ref } from 'vue';
import { useI18n } from 'vue-i18n';
import type { Client, SlotJson } from '../../core/models/appointment.models';

defineProps<{
  open: boolean;
  slot: SlotJson | null;
  clients: Client[];
}>();

const emit = defineEmits<{
  confirm: [choice: { clientId: number }];
  close: [];
}>();

const { t } = useI18n();
const selectedClientId = ref<number | null>(null);

function onConfirmClick(): void {
  if (selectedClientId.value === null) {
    return;
  }
  emit('confirm', { clientId: selectedClientId.value });
  selectedClientId.value = null;
}

function onCloseClick(): void {
  selectedClientId.value = null;
  emit('close');
}
</script>

<template>
  <template v-if="open">
    <div class="modal-backdrop fade show"></div>

    <div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true">
      <div class="modal-dialog modal-dialog-centered">
        <div class="modal-content">
          <div class="modal-header">
            <h5 class="modal-title">{{ t('BOOKING_DIALOG.TITLE') }}</h5>
            <button type="button" class="btn-close"
              :aria-label="t('BOOKING_DIALOG.CLOSE_ARIA')" @click="onCloseClick"></button>
          </div>

          <div class="modal-body">
            <p v-if="slot">
              {{ t('BOOKING_DIALOG.SLOT_FROM') }} {{ slot.startHour }}:{{
                slot.startMinute.toString().padStart(2, '0')
              }}
              {{ t('BOOKING_DIALOG.SLOT_TO') }} {{ slot.endHour }}:{{
                slot.endMinute.toString().padStart(2, '0')
              }}
            </p>

            <label class="form-label" for="select-client">
              {{ t('BOOKING_DIALOG.PATIENT_LABEL') }}
            </label>
            <select id="select-client" class="form-select" v-model="selectedClientId">
              <option :value="null">{{ t('BOOKING_DIALOG.CHOOSE_PATIENT') }}</option>
              <option v-for="client in clients" :key="client.id" :value="client.id">
                {{ client.title }} {{ client.firstName }} {{ client.lastName }}
              </option>
            </select>
          </div>

          <div class="modal-footer">
            <button type="button" class="btn btn-secondary" @click="onCloseClick">
              {{ t('BOOKING_DIALOG.CANCEL') }}
            </button>
            <button type="button" class="btn btn-primary"
              :disabled="selectedClientId === null" @click="onConfirmClick">
              {{ t('BOOKING_DIALOG.CONFIRM') }}
            </button>
          </div>
        </div>
      </div>
    </div>
  </template>
</template>

Vamos analisar este código:

  • linha 35: [template v-if="open"] — um [<template>] (uma tag específica do [Vue.js], que NÃO produz nenhum elemento) carrega o [v-if]: nada é sequer carregado no DOM até que o modal seja aberto—o equivalente exato de [if (!open) return null;] do lado [React] e de [@if(open())] do lado [Angular];
  • linha 36: [div class="modal-backdrop fade show"] — o fundo semitransparente que escurece o restante da página—escrito diretamente no código aqui, como nas outras duas variantes, enquanto o [Bootstrap] normalmente o insere por conta própria via JavaScript quando o modal é exibido;
  • linha 38: [div class="modal fade show d-block"] — [d-block] assume o papel normalmente desempenhado pelo JavaScript do [Bootstrap] (adicionar [display:block] na abertura) - Aqui, é o [v-if] da linha 35 que cumpre diretamente esse papel;
  • linha 44: [:aria-label="t(‘BOOKING_DIALOG.CLOSE_ARIA’)"] — ao contrário de [attr.aria-label="‘BOOKING_DIALOG.CLOSE_ARIA’ | translate"] do lado [Angular] (um binding de atributo distinto da interpolação {{ }}), e de modo semelhante a [JSX] e [React] (que não fazem distinção entre um atributo e o conteúdo de um elemento), o [Vue.js] usa aqui [:aria-label="..."] —o prefixo [:] indicando um BINDING de atributo (uma expressão JavaScript) em vez de uma string literal.

Como nas outras duas variantes, este componente usa as classes REAIS do [Bootstrap] de um modal, mas sua visibilidade é controlada pelo [Vue.js] (um [v-if] na [open] propriedade) em vez de pelo JavaScript do [Bootstrap] ([bootstrap.bundle.js, new bootstrap.Modal(...)])—para evitar que cada um gerencie, de forma independente, a mesma informação (o modal está aberto?), uma fonte comum de bugs sutis. O documento original (2014) usava um componente da biblioteca angular-ui-bootstrap (um modal “pronto para uso”), já concebido segundo esse mesmo princípio.

6.11. O componente raiz App: orquestrador e guardião da autenticação

Este componente cumpre o papel desempenhado pelo “controller principal” na aplicação AngularJS 1.x original, bem como pelos componentes App dos lados [Angular] e [React] : ele mantém o estado global da aplicação e responde aos eventos dos componentes de features/ para chamar [useAppointmentService()] no momento certo. Desde a adição da autenticação, ele assumiu um segundo papel: o de “porteiro” na camada de apresentação, que decide se exibe a tela de login ou o restante da aplicação. Um componente [Vue.js] reúne em um único arquivo [.vue] o que o [Angular] separa em três (app.ts, app.html, app.css)—exatamente como App.tsx já fazia para o [React].

6.11.1. src/app/App.vue

<script setup lang="ts">
import { ref, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useAuth } from './core/composables/auth.composable';
import { useSettings } from './core/composables/settings.composable';
import { useLanguage } from './core/composables/language.composable';
import { useAppointmentService } from './core/services/appointment.service';
import type { DoctorDaySchedule, Client, SlotJson, Doctor, AppointmentJson } from './core/models/appointment.models';
import DoctorDayPicker from './features/doctor-day-picker/DoctorDayPicker.vue';
import Schedule from './features/schedule/Schedule.vue';
import BookingDialog from './features/booking-dialog/BookingDialog.vue';
import Login from './features/login/Login.vue';

const { t } = useI18n();
const auth = useAuth();
const settings = useSettings();
const language = useLanguage();
const api = useAppointmentService();

const doctors = ref<Doctor[]>([]);
const clients = ref<Client[]>([]);
const schedule = ref<DoctorDaySchedule | null>(null);
const error = ref<string | null>(null);
const slotBeingBooked = ref<SlotJson | null>(null);
const lastDoctorId = ref<number | null>(null);
const lastDay = ref<string | null>(null);

watch(
  () => auth.isLoggedIn,
  (isLoggedIn) => {
    if (isLoggedIn) {
      loadInitialLists();
    }
  },
  { immediate: true },
);

function loadInitialLists(): void {
  api
    .getAllDoctors()
    .then((result) => (doctors.value = result))
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));

  api
    .getAllClients()
    .then((result) => (clients.value = result))
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));
}

function onLogout(): void {
  auth.logOut();
  doctors.value = [];
  clients.value = [];
  schedule.value = null;
  error.value = null;
  slotBeingBooked.value = null;
  lastDoctorId.value = null;
  lastDay.value = null;
}

function onSearchSchedule(criteria: { doctorId: number; day: string }): void {
  error.value = null;
  lastDoctorId.value = criteria.doctorId;
  lastDay.value = criteria.day;
  loadSchedule();
}

function onBookingRequest(slot: SlotJson): void {
  slotBeingBooked.value = slot;
}

function onConfirmBooking(choice: { clientId: number }): void {
  if (slotBeingBooked.value === null || lastDay.value === null) {
    return;
  }
  api
    .addAppointment(lastDay.value, choice.clientId, slotBeingBooked.value.id)
    .then(() => {
      slotBeingBooked.value = null;
      loadSchedule();
    })
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));
}

function onCloseBooking(): void {
  slotBeingBooked.value = null;
}

function onCancelAppointment(appointment: AppointmentJson): void {
  api
    .deleteAppointment(appointment.id)
    .then(() => loadSchedule())
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));
}

function loadSchedule(): void {
  if (lastDoctorId.value === null || lastDay.value === null) {
    return;
  }
  api
    .getDoctorScheduleOfDay(lastDoctorId.value, lastDay.value)
    .then((result) => (schedule.value = result))
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));
}
</script>

<template>
  <div class="container py-4">
    <nav class="navbar navbar-expand-sm navbar-dark bg-primary rounded mb-4 px-3">
      <span class="navbar-brand mb-0">{{ t('APP.TITLE') }}</span>

      <div class="d-flex align-items-center gap-2">
        <div class="btn-group btn-group-sm" role="group" aria-label="FR / EN">
          <button type="button"
            :class="'btn ' + (language.currentLanguage === 'fr' ? 'btn-light' : 'btn-outline-light')"
            @click="language.changeLanguage('fr')">
            FR
          </button>
          <button type="button"
            :class="'btn ' + (language.currentLanguage === 'en' ? 'btn-light' : 'btn-outline-light')"
            @click="language.changeLanguage('en')">
            EN
          </button>
        </div>

        <template v-if="auth.isLoggedIn">
          <span class="badge text-bg-light text-primary">{{ auth.role }}</span>
          <span class="text-white">{{ auth.name }}</span>
          <button type="button" class="btn btn-sm btn-outline-light" @click="onLogout">
            {{ t('APP.LOGOUT') }}
          </button>
        </template>
      </div>
    </nav>

    <div class="row g-2 align-items-center mb-4">
      <div class="col-auto">
        <label class="form-label mb-0" for="input-server-url">
          {{ t('APP.SERVER_URL_LABEL') }}
        </label>
      </div>
      <div class="col-sm-4">
        <input id="input-server-url" type="text" class="form-control form-control-sm"
          v-model="settings.apiBaseUrl" />
      </div>
    </div>

    <div v-if="error" class="alert alert-danger" role="alert">
      {{ error }}
    </div>

    <Login v-if="!auth.isLoggedIn" />

    <template v-else>
      <DoctorDayPicker :doctors="doctors" @search="onSearchSchedule" />

      <Schedule
        :schedule="schedule"
        :can-edit="auth.isAdmin"
        @book="onBookingRequest"
        @cancel="onCancelAppointment"
      />

      <BookingDialog
        :open="slotBeingBooked !== null"
        :slot="slotBeingBooked"
        :clients="clients"
        @confirm="onConfirmBooking"
        @close="onCloseBooking"
      />
    </template>
  </div>
</template>

Vamos comentar este código:

  • linhas 25–26: [const lastDoctorId = ref<number | null>(null); const lastDay = ref<string | null>(null);] — armazenamos a última busca (médico + dia) para poder atualizar a agenda após um agendamento ou cancelamento. Como no [React] (um [useRef](), e não um [useState]()), esses dois valores nunca são usados diretamente na exibição (ao contrário da agenda ou das páginas de erro)—mas, ao contrário do [React], o [Vue.js] não exige um hook especial ([useRef]) para uma variável que sobrevive à renderização sem provocar um redesenho: como um [<script setup>] é executado apenas uma vez por instância de componente (ao contrário de uma função de componente [React], que é reexecutada a cada renderização), uma simples variável JavaScript (let) teria funcionado igualmente bem; [ref()] é usado aqui simplesmente por coerência com o restante do arquivo;
  • linhas 28–36: [watch(() => auth.isLoggedIn, (isLoggedIn) => { if (isLoggedIn) { loadInitialLists(); } }, { immediate: true });] — reexecuta seu corpo toda vez que [auth.isLoggedIn] muda — o equivalente direto de [effect(() => { if (this.auth.isLoggedIn()) { … } })] do lado [Angular] e de [useEffect](..., [auth.isLoggedIn]) do lado [React]. [{ immediate: true }] também faz com que ele seja executado imediatamente na primeira vez, sem esperar uma mudança—exatamente o comportamento de [useEffect]() do lado [React] (que sempre é executado ao menos uma vez, na inicialização): se uma sessão já estava armazenada em [localStorage] (recarregamento da página), as listas são carregadas imediatamente na inicialização, sem esperar por um login;
  • linhas 112–133: [div class="btn-group btn-group-sm" … FR … EN … template v-if="auth.isLoggedIn" …] — o seletor de idioma está SEMPRE visível (inclusive na tela de login); já o badge de papel + nome + botão de logout só são exibidos se [auth.isLoggedIn] (linhas 126–132, [template v-if="auth.isLoggedIn"])—exatamente a mesma lógica de [Angular] e [React];
  • linha 152: [Login v-if="!auth.isLoggedIn"] — enquanto [useAuth().isLoggedIn] for false, este componente exibe apenas <Login />; como todas as rotas do servidor agora são protegidas por [JwtAuthGuard] (Capítulo 3), seria inútil de qualquer forma (e causaria erros 401) carregar médicos/clientes/agenda antes do login—exatamente o mesmo raciocínio de [Angular] e [React];
  • Linhas 154–171: [template v-else … DoctorDayPicker … Schedule … BookingDialog …] — os três componentes de “lógica de negócio” de features/ são montados aqui, cada um recebendo suas props (dados, prefixadas com [:]) e seus manipuladores de eventos (prefixados com [@]) - o equivalente exato do template app.html do lado [Angular], em que os mesmos três componentes apareciam com [doctors]="doctors()" (search)="onSearchSchedule($event)"…

Estado ([ref]), efeito ([watch]) e manipuladores de eventos (as funções onXxx): são exatamente os mesmos elementos já apresentados no capítulo anterior, aplicados aqui a todo o componente raiz—nada de novo foi introduzido neste arquivo; ele apenas foi montado.

6.12. Guia passo a passo de uso da aplicação

As capturas de tela a seguir foram obtidas com exatamente a mesma sequência de ações das variantes [Angular] e [React] deste curso, neste cliente [Vue.js]: URL do servidor mantida no valor padrão (http://localhost:8080), contas de demonstração admin/admin e user/user.

6.12.1. 1. Tela de login

Quando a página é carregada pela primeira vez, [useAuth().isLoggedIn] é false (nenhuma sessão no localStorage): apenas <Login /> é exibido.

Image

Tela de login

Uma tentativa com uma combinação inválida de nome de usuário/senha exibe a mensagem de erro armazenada por Login.vue:

Image

Erro de login

O seletor FR/EN, que continua visível, também traduz esta tela (e a mensagem de erro armazenada, que é retraduzida sem código adicional; veja Login.vue acima):

Image

Tela de login em francês

6.12.2. 2. Login como administrador (papel ADMIN, acesso total)

Depois de fazer login com admin/admin, App.vue deixa de exibir <Login /> e carrega médicos/clientes ([loadInitialLists()], disparado por [watch(() => auth.isLoggedIn, …, { immediate: true })] na linha 28):

Image

Página inicial, após login como ADMIN

Image

Página inicial, após login como ADMIN, em francês

Depois de selecionar um médico e uma data em <DoctorDayPicker />, a agenda é exibida com os botões “Book”/“Cancel” (canEdit é true para o papel ADMIN):

Image

Agenda, visão ADMIN (botões Book/Cancel visíveis)

Clicar em “Book” abre <BookingDialog /> ([open] passa a true; veja [onBookingRequest] em App.vue):

Image

Janela de agendamento (modal Bootstrap)

Após a confirmação ([onConfirmBooking] chama [api.addAppointment(...)], e depois [loadSchedule()] atualiza a exibição), o horário aparece como reservado:

Image

Agenda após o agendamento

Clicar em “Cancel” ([onCancelAppointment] chama [api.deleteAppointment(...)]) torna o horário novamente disponível:

Image

Agenda após o cancelamento

6.12.3. 3. Login como usuário (papel USER, somente leitura)

Depois de sair (onLogout), fazer login com a conta user/user exibe um badge “USER” diferente:

Image

Página inicial, após login como USER

A agenda continua visível, mas nenhum botão “Book”/“Cancel” aparece: a coluna de ações fica vazia para cada horário (veja Schedule.vue, [v-if="canEdit"] no botão). Uma requisição direta ao servidor (por exemplo, usando o Postman e fornecendo o token do usuário) ainda receberia uma resposta 403 Forbidden—ocultar o botão é apenas uma conveniência de exibição; a restrição real é imposta por [RolesGuard] no lado do servidor (Capítulo 3):

Image

Agenda, visão USER (somente leitura, sem botões de ação)

6.13. O que fica fora do escopo ou foi adiado

O modo "debug" (exibição do template bruto da view atual) do cliente AngularJS 1.x original é um recurso deliberadamente omitido deste port, assim como nas variantes [Angular] e [React] deste curso—ele não aparecerá em uma etapa posterior do curso (veja o Capítulo 6, Conclusão, para as razões dessa decisão). A configuração de um atraso de rede artificial, por outro lado, é de fato adiada para uma etapa posterior nas três variantes.

Duas diferenças adicionais, específicas deste port [Vue.js], merecem ser mencionadas aqui:

  • os testes unitários (ausentes deste projeto, assim como dos projetos [Angular] e [React] deste curso) seguiriam uma abordagem diferente no [Vue.js]: em vez do TestBed (específico do [Angular]) ou da [React Testing Library] ([React]), o ecossistema [Vue.js] normalmente se apoia no [Vue Test Utils]—não apresentado neste documento;
  • a verificação de tipos do [<template>] tem aqui um status especial: ao contrário do [React] (em que o compilador TypeScript padrão basta, já que [JSX] é apenas mais uma forma de JavaScript), o [Vue.js] fornece o [vue-tsc] (veja package.json, Capítulo 5), especificamente PARA essa finalidade, que verifica os tipos dentro do [<template>] - uma situação que, nesse ponto específico, se aproxima mais do [Angular] e de strictTemplates do que do [React], embora seja uma ferramenta separada, e não uma opção do próprio compilador.