More PT-BR translations

packages/tsconfig-reference/copy/pt/options/alwaysStrict.md

@@ -0,0 +1,8 @@
+---
+display: "Sempre Estrito"
+oneline: "Garante que 'use strict' é sempre emitido no início do arquivo"
+---
+
+Garante que seus arquivos sejam analisados no modo estrito do ECMAScript e emitam "use strict" para cada arquivo fonte.
+
+O modo [estrito do ECMAScript](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Strict_mode) foi introduzido no ES5 e fornece ajustes de comportamento para o runtime do engine JavaScript para melhorar o desempenho e faz um conjunto de erros serem lançados em vez de ignorá-los silenciosamente.

packages/tsconfig-reference/copy/pt/options/assumeChangesOnlyAffectDirectDependencies.md

@@ -0,0 +1,8 @@
+---
+display: "Assume que as alterações afetem apenas dependências diretas"
+oneline: "Uma opção do modo watch que é drasticamente mais rápida, mas ocasionalmente imprecisa."
+---
+
+Quando essa opção está ativada, o TypeScript apenas verifica/reconstrói os arquivos que foram alterados, bem como os arquivos que os importam diretamente. Evitando assim a verificação/reconstrução de todos os arquivos que realmente podem ter sido afetados pelas alterações.
+
+Isso pode ser considerado uma implementação 'rápida' do algoritmo de observação, que pode reduzir drasticamente os tempos de reconstrução incremental às custas de ter que executar a compilação completa ocasionalmente para obter todas as mensagens de erro do compilador.

packages/tsconfig-reference/copy/pt/options/baseUrl.md

@@ -0,0 +1,27 @@
+---
+display: "URL Base"
+oneline: "Configura uma URL base para os nomes relativos de módulos"
+---
+
+Permite definir um diretório base para resolver nomes de módulo não absolutos.
+
+Você pode definir uma pasta raiz na qual pode fazer a resolução absoluta do arquivo. Por exemplo.
+
+```
+URLBase
+├── ex.ts
+├── ola
+│   └── mundo.ts
+└── tsconfig.json
+```
+
+Com `"baseUrl": "./"` no projeto, o TypeScript vai procurar por arquivos começando na mesma pasta do `tsconfig.json`.
+
+```ts
+import { olaMundo } from "ola/mundo";
+
+console.log(olaMundo);
+```
+
+Se você estiver cansado de importações sempre parecidas com `"../"` ou `"./"`, ou precisando
+alterá-las à medida que move arquivos, essa é uma ótima maneira de simplificar isso.

packages/tsconfig-reference/copy/pt/options/charset.md

