Introduzindo o uso do TypeScript no Angular
Olá, pessoal. Agora que já conhecemos um pouco do TypeScript e entendemos melhor o que ele pode fazer, é hora de aprender como começar a utilizá-lo de fato. Usar o TypeScript não é tão simples quanto rodar apenas um Node em um arquivo JavaScript, mas também não é tão complicado. Ao escolhermos utilizar o Angular, ganhamos um presente, pois estamos dentro da carreira Angular. Vou explicar qual é esse presente.
O Angular é conhecido no mundo do front-end como um dos frameworks mais robustos que temos. Essa robustez e segurança se devem ao fato de que, desde o princípio, o Angular escolheu utilizar TypeScript por padrão. Isso significa que, assim que criamos nosso projeto Angular, já recebemos toda a configuração do TypeScript por padrão. Por isso, quando criamos o projeto do nosso curso, o TypeScript já foi instalado e estará disponível para nós.
Criando um novo projeto Angular
Para começar, vamos criar um novo projeto Angular utilizando o NPX. Isso nos permite não precisar instalar o Angular CLI globalmente. O comando que utilizamos é:
npx ng new 5532-typescript-books
Vou mostrar o nosso projeto funcionando. Ele é simples e o chamamos de "buscante". Será uma listagem de livros. No topo da página, temos um campo de busca onde podemos procurar por título, autor, data de publicação e editora. Em seguida, há uma lista estática. Algumas imagens vêm da internet, então podem ou não renderizar. Podemos substituir rapidamente por uma imagem padrão quando não há capa de livro disponível. Os livros estão estáticos no código, pois o objetivo do curso é aprender, interagir e dominar o TypeScript. Esta página web simples será suficiente para fazermos algumas buscas. Quando não houver resultados com o filtro aplicado, será exibida uma mensagem indicando que podemos buscar qualquer livro, junto com a imagem padrão.
Explorando a transpilação de TypeScript para JavaScript
Este projeto nos permitirá criar situações utilizando o TypeScript, mostrando onde ele faz diferença e nos ajuda a evitar erros, identificando os tipos que precisamos utilizar. O grande problema é que o navegador só entende JavaScript. Mesmo que o TypeScript traga benefícios, no final, o navegador do usuário só entenderá JavaScript. Por isso, precisamos encontrar uma forma de traduzir, transpilar ou compilar nosso código TypeScript em JavaScript, para que o navegador possa entender tudo o que criamos.
Como podemos fazer isso de forma organizada? A solução é o compilador do TypeScript, mas tudo isso foi abstraído para nós ao criarmos nosso projeto Angular. Para nos situarmos melhor, vou passar pelos passos que utilizei para criar este projeto, além de explicar um pouco da estrutura do nosso projeto Angular. Vamos focar nos arquivos de configuração do TypeScript, para que não precisemos configurá-los do zero. Sempre farei referência à documentação do TypeScript, que é nossa fonte de verdade e nos ajudará a entender como instalar e o que faz o TypeScript.
Analisando o arquivo de configuração tsconfig.json
Dentro da pasta src, já temos nosso aplicativo configurado, mas vamos focar principalmente em um arquivo: o tsconfig.json. Como o nome sugere, esse arquivo contém as configurações do TypeScript. Geralmente, não precisamos alterá-lo com frequência, especialmente em projetos Angular, pois ele já vem configurado. Alteramos sob demanda, ou seja, quando precisamos de uma configuração diferente, modificamos esse arquivo. A estrutura inicial dele contém várias opções, sendo um grande objeto com diversas configurações, como as opções de compilação. Aqui está um exemplo de como ele pode ser configurado:
{
"compileOnSave": false,
"compilerOptions": {
"strict": true,
"noImplicitOverride": true,
"noPropertyAccessFromIndexSignature": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
"skipLibCheck": true,
"isolatedModules": true,
"experimentalDecorators": true,
"importHelpers": true,
"target": "ES2022",
"module": "preserve"
},
"angularCompilerOptions": {
"enableI18nLegacyMessageIdFormat": false,
"strictInjectionParameters": true,
"strictInputAccessModifiers": true,
"typeCheckHostBindings": true,
"strictTemplates": true
},
"files": [],
"references": [
{
"path": "./tsconfig.app.json"
},
{
"path": "./tsconfig.spec.json"
}
]
}
Se copiarmos a URL do "Veja Mais" e colarmos no navegador, encontraremos mais detalhes sobre a configuração na documentação do TypeScript. Caso não saibamos inglês, podemos usar ferramentas de tradução para entender melhor o que essas propriedades fazem. A flag strict habilita uma ampla gama de verificações de tipos, resultando em garantias mais robustas de correção do programa. Essa configuração exige que nosso programa siga mais as regras, não sendo tão flexível.
Detalhando as configurações do tsconfig.json
O arquivo tsconfig.json contém diversas outras configurações para pular ou não validações e cheques de bibliotecas, separar módulos, permitir ou não decoradores experimentais. Geralmente, modificamos essas configurações quando precisamos alterar algo ou quando, como equipe, decidimos ajustar certas configurações. Por exemplo, se não temos decoradores, podemos habilitar a experimentação deles.
Duas das principais configurações são o target, que define a versão do JavaScript para a qual o código final deve ser traduzido, como ECMAScript 2022, e o module, que define como o código deve ser modularizado, com opções como AMD, CommonJS, ESNext, entre outras. A documentação do TypeScript é extensa, e passar por todas as configurações levaria tempo. Por isso, fizemos um apanhado geral para entender que dentro do nosso projeto temos o tsconfig.json, tsconfig.spec.json e tsconfig.app.json. Esses arquivos estendem o tsconfig.json padrão, reaproveitando o que já está configurado, mas mudando algumas coisas. O tsconfig.spec.json é focado nos testes, configurando os tipos para Jasmine, que é o padrão nos projetos Angular, embora possamos usar Jest. Aqui está um exemplo de configuração para testes:
{
"extends": "./tsconfig.json",
"compilerOptions": {
"outDir": "./out-tsc/spec",
"types": [
"jasmine"
]
},
"include": [
"src/**/*.ts"
]
}
Configurando o build final com tsconfig.app.json
Já o tsconfig.app.json configura o build final da aplicação, definindo o que deve ser incluído ou excluído do bundle enviado ao usuário. No build final, não temos um arquivo .spec, pois os testes ficam apenas na máquina da pessoa desenvolvedora. Veja como ele é configurado:
{
"extends": "./tsconfig.json",
"compilerOptions": {
"outDir": "./out-tsc/app",
"types": []
},
"include": [
"src/**/*.ts"
],
"exclude": [
"src/**/*.spec.ts"
]
}
Assim como o npm tem o package.json, o TypeScript é uma ferramenta de build, não sendo interpretado diretamente pelo navegador. Ele atua na máquina da pessoa desenvolvedora, ajudando a gerar um resultado esperado pelo navegador com mais segurança. O compilador TSC (TypeScript Compiler) é responsável por pegar o código TypeScript, verificar os tipos e, se tudo estiver correto, gerar o código JavaScript equivalente. Esse processo é chamado de transpilação. Quando rodamos um npm start, por exemplo, o Angular faz o build e, se não houver problemas, o aplicativo fica disponível na porta 4200.
Iniciando o servidor de desenvolvimento
Para iniciar o servidor de desenvolvimento, utilizamos o seguinte comando:
E o script correspondente no package.json é:
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"watch": "ng build --watch --configuration development",
"test": "ng test"
}
O tsconfig.json é o coração do projeto TypeScript. Em um projeto apenas JavaScript, rodamos comandos como tsc --init e instalamos o TypeScript como um pacote npm (npm install typescript --save-dev). Todos os projetos terão o tsconfig.json, que garante que todos no time usem as mesmas configurações, assegurando que o projeto possua configurações padrão. Isso é fundamental para a consistência do nosso código.