[Added] Brazilian Portuguese Translation (axios#27)

* ✨ starting translation to brazilian portuguese

* Brazilian translation finished

* Update notes.md

Author: ylyra

inert.config.js

@@ -17,6 +17,7 @@ const {
 const enConfig = require('./en.lang.js');
 const deConfig = require('./de.lang.js');
 const zhConfig = require('./zh.lang.js');
+const ptBRConfig = require('./ptBR.lang.js');
 
 /**
  * This is the inert configuration file. It contains all the information inert needs to build this template.
@@ -37,6 +38,10 @@ module.exports = {
         name: 'English',
         prefix: '/'
       },
+      {
+        name: 'Brazilian Portuguese',
+        prefix: '/ptBR/'
+      },
       {
         name: 'Deutsch',
         prefix: '/de/'
@@ -99,12 +104,14 @@ module.exports = {
        * Output for internationalized files
        */
       deOutput: ":output:/de",
+      ptBROutput: ":output:/ptBR",
       zhOutput: ":output:/zh",
       /**
        * Output for posts
        */
       postOutput: ":output:/docs",
       dePosts: ":deOutput:/docs",
+      ptBRPosts: ":ptBROutput:/docs",
       zhPosts: ":zhOutput:/docs"
     },
 
@@ -125,11 +132,16 @@ module.exports = {
        * Build for other languages
        */
       halt('templates/index.ejs'), // This makes sure that the output from the previous methods isn't passed into singleHTMLBuild
+
       singleHTMLBuild(deConfig),
       writeFile(":deOutput:/index.html"),
       halt('templates/index.ejs'),
+
       singleHTMLBuild(zhConfig),
-      writeFile(":zhOutput:/index.html")
+      writeFile(":zhOutput:/index.html"),
+
+      singleHTMLBuild(ptBRConfig),
+      writeFile(":ptBROutput:/index.html"),
     ],
 
     /**
@@ -256,6 +268,34 @@ module.exports = {
           ],
         },
       },
+      {
+        folder: "posts/ptBR",
+        build: {
+          traverseLevel: "recursive",
+          filePipeline: [
+            /**
+             * Compiles the content of markdown files into HTML. Does not save the result. If the argument
+             * `true` is passed, it will throw an error when it encounters a non-markdown file. Will always
+             * throw on markdown error.
+             */
+            markdown(),
+            /**
+             * This function takes an ejs file as an argument and builds it with the global `data` set to
+             * the value of the previous method's result. If this is the first method, the raw content
+             * of the given file is used. Will always throw on EJS error.
+             *
+             * As most blogs are monolingual, we will not be including any fancy i18n stuff here, although
+             * you can if you want to.
+             */
+            htmlBuild("post", ptBRConfig),
+            /**
+             * Like in the `sass` folder's pipeline, the `write` method takes the output of the previous `htmlBuild`
+             * method and writes it to a file with the same name in the specified directory.
+             */
+            write("ptBRPosts", ".html"),
+          ],
+        },
+      },
       {
         folder: "posts/zh",
         build: {

posts/ptBR/api_intro.md

@@ -0,0 +1,60 @@
+---
+title: "Axios API"
+description: "A referência de API do Axios"
+prev_title: "Requisições POST"
+prev_link: "/docs/ptBR/post_example"
+next_title: "Instância Axios"
+next_link: "/docs/ptBR/instance"
+---
+
+Requisições podem ser feitas passando as configuraçãos relevantes para o `axios`.
+
+##### axios(config)
+
+```js
+import axios from 'axios';
+
+// Envia uma requisição post
+axios({
+  method: "post",
+  url: "/user/12345",
+  data: {
+    firstName: "Fred",
+    lastName: "Flintstone",
+  },
+});
+```
+
+```js
+// Requisição GET para imagem remota em node.js
+axios({
+  method: "get",
+  url: "http://bit.ly/2mTM3nY",
+  responseType: "stream",
+}).then(function (response) {
+  response.data.pipe(fs.createWriteStream("ada_lovelace.jpg"));
+});
+```
+
+##### axios(url[, config])
+
+```js
+// Envia uma requisição GET (método padrão)
+axios("/user/12345");
+```
+
+### Apelidos para requisições
+
+Por conveniência, foram fornecidos pseudônimos para todos os métodos de solicitação suportados.
+
+##### axios.request(config)
+##### axios.get(url[, config])
+##### axios.delete(url[, config])
+##### axios.head(url[, config])
+##### axios.options(url[, config])
+##### axios.post(url[, data[, config]])
+##### axios.put(url[, data[, config]])
+##### axios.patch(url[, data[, config]])
+
+###### INFO
+Ao usar os pseudônimo dos métodos, as propriedades `url`,` method` e `data` não precisam ser especificadas na configuração.

posts/ptBR/cancellation.md

@@ -0,0 +1,56 @@
+---
+title: 'Cancelamento'
+prev_title: 'Manipulando erros'
+prev_link: '/docs/ptBR/handling_errors'
+next_title: 'Corpo de codificação de URL'
+next_link: '/docs/ptBR/urlencoded'
+---
+
+Você pode cancelar uma requisição usando um *cancel token*.
+
+> O token de cancelamento do axios é baseado em retirada [proposta de promessas canceláveis](https://github.com/tc39/proposal-cancelable-promises).
+
+Você pode criar um token de cancelamento usando o `CancelToken.souce` conforme mostrado abaixo:
+
+```js
+const CancelToken = axios.CancelToken;
+const source = CancelToken.source();
+
+axios.get('/user/12345', {
+  cancelToken: source.token
+}).catch(function (thrown) {
+  if (axios.isCancel(thrown)) {
+    console.log('Request canceled', thrown.message);
+  } else {
+    // manipulando erro
+  }
+});
+
+axios.post('/user/12345', {
+  name: 'new name'
+}, {
+  cancelToken: source.token
+})
+
+// cancela a requisição (o parâmetro de mensagem é opcional)
+source.cancel('Operação cancelada pelo usuário');
+```
+
+Você também poder criar um token de cancelamento passando uma função executora para o construtor de `CancelToken`
+
+```js
+const CancelToken = axios.CancelToken;
+let cancel;
+
+axios.get('/user/12345', {
+  cancelToken: new CancelToken(function executor(c) {
+    // Uma função executora recebe uma função de cancelamento como parametro
+    cancel = c;
+  })
+});
+
+// cancela a requisição
+cancel();
+```
+
+> Nota: você pode cancelar multiplas requisições com o mesmo token de cancelamento.

posts/ptBR/config_defaults.md

@@ -0,0 +1,50 @@
+---
+title: 'Configurações padrões'
+prev_title: 'Esquema de respostas'
+prev_link: '/docs/ptBR/res_schema'
+next_title: 'Interceptadores'
+next_link: '/docs/ptBR/interceptors'
+---
+
+## Configurações padrões
+
+Você pode especificar configurações padrões que será aplicar em todas as requisições.
+
+### Configurações globais do axios
+
+```js
+axios.defaults.baseURL = 'https://api.example.com';
+axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;
+axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
+```
+
+### Padrões de instância personalizados
+
+```js
+// Define as configurações padrões quando cria a instância
+const instance = axios.create({
+  baseURL: 'https://api.example.com'
+});
+
+// Altera as configurações padrões após a instância ser criada
+instance.defaults.headers.common['Authorization'] = AUTH_TOKEN;
+```
+
+### Ordem de precedência
+
+As configurações serão mescladas pela ordem de precedente. A ordem é o padrão da biblioteca encontrados em [lib/defaults.js](https://github.com/axios/axios/blob/master/lib/defaults.js#L28), depos as propriedades `defaults` da instância, e finalmente `config` argumentos para a requisição. O último terá precedência sobre o primeiro. Aqui está um exemplo.
+
+```js
+// Cria uma instancia usando os padrões de configurações fornecidas pela biblioteca
+// Neste ponto o valor do timeout é de `0` pois é o padrão da biblioteca
+const instance = axios.create();
+
+// Sobrescreve o valor do tempo de espera da biblioteca
+// Agora todas as requisições que usarem está instancia terá que esperar 2.5 secundos antes do tempo se esgotar
+instance.defaults.timeout = 2500;
+
+// Sobrescreve o tempo de espera para apenas está requisição por levar um tempo maior
+instance.get('/longRequest', {
+  timeout: 5000
+});
+```

posts/ptBR/example.md

@@ -0,0 +1,67 @@
+---
+title: 'Exemplos minimalistas'
+description: 'Um pequeno exemplo de como usar o axios'
+prev_title: 'Introdução'
+prev_link: '/docs/ptBR/intro'
+next_title: 'Requisições POST'
+next_link: '/docs/ptBR/post_example'
+---
+
+## nota: Uso de CommonJS
+Em ordem de usar o TypeScript (para intellissen e/ou preenchimento automático) enquanto usando CommonJS, importe com o `require()` utilize a seguinte abordagem:
+
+```js
+const axios = require('axios').default;
+
+// axios.<método> agora o axios fornecerá preenchimento automático e tipagens de parâmetros
+```
+
+# Exemplo
+
+Executando uma requisição `GET`
+
+```js
+const axios = require('axios');
+
+// Faz uma requisição a um usuarío com um ID expecifico
+axios.get('/user?ID=12345')
+  .then(function (response) {
+    // manipula o sucesso da requisição
+    console.log(response);
+  })
+  .catch(function (error) {
+    // manipula erros da requisição
+    console.error(error);
+  })
+  .then(function () {
+    // sempre será executado
+  });
+
+// Opcionalmente a requisição acima poderia ser feita assim da seguinte forma
+axios.get('/user', {
+    params: {
+      ID: 12345
+    }
+  })
+  .then(function (response) {
+    console.log(response);
+  })
+  .catch(function (error) {
+    console.error(error);
+  })
+  .then(function () {
+    // sempre será executado
+  });  
+
+// Quer usar async/await? Adicione o prefixo `async` na sua função/método
+async function getUser() {
+  try {
+    const response = await axios.get('/user?ID=12345');
+    console.log(response);
+  } catch (error) {
+    console.error(error);
+  }
+}
+```
+> **NOTA:** `async/await` faz parte do ECMAScript 2017 e não é suportado no Internet
+> Explorer e versões antigas de browsers, use com cuidado.

posts/ptBR/handling_errors.md

@@ -0,0 +1,48 @@
+---
+title: 'Manipulando Erros'
+prev_title: 'Interceptadores'
+prev_link: '/docs/ptBR/interceptors'
+next_title: 'Cancelamento'
+next_link: '/docs/ptBR/cancellation'
+---
+
+```js
+axios.get('/user/12345')
+  .catch(function (error) {
+    if (error.response) {
+      // A requisição foi feita e o servidor respondeu com um código de status
+      // que sai do alcance de 2xx
+      console.error(error.response.data);
+      console.error(error.response.status);
+      console.error(error.response.headers);
+    } else if (error.request) {
+      // A requisição foi feita mas nenhuma resposta foi recebida
+      // `error.request` é uma instância do XMLHttpRequest no navegador e uma instância de
+      // http.ClientRequest no node.js
+      console.error(error.request);
+    } else {
+      // Alguma coisa acontenceu ao configurar a requisição que acionou este erro.
+      console.error('Error', error.message);
+    }
+    console.error(error.config);
+  });
+```
+
+Usando a configuração opcional `validadeStatus`, você pode definir o(s) código(s) HTTP que devem lançar um erro
+
+```js
+axios.get('/user/12345', {
+  validateStatus: function (status) {
+    return status < 500; // Resolve somente se o código de status for menor que 500
+  }
+})
+```
+
+Usando o `toJSON` você pode receber um objeto com mais informações sobre o erro HTTP.
+
+```js
+axios.get('/user/12345')
+  .catch(function (error) {
+    console.error(error.toJSON());
+  });
+```