@@ -0,0 +1,7 @@
+---
+display: "Charset"
+oneline: "Seta manualmente o encoding do texto para leitura de arquivos"
+---
+
+Nas versões anteriores do TypeScript, isso controlava qual codificação era usada ao ler arquivos de texto do disco.
+Hoje, o TypeScript assume a codificação UTF-8, mas detectará corretamente as codificações UTF-16 (BE e LE) ou UTF-8 com [BOMs](https://pt.wikipedia.org/wiki/Marca_de_ordem_de_byte).

packages/tsconfig-reference/copy/pt/options/checkJs.md

@@ -0,0 +1,40 @@
+---
+display: "Checar JS"
+oneline: "Executa o verificador de tipos em arquivos .js do seu projeto"
+---
+
+Funciona em conjunto com o `allowJs`. Quando o `checkJs` está ativado, os erros são relatados também nos arquivos JavaScript. Isto é
+o equivalente a incluir `// @ts-check` na parte superior de todos os arquivos JavaScript incluídos no seu projeto.
+
+Por exemplo, este é um JavaScript incorreto, de acordo com a definição do tipo `parseFloat` que acompanha o TypeScript:
+
+```js
+// parseFloat só recebe uma string
+module.exports.pi = parseFloat(3.124);
+```
+
+Quando importado em um módulo TypeScript:
+
+```ts twoslash
+// @allowJs
+// @filename: constantes.js
+module.exports.pi = parseFloat(3.124);
+
+// @filename: index.ts
+import { pi } from "./constantes";
+console.log(pi);
+```
+
+Você não vai obter nenhum erro. No entanto, se você ativar o `checkJs` então voce também terá mensagens de erro no seu arquivo JavaScript.
+
+```ts twoslash
+// @errors: 2345
+// @allowjs: true
+// @checkjs: true
+// @filename: constantes.js
+module.exports.pi = parseFloat(3.124);
+
+// @filename: index.ts
+import { pi } from "./constantes";
+console.log(pi);
+```

packages/tsconfig-reference/copy/pt/options/composite.md

@@ -0,0 +1,17 @@
+---
+display: "Composição"
+oneline: "Usado para criar múltiplos projetos de build"
+---
+
+A opção `composite` aplica certas restrições que possibilitam que ferramentas de build (incluindo o TypeScript
+no modo `--build`) determinem rapidamente se um projeto já foi construído.
+
+Quando esta configuração está ativada:
+
+- A configuração `rootDir`, se não foi setada explicitamente, é o diretório que contém o arquivo `tsconfig.json`.
+
+- Todos os arquivos de implementação devem corresponder a um padrão do `include` ou listados no array `files`. Se esta restrição for violada, o `tsc` informará quais arquivos não foram especificados.
+
+- `declaration` é setado como `true`
+
+Você pode encontrar a documentação de projetos TypeScript [no guia](https://www.typescriptlang.org/docs/handbook/project-references.html).

packages/tsconfig-reference/copy/pt/options/declaration.md

@@ -0,0 +1,32 @@
+---
+display: "Declarações"
+oneline: "Emite arquivos d.ts para os arquivos referenciados no projeto"
+---
+
+Gere arquivos `.d.ts` para cada arquivo TypeScript ou JavaScript dentro do seu projeto.
+Esses arquivos `.d.ts` são arquivos de definição de tipo que descrevem a API externa do seu módulo.
+Com arquivos `.d.ts`, ferramentas como o TypeScript podem fornecer intellisense e tipos mais precisos para código que ainda não foi digitado.
+
+Quando a opção `declaration` é definida como `true`, executando o compilador com este código TypeScript:
+
+```ts twoslash
+export let olaMundo = "olá!";
+```
+
+Vai gerar um arquivo `index` como este:
+
+```ts twoslash
+// @showEmit
+export let olaMundo = "olá!";
+```
+
+Com um outro arquivo correspondente `olaMundo.d.ts`:
+
+```ts twoslash
+// @showEmittedFile: index.d.ts
+// @showEmit
+// @declaration
+export let olaMundo = "olá!";
+```
+
+Ao trabalhar com arquivos `.d.ts` para arquivos JavaScript, você pode usar [`emitDeclarationOnly`](#emitDeclarationOnly) ou usar [`outDir`](#outDir) para garantir que os arquivos JavaScript não sejam sobrescritos.

packages/tsconfig-reference/copy/pt/options/declarationDir.md

@@ -0,0 +1,36 @@
+---
+display: "Diretório de declarações"
+oneline: "Define o diretório raiz para os arquivos .d.ts"
+---
+
+Oferece uma maneira de configurar o diretório raiz para onde os arquivos de declaração são emitidos.
+
+```
+exemplo
+├── index.ts
+├── package.json
+└── tsconfig.json
+```
+
+com este `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationDir": "./tipos"
+  }
+}
+```
+
+Colocaria o `d.ts` para o `index.ts` em uma pasta`tipos`:
+
+```
+exemplo
+├── index.js
+├── index.ts
+├── package.json
+├── tsconfig.json
+└── tipos
+    └── index.d.ts
+```

packages/tsconfig-reference/copy/pt/options/declarationMap.md

@@ -0,0 +1,9 @@
+---
+display: "Mapa de declarações"
+oneline: "Cria arquivos sourcemap para os arquivos .d.ts"
+---
+
+Gera um sourcemap para arquivos `.d.ts`, que são mapeados de volta para o arquivo original `.ts`.
+Isso permitirá que editores como o VS Code acessem o arquivo `.ts` original ao usar recursos como _Ir para definição_.
+
+Você deve fortemente considerar ativar essa opção se estiver usando referências de projeto.

packages/tsconfig-reference/copy/pt/options/diagnostics.md

@@ -0,0 +1,8 @@
+---
+display: "Diagnósticos"
+oneline: "Gera mais informações de diagnóstico após a compilação"
+---
+
+Usado para gerar informações de diagnóstico para depuração. Este comando é um subconjunto de [`extendedDiagnostics`](#extendedDiagnostics), apenas com resultados voltados para o usuário e mais fáceis de interpretar.
+
+Se você tiver sido solicitado por um engenheiro do compilador do TypeScript para fornecer os resultados usando esse sinalizador em uma compilação, não há mal algum em usar [`--extendedDiagnostics`](#extendedDiagnostics) durante o processo.

packages/tsconfig-reference/copy/pt/options/disableSizeLimit.md

@@ -0,0 +1,6 @@
+---
+display: "Desativar limite de tamanho"
+oneline: "Remove a limitação de memória no servidor de linguagem do TypeScript"
+---
+
+Para evitar um possível problema de inchaço da memória ao trabalhar com projetos JavaScript muito grandes, há um limite superior para a quantidade de memória que o TypeScript alocará. Ativar este sinalizador removerá o limite.

packages/tsconfig-reference/copy/pt/options/disableSolutionSearching.md

@@ -0,0 +1,8 @@
+---
+display: "Desabilitar Busca por Soluções"
+oneline: "Remove um projeto da checagem de referências multi-projeto"
+---
+
+Ao trabalhar com [projetos TypeScript compostos](/docs/handbook/project-reference.html), esta opção fornece uma maneira de declarar que você não deseja que um projeto seja incluído ao usar recursos como _encontrar todas as referências_ ou _pular para definição_ em um editor.
+
+Esse sinalizador é algo que você pode usar para aumentar a capacidade de resposta em grandes projetos compostos.

packages/tsconfig-reference/copy/pt/options/disableSourceOfProjectReferenceRedirect.md

@@ -0,0 +1,8 @@
+---
+display: "Desabilitar Redirecionamento de Referências no Projeto de Origem"
+oneline: "Usar arquivos .d.ts como a fonte de verdade para todas as ferramentas dentro do escopo de projetos compostos"
+---
+
+Ao trabalhar com [projetos TypeScript compostos](/docs/handbook/project-reference.html), esta opção fornece uma maneira de voltar [ao comportamento pré-3.7](/docs/handbook/release-notes/typescript-3-7.html#build-free-edition-with-project-reference) em que os arquivos d.ts eram usados como limites entre os módulos.
+
+Na versão 3.7, a fonte da verdade são agora os arquivos TypeScript.

packages/tsconfig-reference/copy/pt/options/downlevelIteration.md

@@ -0,0 +1,73 @@
+---
+display: "Iteração Downlevel"
+oneline: "Emite JavaScript mais compatível, porém mais verboso, para objetos iterativos"
+---
+
+Downleveling é o termo do TypeScript para transpilar para uma versão mais antiga do JavaScript.
+Esse sinalizador permite que, em runtimes mais antigos do JavaScript, haja o suporte a uma implementação mais precisa de como o JavaScript moderno interage com novos conceitos.
+
+O ECMAScript 6 adicionou várias novas primitivas de iteração: o loop `for / of` (`for (el of arr)`), operador de spread (`[a, ...b]`), spread de argumento (`fn (... args)`) e o [`Symbol.iterator`](https://medium.com/trainingcenter/iterators-em-javascript-880adef14495). `--downlevelIteration` permite que essas primitivas de iteração sejam usadas com mais precisão nos ambientes ES5 se uma implementação do [`Symbol.iterator`](https://medium.com/trainingcenter/iterators-em-javascript-880adef14495) estiver presente.
+
+#### Exemplo: Efeitos no `for / of`
+
+Sem a flag `downlevelIteration` ativa, um loop `for / of` em qualquer objeto sofre um downlevel para um loop `for` tradicional:
+
+```ts twoslash
+// @target: ES5
+// @showEmit
+const str = "Olá!";
+for (const s of str) {
+  console.log(s);
+}
+```
+
+Isso geralmente é o que as pessoas esperam, mas não é 100% compatível com o comportamento do ECMAScript 6.
+Certas strings, como emoji (😜), têm um `.length` de 2 (ou até mais!), Mas devem iterar como 1 unidade em um loop `for-of`.
+Consulte [esta postagem no blog de Jonathan New](https://blog.jonnew.com/posts/poo-dot-length-equals-two) para obter uma explicação mais detalhada.
+
+Quando o `downlevelIteration` estiver ativado, o TypeScript usará uma função auxiliar que verifica a implementação do `Symbol.iterator` (nativo ou polyfill). Se essa implementação estiver ausente, ela retornará à iteração baseada em índice.
+
+```ts twoslash
+// @target: ES5
+// @downlevelIteration
+// @showEmit
+const str = "Olá!";
+for (const s of str) {
+  console.log(s);
+}
+```
+
+> > **Nota:** ativar o `downlevelIteration` não melhora a compatibilidade se o `Symbol.iterator` não estiver presente no runtime.
+
+#### Exemplo: Efeitos em Spreads de Arrays
+
+Isso é um operador spread em um array:
+
+```js
+// Cria um novo array onde os elementos são: 1 seguido por todos os elementos do arr2
+const arr = [1, ...arr2];
+```
+
+Baseado nas descrições, parece fácil fazer um downlevel para ES6:
+
+```js
+// Mesma coisa, certo?
+const arr = [1].concat(arr2);
+```
+
+No entanto, isso é claramente diferente em certos casos bem raros.
+Por exemplo, se o array tiver um "buraco" no meio, o índice faltante vai criar uma propriedade _própria_ quando sofrer o spread, mas isso não acontece quando usamos `concat`:
+
+```js
+// Fazemos um array onde temos o elemento do índice '1' faltando
+let faltando = [0, , 1];
+let spread = [...faltando];
+let concatenado = [].concat(faltando);
+
+// true
+"1" in spread;
+// false
+"1" in concatenado;
+```
+
+Assim como `for / of`, `downlevelIteration` vai usar o `Symbol.iterator` (se presente) para emular de forma mais precisa o comportamento do ES 6.

packages/tsconfig-reference/copy/pt/options/emitBOM.md

@@ -0,0 +1,8 @@
+---
+display: "Emitir BOM"
+oneline: "Inclui um byte order mark nos arquivos de saída"
+---
+
+Controla se o TypeScript emitirá uma [BOM (byte order mark)](https://pt.wikipedia.org/wiki/Marca_de_ordem_de_byte) ao gravar arquivos de saída.
+Alguns runtimes exigem uma BOM para interpretar corretamente os arquivos JavaScript; outros exigem que ele não esteja presente.
+O valor padrão de `false` é geralmente melhor, a menos que você tenha um motivo para alterá-lo.

packages/tsconfig-reference/copy/pt/options/emitDeclarationOnly.md

@@ -0,0 +1,11 @@
+---
+display: "Emitir Somente Declarações"
+oneline: "Somente emitir arquivos .d.ts e não emitir arquivos .js"
+---
+
+_Só_ emite arquivos `.d.ts`; não emite arquivos `.js`.
+
+Essa configuração é útil em dois casos:
+
+- Você está usando um transpilador diferente do TypeScript para gerar seu JavaScript.
+- Você está usando o TypeScript para gerar apenas arquivos `d.ts` para seus consumidores.

packages/tsconfig-reference/copy/pt/options/emitDecoratorMetadata.md

@@ -0,0 +1,69 @@
+---
+display: "Emitir Metadados de Decorators"
+oneline: "Adiciona metadados de tipo adicionais a decorators no código emitido"
+---
+
+Ativa o suporte experimental para a emissão de metadados de tipo para decorators que funcionam com o módulo [`reflect-metadata`](https://www.npmjs.com/package/reflect-metadata).
+
+Por exemplo, aqui está o JavaScript
+
+```ts twoslash
+// @experimentalDecorators
+function LogarMetodo(alvo: any, chaveDaPropriedade: string | symbol, descritor: PropertyDescriptor) {
+  console.log(alvo);
+  console.log(chaveDaPropriedade);
+  console.log(descritor);
+}
+
+class Demo {
+  @LogarMetodo
+  public foo(bar: number) {
+    // não faz nada
+  }
+}
+
+const demo = new Demo();
+```
+
+Com `emitDecoratorMetadata` não ativo (padrão):
+
+```ts twoslash
+// @experimentalDecorators
+// @showEmit
+function LogarMetodo(alvo: any, chaveDaPropriedade: string | symbol, descritor: PropertyDescriptor) {
+  console.log(alvo);
+  console.log(chaveDaPropriedade);
+  console.log(descritor);
+}
+
+class Demo {
+  @LogarMetodo
+  public foo(bar: number) {
+    // não faz nada
+  }
+}
+
+const demo = new Demo();
+```
+
+Com `emitDecoratorMetadata` em true:
+
+```ts twoslash
+// @experimentalDecorators
+// @showEmit
+// @emitDecoratorMetadata
+function LogarMetodo(alvo: any, chaveDaPropriedade: string | symbol, descritor: PropertyDescriptor) {
+  console.log(alvo);
+  console.log(chaveDaPropriedade);
+  console.log(descritor);
+}
+
+class Demo {
+  @LogarMetodo
+  public foo(bar: number) {
+    // não faz nada
+  }
+}
+
+const demo = new Demo();
+```