Add PT-BR translations (#456)

* Translate final.md, hello_world.md, README.md, ROADMAP.md and SUMMARY.md

* Translatation complete

* Internationalization: move guide to en folder and preserve its history. (#494)

* Clean files and build mdBook with localization feature

* Rebase, remove leftovers and check book builds for every language: ✅

Co-authored-by: Jon Kelley <jkelleyrtp@gmail.com>

docs/guide/src/pt-br/getting_started/desktop.md

@@ -0,0 +1,46 @@
+# Aplicativo de área de trabalho
+
+Crie um aplicativo de desktop nativo autônomo que tenha a mesma aparência em todos os sistemas operacionais.
+
+Os aplicativos criados com o Dioxus geralmente têm menos de 5 MB de tamanho e usam os recursos existentes do sistema, para que não consumam quantidades extremas de RAM ou memória.
+
+Exemplos:
+
+- [Explorador de arquivos](https://github.com/DioxusLabs/example-projects/blob/master/file-explorer)
+- [Scanner WiFi](https://github.com/DioxusLabs/example-projects/blob/master/wifi-scanner)
+
+[![Exemplo do Explorador de Arquivos](https://raw.githubusercontent.com/DioxusLabs/example-projects/master/file-explorer/image.png)](https://github.com/DioxusLabs/example-projects/tree /master/file-explorer)
+
+## Suporte
+
+O desktop é uma plataforma poderosa para o Dioxus, mas atualmente é limitado em capacidade quando comparado à plataforma Web. Atualmente, os aplicativos de desktop são renderizados com a biblioteca WebView da própria plataforma, mas seu código Rust está sendo executado nativamente em um _thread_ nativo. Isso significa que as APIs do navegador _não_ estão disponíveis, portanto, renderizar WebGL, Canvas, etc. não é tão fácil quanto a Web. No entanto, as APIs do sistema nativo _são_ acessíveis, portanto, streaming, WebSockets, sistema de arquivos, etc., são todas APIs viáveis. No futuro, planejamos migrar para um renderizador DOM personalizado baseado em webrenderer com integrações WGPU.
+
+O Dioxus Desktop é construído a partir do [Tauri](https://tauri.app/). No momento, não há abstrações do Dioxus sobre atalhos de teclado, barra de menus, manuseio, etc., então você deve aproveitar o Tauri - principalmente [Wry](http://github.com/tauri-apps/wry/) e [ Tao](http://github.com/tauri-apps/tao)) diretamente.
+
+## Criando um projeto
+
+Crie uma nova caixa:
+
+```shell
+cargo new --bin demo
+cd demo
+```
+
+Adicione o Dioxus com o recurso `desktop` (isso irá editar o `Cargo.toml`):
+
+```shell
+cargo add dioxus --features desktop
+```
+
+> Se seu sistema não fornece a biblioteca `libappindicator3`, como Debian/bullseye, você pode habilitar a substituta `ayatana` com um _flag_ adicional:
+>
+> ```shell
+> # On Debian/bullseye use:
+> cargo add dioxus --features desktop --features ayatana
+> ```
+
+Edite seu `main.rs`:
+
+```rust
+{{#include ../../examples/hello_world_desktop.rs:all}}
+```

docs/guide/src/pt-br/getting_started/hot_reload.md

@@ -0,0 +1,31 @@
+# Configurando o Hot Reload
+
+1. O recarregamento em tempo-real (_hot reload_) permite tempos de iteração muito mais rápidos dentro de chamadas 'rsx', interpretando-as e transmitindo as edições.
+2. É útil para alterar o estilo/layout de um programa, mas não ajudará na alteração da lógica de um programa.
+3. Atualmente, o cli implementa apenas o _hot-reload_ para o renderizador da web.
+
+# Configurar
+
+Instale o [dioxus-cli](https://github.com/DioxusLabs/cli).
+Habilite o recurso de _hot-reload_ no dioxus:
+
+```toml
+dioxus = { version = "*", features = ["web", "hot-reload"] }
+```
+
+# Usage
+
+1. Execute:
+
+```
+dioxus serve --hot-reload
+```
+
+2. alterar algum código dentro de uma macro `rsx`
+3. abra seu `localhost` em um navegador
+4. salve e observe a mudança de estilo sem recompilar
+
+# Limitações
+
+1. O interpretador só pode usar expressões que existiam na última recompilação completa. Se você introduzir uma nova variável ou expressão na chamada `rsx`, ela acionará uma recompilação completa para capturar a expressão.
+2. Componentes e Iteradores podem conter código de Rust arbitrário e acionarão uma recompilação completa quando alterados.

docs/guide/src/pt-br/getting_started/index.md

@@ -0,0 +1,72 @@
+# Introdução
+
+Esta seção irá ajudá-lo a configurar seu projeto Dioxus!
+
+## Pré-requisitos
+
+### Editor
+
+O Dioxus se integra muito bem com o [plugin Rust-Analyzer LSP](https://rust-analyzer.github.io) que fornecerá realce de sintaxe apropriado, navegação de código, _folding_ e muito mais.
+
+### Rust
+
+Vá para [https://rust-lang.org](http://rust-lang.org) e instale o compilador Rust.
+
+É altamente recomendável ler o [livro oficial do Rust](https://doc.rust-lang.org/book/ch01-00-getting-started.html) _completamente_. No entanto, nossa esperança é que um aplicativo Dioxus possa servir como um ótimo primeiro projeto Rust. Com Dioxus, você aprenderá sobre:
+
+- Manipulação de erros
+- Estruturas, Funções, Enums
+- Closures
+- Macros
+
+Nós empenhamos muito cuidado para tornar a sintaxe do Dioxus familiar e fácil de entender, para que você não precise de conhecimento profundo sobre _async_, _lifetime_ ou _smart pointers_ até que você realmente comece a criar aplicativos Dioxus complexos.
+
+### Dependências Específicas da Plataforma
+
+#### Windows
+
+Os aplicativos da área de trabalho do Windows dependem do WebView2 – uma biblioteca que deve ser instalada em todas as distribuições modernas do Windows. Se você tiver o Edge instalado, o Dioxus funcionará bem. Se você _não_ tiver o Webview2, [você poderá instalá-lo pela Microsoft](https://developer.microsoft.com/en-us/microsoft-edge/webview2/). MS oferece 3 opções:
+
+1. Um pequeno _bootstrapper_ "evergreen" que buscará um instalador do CDN da Microsoft
+2. Um pequeno _instalador_ que buscará o Webview2 do CDN da Microsoft
+3. Uma versão vinculada estaticamente do Webview2 em seu binário final para usuários offline
+
+Para fins de desenvolvimento, use a Opção 1.
+
+#### Linux
+
+Os aplicativos Webview Linux requerem WebkitGtk. Ao distribuir, isso pode ser parte de sua árvore de dependência em seu `.rpm` ou `.deb`. No entanto, é muito provável que seus usuários já tenham o WebkitGtk.
+
+```bash
+sudo apt install libwebkit2gtk-4.0-dev libgtk-3-dev libappindicator3-dev
+```
+
+Ao usar o Debian/bullseye, o `libappindicator3-dev` não está mais disponível, pois foi substituído por `libayatana-appindicator3-dev`.
+
+```bash
+# on Debian/bullseye use:
+sudo apt install libwebkit2gtk-4.0-dev libgtk-3-dev libayatana-appindicator3-dev
+```
+
+Se você tiver problemas, certifique-se de ter todo o básico instalado, conforme descrito nos [documentos do Tauri](https://tauri.studio/v1/guides/getting-started/prerequisites#setting-up-linux).
+
+#### Mac OS
+
+Atualmente – tudo para macOS está integrado! No entanto, você pode encontrar um problema se estiver usando o Rust **nightly** devido a alguns problemas de permissão em nossa dependência do `Tao` (que foram resolvidos, mas não publicados).
+
+### Extensões do Cargo Sugeridas
+
+Se você quiser manter seu fluxo de trabalho tradicional como `npm install XXX` para adicionar pacotes, você pode querer instalar o `cargo-edit` e algumas outras extensões `cargo` interessantes:
+
+- [cargo-expand](https://github.com/dtolnay/cargo-expand) para expandir chamadas de macro
+- [árvore de carga](https://doc.rust-lang.org/cargo/commands/cargo-tree.html) – um comando de carga integrado que permite inspecionar sua árvore de dependência
+
+## Guias de configuração
+
+Dioxus suporta múltiplas plataformas. Dependendo do que você quer, a configuração é um pouco diferente.
+
+- [Web](web.md): rodando no navegador usando WASM
+- [Server Side Rendering](ssr.md): renderiza Dioxus HTML como texto
+- [Desktop](desktop.md): um aplicativo autônomo usando o webview
+- [Celular](mobile.md)
+- [Terminal UI](tui.md): interface gráfica baseada em texto do terminal

docs/guide/src/pt-br/getting_started/mobile.md

@@ -0,0 +1,75 @@
+# Aplicativo móvel
+
+Crie um aplicativo móvel com Dioxus!
+
+Exemplo: [Aplicativo Todo](https://github.com/DioxusLabs/example-projects/blob/master/ios_demo)
+
+## Suporte
+
+Atualmente, a plataforma móvel é o destino de renderizador menos suportado para o Dioxus. Os aplicativos móveis são renderizados com o WebView da plataforma, o que significa que animações, transparência e widgets nativos não estão disponíveis no momento.
+
+Além disso, o iOS é a única plataforma móvel compatível. É possível obter o Dioxus rodando no Android e renderizado com WebView, mas a biblioteca de janelas do Rust que o Dioxus usa – tao – atualmente não suporta Android.
+
+Atualmente, o suporte móvel é mais adequado para aplicativos no estilo CRUD, idealmente para equipes internas que precisam desenvolver rapidamente, mas não se importam muito com animações ou widgets nativos.
+
+## Configurando
+
+A configuração com dispositivos móveis pode ser bastante desafiadora. As ferramentas aqui não são ótimas (ainda) e podem precisar de alguns _hacks_ para fazer as coisas funcionarem. O macOS M1 é amplamente inexplorado e pode não funcionar para você.
+
+Vamos usar `cargo-mobile` para construir para dispositivos móveis. Primeiro, instale-o:
+
+```shell
+cargo install --git https://github.com/BrainiumLLC/cargo-mobile
+```
+
+E, em seguida, inicialize seu aplicativo para a plataforma certa. Use o modelo `winit` por enquanto. No momento, não há modelo "Dioxus" no cargo-mobile.
+
+```shell
+cargo mobile init
+```
+
+Nós vamos limpar completamente as `dependências` que ele gera para nós, trocando `winit` por `dioxus-mobile`.
+
+```toml
+
+[package]
+name = "dioxus-ios-demo"
+version = "0.1.0"
+authors = ["Jonathan Kelley <jkelleyrtp@gmail.com>"]
+edition = "2018"
+
+
+# leave the `lib` declaration
+[lib]
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+
+# leave the binary it generates for us
+[[bin]]
+name = "dioxus-ios-demo-desktop"
+path = "gen/bin/desktop.rs"
+
+# clear all the dependencies
+[dependencies]
+mobile-entry-point = "0.1.0"
+dioxus = { version = "*", features = ["mobile"] }
+simple_logger = "*"
+```
+
+Edite seu `lib.rs`:
+
+```rust
+use dioxus::prelude::*;
+
+fn main() {
+    dioxus::mobile::launch(app);
+}
+
+fn app(cx: Scope) -> Element {
+    cx.render(rsx!{
+        div {
+            "hello world!"
+        }
+    })
+}
+```

docs/guide/src/pt-br/getting_started/ssr.md

@@ -0,0 +1,108 @@
+# Renderização por Servidor
+
+O Dioxus 'VirtualDom' pode ser renderizado por servidor.
+
+[Exemplo: Dioxus DocSite](https://github.com/dioxusLabs/docsite)
+
+## Suporte a Multitarefas
+
+O Dioxus `VirtualDom`, infelizmente, atualmente não é `Send`. Internamente, usamos um pouco de mutabilidade interior que não é _thread-safe_. Isso significa que você não pode usar Dioxus facilmente com a maioria dos frameworks da web como Tide, Rocket, Axum, etc.
+
+Para resolver isso, você deve gerar um `VirtualDom` em seu próprio thread e se comunicar com ele por meio de canais.
+
+Ao trabalhar com frameworks web que requerem `Send`, é possível renderizar um `VirtualDom` imediatamente para uma `String` – mas você não pode manter o `VirtualDom` em um ponto de espera. Para SSR de estado retido (essencialmente LiveView), você precisará criar um _pool_ de `VirtualDoms`.
+
+## Configurar
+
+Se você quer apenas renderizar `rsx!` ou um VirtualDom para HTML, confira os documentos da API. É bem simples:
+
+```rust
+// We can render VirtualDoms
+let mut vdom = VirtualDom::new(app);
+let _ = vdom.rebuild();
+println!("{}", dioxus::ssr::render_vdom(&vdom));
+
+// Or we can render rsx! calls directly
+println!( "{}", dioxus::ssr::render_lazy(rsx! { h1 { "Hello, world!" } } );
+```
+
+No entanto, para este guia, vamos mostrar como usar Dioxus SSR com `Axum`.
+
+Certifique-se de ter o Rust and Cargo instalado e, em seguida, crie um novo projeto:
+
+```shell
+cargo new --bin demo
+cd app
+```
+
+Adicione o Dioxus com o recurso `ssr`:
+
+```shell
+cargo add dioxus --features ssr
+```
+
+Em seguida, adicione todas as dependências do Axum. Isso será diferente se você estiver usando um Web Framework diferente
+
+```
+cargo add tokio --features full
+cargo add axum
+```
+
+Suas dependências devem ficar mais ou menos assim:
+
+```toml
+[dependencies]
+axum = "0.4.5"
+dioxus = { version = "*", features = ["ssr"] }
+tokio = { version = "1.15.0", features = ["full"] }
+```
+
+Agora, configure seu aplicativo Axum para responder em um _endpoint_.
+
+```rust
+use axum::{response::Html, routing::get, Router};
+use dioxus::prelude::*;
+
+#[tokio::main]
+async fn main() {
+    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 3000));
+    println!("listening on http://{}", addr);
+
+    axum::Server::bind(&addr)
+        .serve(
+            Router::new()
+                .route("/", get(app_endpoint))
+                .into_make_service(),
+        )
+        .await
+        .unwrap();
+}
+```
+
+E, em seguida, adicione nosso _endpoint_. Podemos renderizar `rsx!` diretamente:
+
+```rust
+async fn app_endpoint() -> Html<String> {
+    Html(dioxus::ssr::render_lazy(rsx! {
+            h1 { "hello world!" }
+    }))
+}
+```
+
+Ou podemos renderizar `VirtualDoms`.
+
+```rust
+async fn app_endpoint() -> Html<String> {
+    fn app(cx: Scope) -> Element {
+        cx.render(rsx!(h1 { "hello world" }))
+    }
+    let mut app = VirtualDom::new(app);
+    let _ = app.rebuild();
+
+    Html(dioxus::ssr::render_vdom(&app))
+}
+```
+
+E é isso!
+
+> Você pode notar que não pode manter o VirtualDom em um ponto de espera. Dioxus atualmente não é ThreadSafe, então _deve_ permanecer no _thread_ que iniciou. Estamos trabalhando para flexibilizar essa exigência.

docs/guide/src/pt-br/getting_started/tui.md

@@ -0,0 +1,45 @@
+# IU do terminal
+
+Você pode construir uma interface baseada em texto que será executada no terminal usando o Dioxus.
+
+![Hello World screenshot](https://github.com/DioxusLabs/rink/raw/master/examples/example.png)
+
+> Nota: este livro foi escrito tendo em mente plataformas baseadas em HTML. Você pode acompanhar a TUI, mas terá que se adaptar um pouco.
+
+## Suporte
+
+O suporte à TUI é atualmente bastante experimental. Até o nome do projeto mudará. Mas, se você estiver disposto a se aventurar no reino do desconhecido, este guia o ajudará a começar.
+
+## Configurando
+
+Comece criando um novo pacote e adicionando nosso recurso TUI.
+
+```shell
+cargo new --bin demo
+cd demo
+cargo add dioxus --features tui
+```
+
+Em seguida, edite seu `main.rs` com o modelo básico.
+
+```rust
+{{#include ../../examples/hello_world_tui.rs}}
+```
+
+Para executar nosso aplicativo:
+
+```shell
+cargo run
+```
+
+Pressione "ctrl-c" para fechar o aplicativo. Para mudar de "ctrl-c" para apenas "q" para sair, você pode iniciar o aplicativo com uma configuração para desativar o sair padrão e usar a raiz TuiContext para sair por conta própria.
+
+```rust
+{{#include ../../examples/hello_world_tui_no_ctrl_c.rs}}
+```
+
+## Notas
+
+- Nosso pacote TUI usa flexbox para layout
+- 1px é a altura da linha de um caractere. Seu px CSS regular não traduz.
+- Se seu aplicativo entrar em pânico, seu terminal será destruído. Isso será corrigido eventualmente.

docs/guide/src/pt-br/getting_started/web.md

@@ -0,0 +1,74 @@
+# Web
+
+Crie aplicativos de página única (SPA) que são executados no navegador com o Dioxus. Para rodar na Web, seu aplicativo deve ser compilado para WebAssembly e utilizar a `crate` `dioxus` com o recurso `web` ativado.
+
+Uma compilação do Dioxus para a web será aproximadamente equivalente ao tamanho de uma compilação do React (70kb vs 65kb), mas carregará significativamente mais rápido devido ao [StreamingCompile do WebAssembly](https://hacks.mozilla.org/2018/01/making-webassembly-even-faster-firefoxs-new-streaming-and-tiering-compiler/).
+
+Exemplos:
+
+- [TodoMVC](https://github.com/DioxusLabs/example-projects/tree/master/todomvc)
+- [ECommerce](https://github.com/DioxusLabs/example-projects/tree/master/ecommerce-site)
+
+[![Exemplo de TodoMVC](https://github.com/DioxusLabs/example-projects/raw/master/todomvc/example.png)](https://github.com/DioxusLabs/example-projects/blob/master /todomvc)
+
+> Nota: Devido às limitações do Wasm, nem todos as `crates` funcionarão com seus aplicativos da web, portanto, você precisará certificar-se de que suas `crates` funcionem sem chamadas de sistema nativas (temporizadores, IO, etc.).
+
+## Suporte
+
+A Web é a plataforma de destino com melhor suporte para Dioxus.
+
+## Ferramentas
+
+Para desenvolver seu aplicativo Dioxus para a web, você precisará de uma ferramenta para construir e servir seus itens. Recomendamos usar [trunk](https://trunkrs.dev) que inclui um sistema de compilação, otimização Wasm, um servidor dev e suporte para SASS/CSS:
+
+```shell
+cargo install trunk
+```
+
+Certifique-se de que o destino `wasm32-unknown-unknown` esteja instalado:
+
+```shell
+rustup target add wasm32-unknown-unknown
+```
+
+## Criando um Projeto
+
+Crie uma nova caixa:
+
+```shell
+cargo new --bin demo
+cd demo
+```
+
+Adicione o Dioxus como uma dependência com o recurso `web`:
+
+```bash
+cargo add dioxus --features web
+```
+
+Adicione um `index.html` para o `Trunk` usar. Certifique-se de que seu elemento "mount point" tenha um ID de "main":
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  </head>
+  <body>
+    <div id="main"></div>
+  </body>
+</html>
+```
+
+Edite seu `main.rs`:
+
+```rust
+{{#include ../../examples/hello_world_web.rs}}
+```
+
+E para servir nosso aplicativo:
+
+```bash
+trunk serve
+```