.manifest` não existir, será criado a partir de uma versão padrão.
+- Compila a aplicação como uma compilação de produção (acima)
+- Usa [winres](https://github.com/tc-hib/winres) para empacotar o ícone e manifestar em um arquivo `.syso` pronto para vincular.
+
+#### Passos manuais
+
+- Crie `icon.ico` usando o [winicon](https://github.com/leaanthony/winicon) Ferramenta de CLI (ou qualquer outra ferramenta).
+- Criar / Atualizar o arquivo de `.manifest` para sua aplicação
+- Use o [winres CLI](https://github.com/tc-hib/go-winres) para gerar um arquivo `.syso`.
+
+### Compilar aplicação
+
+#### Wails CLI
+
+- Se o sinalizador `-clean` for fornecido, o diretório `build` é excluído e recriado
+- Para `wails dev`, as seguintes bandeiras Go padrão são usadas: `-tags dev -gcflags "all=-N -l"`
+- Para `wails build`, as seguintes flags padrão do Go são usadas: `-tags desktop,production -ldflags "-w -s"`
+ - No Windows, `-ldflags "-w -h -H windowsgui"`
+- Tags adicionais passadas para o CLI usando `-tags` são adicionadas aos padrões
+- Ldflags adicionais passadas para a CLI usando `-ldflags` são adicionados aos padrões
+- A bandeira `-o` é passada
+- O compilador Go especificado por `-compiler` será usado para compilação
+
+#### Passos manuais
+
+- Para compilação de desenvolvedores, o comando mínimo seria: `go build -tags dev -gcflags "all=-N -l"`
+- Para a compilação de produção, o comando mínimo seria: `go build -tags desktop,production -ldflags "-w -s -H windowsgui"`
+- Certifique-se de compilar no mesmo diretório que o arquivo `.syso`
+
+### Comprimir aplicativo
+
+#### Wails CLI
+
+- Se a flag `-upx` tiver sido dada, o programa `upx` será executado para comprimir o aplicativo com as configurações padrão
+- Se `-upxflags` também for colado, essas flags são usadas em vez das padrão
+
+#### Passos manuais
+
+- Execute `upx [flags]` manualmente para comprimir o aplicativo.
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/migrating.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/migrating.mdx
new file mode 100644
index 00000000000..a874b03f4f5
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/migrating.mdx
@@ -0,0 +1,191 @@
+# Migrando da v1
+
+## Visão geral
+
+Wails v2 é uma mudança significativa em relação à v1. Este documento visa destacar as mudanças e as etapas na migração de um projeto existente.
+
+### Criando uma aplicação Cli
+
+Na v1, o aplicativo principal é criado usando `wails.CreateApp`, as ligações são adicionadas com `app.Bind` e, em seguida, o o aplicativo é executado usando `app.Run()`.
+
+Exemplo:
+
+```go title="v1"
+ app := wails.CreateApp(&wails.AppConfig{
+ Title: "MyApp",
+ Width: 1024,
+ Height: 768,
+ JS: js,
+ CSS: css,
+ Colour: "#131313",
+ })
+ app.Bind(basic)
+ app.Run()
+```
+
+Na v2, há apenas um único método, `wails.Run()`, que aceita as opções de aplicação [](../reference/options.mdx#application-options).
+
+```go title="v2"
+ err := wails.Run(&options.App{
+ Title: "MyApp",
+ Width: 800,
+ Height: 600,
+ AssetServer: &assetserver.Options{
+ Assets: assets,
+ },
+ Bind: []interface{}{
+ basic,
+ },
+ })
+```
+
+### Mapeamento
+
+Na v1, foi possível vincular funções e estruturas arbitrárias. Em v2, foi simplificado apenas para estruturas vinculativas. As instâncias de construção que foram passadas anteriormente para o método `Bind()` na v1, estão agora especificados no campo `Vincular` do as opções de aplicação [](../reference/options.mdx#application-options):
+
+```go title="v1"
+ app := wails.CreateApp(/* options */)
+ app.Bind(basic)
+```
+
+```go title="v2"
+ err := wails.Run(&options.App{
+ /* other options */
+ Bind: []interface{}{
+ basic,
+ },
+ })
+```
+
+Na v1, métodos vinculados estavam disponíveis para o frontend em `window.backend`. Isto mudou para `window.go`
+
+### Ciclo de vida da Aplicação
+
+Na v1, havia 2 métodos especiais em uma estrutura vinculada: `WailsInit()` e `WailsShutdown()`. Foi substituído por três ganchos de ciclo de vida como parte das [opções do aplicativo](../reference/options.mdx#application-options):
+
+- [OnStartup](../reference/options.mdx#onstartup)
+- [OnShutdown](../reference/options.mdx#onshutdown)
+- [OnDomReady](../reference/options.mdx#ondomready)
+
+Nota: [OnDomReady](../reference/options.mdx#ondomready) substitui o evento do sistema `wails:ready` na v1.
+
+Estes métodos podem ser funções padrão, mas uma prática comum é tê-los incluído numa estrutura:
+
+```go title="v2"
+ basic := NewBasicApp()
+ err := wails.Run(&options.App{
+ /* Other Options */
+ OnStartup: basic.startup,
+ OnShutdown: basic.shutdown,
+ OnDomReady: basic.domready,
+ })
+...
+type Basic struct {
+ ctx context.Context
+}
+func (b *Basic) startup(ctx context.Context) {
+ b.ctx = ctx
+}
+...
+```
+
+### Tempo de execução
+
+O tempo de execução na v2 é muito mais rico que a v1 com suporte para menus, manipulação de janelas e melhores diálogos. A assinatura dos métodos mudou ligeiramente - consulte a [Referência de tempo de execução](../reference/runtime/intro.mdx).
+
+Na v1, o [runtime](../reference/runtime/intro.mdx) estava disponível através de uma struct passada para `WailsInit()`. Em v2, o tempo de execução foi movido para o seu próprio pacote. Cada método no tempo de execução leva o `context.Context` que é passado para o método [OnStartup](../reference/options.mdx#onstartup).
+
+```go title="Runtime Example"
+package main
+
+import "github.com/wailsapp/wails/v2/pkg/runtime"
+
+type Basic struct {
+ ctx context.Context
+}
+
+// startup is called at application startup
+func (a *App) startup(ctx context.Context) {
+ a.ctx = ctx
+ runtime.LogInfo(ctx, "Application Startup called!")
+}
+
+```
+
+### Assets
+
+A _maior mudança_ na v2 é como os ativos são geridos.
+
+Na v1, os ativos foram passados via 2 opções de aplicativo:
+
+- `JS` - O JavaScript do aplicativo
+- `CSS` - O CSS da aplicação
+
+Isso significava que a responsabilidade de gerar um único arquivo JS e CSS era do desenvolvedor. Isto exigia essencialmente a utilização de embalagens complicadas como o webpack.
+
+Na v2, Wails não faz suposições sobre seus ativos no frontend, como um servidor web. Todos os seus ativos de aplicação são passados para as opções de aplicação como um `embed.FS`.
+
+**Isso significa que não há necessidade de agrupar seus ativos, codificar imagens como Base64 ou experimente a arte obscura da configuração do bundler para usar fontes personalizadas**.
+
+Na inicialização, Wails verificará o `embed.FS` fornecido em busca de `index.html` e usará sua localização como caminho raiz para todos os outros ativos do aplicativo - assim como faria um servidor web.
+
+Exemplo: Uma aplicação tem o seguinte layout do projeto. Todos os arquivos finais são colocados no diretório `frontend/dist`:
+
+```shell
+.
+├── build/
+├── frontend/
+│ └── dist/
+│ ├── index.html
+│ ├── main.js
+│ ├── main.css
+│ └── logo.svg
+├── main.go
+└── wails.json
+```
+
+Esses ativos podem ser usados pelo aplicativo simplesmente criando um `embed.FS`:
+
+```go title="Assets Example"
+//go:embed all:frontend/dist
+var assets embed.FS
+
+func main() {
+ err := wails.Run(&options.App{
+ /* Other Options */
+ AssetServer: &assetserver.Options{
+ Assets: assets,
+ },
+ })
+}
+```
+
+Claro, empacotadores podem ser usados se você quiser. O único requisito é passar o diretório final de ativos do aplicativo para Wails usando um `embed.FS` no `Assets` chave das [opções do aplicativo](../reference/options.mdx#application-options).
+
+### Configuração do Projeto
+
+Na v1, a configuração do projeto foi armazenada no arquivo `project.json` na raiz do projeto. Na v2, a configuração do projeto é armazenada no arquivo `wails.json` na raiz do projeto.
+
+O formato do arquivo é ligeiramente diferente. Aqui está uma comparação:
+
+
+
+| v1 | v2 | Notes |
+| ------------------ | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| name | name | |
+| description | | Removed |
+| author / name | author / name | |
+| author / email | author / email | |
+| version | version | |
+| binaryname | outputfilename | Changed |
+| frontend / dir | | Removed |
+| frontend / install | frontend:install | Changed |
+| frontend / build | frontend:build | Changed |
+| frontend / bridge | | Removed |
+| frontend / serve | | Removed |
+| tags | | Removed |
+| | wailsjsdir | The directory to generate wailsjs modules |
+| | assetdir | The directory of the compiled frontend assets for `dev` mode. Normalmente, isto é inferido e pode ser deixado vazio. |
+| | reloaddirs | Lista separada por vírgulas de diretórios adicionais para observar alterações e acionar recarregamentos no modo `dev`. Isso só é necessário para algumas configurações de ativos mais avançadas. |
+
+
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/mouse-buttons.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/mouse-buttons.mdx
new file mode 100644
index 00000000000..054ac263bd1
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/mouse-buttons.mdx
@@ -0,0 +1,25 @@
+# Botões do Mouse
+
+As Wails runtime interceptam cliques do mouse para determinar se uma janela precisa ser redimensionada ou uma janela precisa ser movida. Foi perguntado como detectar quando um clique do mouse ocorreu, porque `window.onclick` não relata os botões do mouse corretamente. O código a seguir mostra como detectar cliques do mouse:
+
+```javascript
+window.addEventListener("mousedown", handleMouseButtonDown);
+
+function handleMouseButtonDown(event) {
+ if (event.button === 0) {
+ // left mouse button
+ } else if (event.button === 1) {
+ // middle mouse button
+ } else if (event.button === 2) {
+ // right mouse button
+ } else if (event.button === 3) {
+ // back mouse button
+ } else if (event.button === 4) {
+ // forward mouse button
+ } else {
+ // other mouse button
+ }
+}
+```
+
+Reference: https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/obfuscated.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/obfuscated.mdx
new file mode 100644
index 00000000000..d921a6a5fc2
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/obfuscated.mdx
@@ -0,0 +1,40 @@
+# Builds ofuscadas
+
+Wails inclui suporte para ofuscar a sua aplicação usando [garble](https://github.com/burrowers/garble).
+
+Para produzir uma compilação ofuscada, você pode usar o sinalizador `-obfuscate` com o comando `wails build`:
+
+```bash
+wails build -obfuscated
+```
+
+Para personalizar a configuração de ofuscação, pode-se utilizar a flag: `-garbleargs`:
+
+```bash
+wails build -obfuscated -garbleargs "-literals -tiny -seed=myrandomseed"
+```
+
+Essas configurações podem estar persistentes na configuração do seu [projeto](../reference/project-config).
+
+## Como funciona
+
+Em uma compilação padrão, todos os métodos vinculados estão disponíveis no frontend sob a variável `window.go`. Quando esses métodos são chamados, o método backend correspondente é chamado usando o nome da função totalmente qualificada. Quando usando uma compilação ofuscada, os métodos são vinculados usando um ID em vez de um nome. Os bindings gerados no diretório `wailsjs` usam esses IDs para chamar as funções de backend.
+
+:::note
+
+Para garantir que o seu aplicativo irá funcionar no modo ofuscado, você deve usar os bindings geradas sob o diretório `wailsjs` no seu aplicativo.
+
+:::
+
+## Exemplo
+
+Importing the "Greet" method from the bindings like this:
+
+```js
+import { Greet } from "../../wailsjs/go/main/App";
+
+// snip
+Greet("World");
+```
+
+irá garantir que o método funcionará corretamente no modo ofuscado, como os bindings serão regenerados com IDs e o mecanismo de chamada atualizado.
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/overscroll.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/overscroll.mdx
new file mode 100644
index 00000000000..dcd13f147c3
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/overscroll.mdx
@@ -0,0 +1,10 @@
+# Rolar demais
+
+[Overscroll](https://developer.mozilla.org/en-US/docs/Web/CSS/overscroll-behavior) é o "efeito de salto" que você às vezes obtém quando você rola além dos limites de conteúdo de uma página. This is common in mobile apps. Isso pode ser desativado usando CSS:
+
+```css
+html {
+ height: 100%;
+ overflow: hidden;
+}
+```
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/routing.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/routing.mdx
new file mode 100644
index 00000000000..550e73a57f4
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/routing.mdx
@@ -0,0 +1,47 @@
+# Roteamento
+
+O roteamento é uma maneira popular de alternar as telas de um aplicativo. Esta página oferece algumas orientações sobre como fazer isso.
+
+## Vue
+
+A abordagem recomendada para roteamento em Vue é o [Hash Mode](https://next.router.vuejs.org/guide/essentials/history-mode.html#hash-mode):
+
+```js
+import { createRouter, createWebHashHistory } from "vue-router";
+
+const router = createRouter({
+ history: createWebHashHistory(),
+ routes: [
+ //...
+ ],
+});
+```
+
+## Angular
+
+A abordagem recomendada para roteamento em Angular é [HashLocationStrategy](https://codecraft.tv/courses/angular/routing/routing-strategies#_hashlocationstrategy):
+
+```ts
+RouterModule.forRoot(routes, { useHash: true });
+```
+
+## React
+
+A abordagem recomendada para roteamento em React é [HashRouter](https://reactrouter.com/en/main/router-components/hash-router):
+
+```jsx
+import { HashRouter } from "react-router-dom";
+
+ReactDOM.render(
+
+ {/* The rest of your app goes here */}
+
+ } exact />
+ } />
+ } />
+ {/* more... */}
+
+ ,
+ root
+);
+```
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/signing.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/signing.mdx
new file mode 100644
index 00000000000..c3e0c269658
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/signing.mdx
@@ -0,0 +1,387 @@
+# Assinatura de Código
+
+Este é um guia sobre como você pode assinar seus binários gerados com Wails no MacOS e Windows. O guia visará ambientes de CI, mais especificamente as GitHub Actions.
+
+## Windows
+
+Primeiro você precisa de um certificado de assinatura de código. Se você ainda não tiver uma, a página de informações da Microsoft lista alguns provedores [aqui](https://docs.microsoft.com/en-us/windows-hardware/drivers/dashboard/get-a-code-signing-certificate). Observe que um certificado EV não é necessário a menos que você precise escrever um software no nível kernel como drivers de dispositivos. Para assinar o seu aplicativo Wails, um certificado de assinatura de código padrão vai dar certo.
+
+Pode ser uma boa ideia verificar com seu provedor de certificados como assinar seus binários na sua máquina local antes de direcionar sistemas de compilação automatizada. só para que você saiba se há exigências especiais. Por exemplo, [aqui](https://www.ssl.com/how-to/using-your-code-signing-certificate/) é o guia de assinatura de código de SSL.com para Windows. Se você sabe como assinar localmente, será mais fácil solucionar quaisquer possíveis problemas em um ambiente de CI. Por exemplo, os certificados de assinatura de código SSL.com exigem a flag `/tr` para [SignTool.exe](https://docs.microsoft.com/en-us/windows/win32/seccrypto/signtool) enquanto outros provedores só precisam da flag `/t` para fornecer o servidor de marcação de tempo. GitHub Actions populares para assinar binários Windows como [este](https://github.com/Dana-Prajea/code-sign-action) não suporta a flag `/tr` no SignTool.exe. Portanto, este guia focará em assinar nosso aplicativo manualmente com comandos do PowerShell, mas você pode usar ações como a ação de [de co-sign-action](https://github.com/Dana-Prajea/code-sign-action) se preferir.
+
+Em primeiro lugar, vamos nos certificar de que somos capazes de construir nosso aplicativo Wails no nosso GitHub CI. Aqui está um pequeno modelo de fluxo de trabalho:
+
+```yaml
+name: "example"
+on:
+ workflow_dispatch:
+ # This Action only starts when you go to Actions and manually run the workflow.
+
+jobs:
+ package:
+ strategy:
+ matrix:
+ platform: [windows-latest, macos-latest]
+ go-version: [1.18]
+ runs-on: ${{ matrix.platform }}
+ steps:
+ - uses: actions/checkout@v3
+ - name: Install Go
+ uses: actions/setup-go@v2
+ with:
+ go-version: ${{ matrix.go-version }}
+ - name: setup node
+ uses: actions/setup-node@v2
+ with:
+ node-version: 14
+ # You may need to manually build you frontend manually here, unless you have configured frontend build and install commands in wails.json.
+ - name: Get Wails
+ run: go install github.com/wailsapp/wails/v2/cmd/wails@latest
+ - name: Build Wails app
+ run: |
+ wails build
+ - name: upload artifacts macOS
+ if: matrix.platform == 'macos-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-macos
+ path: build/bin/*
+ - name: upload artifacts windows
+ if: matrix.platform == 'windows-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-windows
+ path: build/bin/*
+```
+
+Em seguida, precisamos dar ao fluxo de trabalho do GitHub acesso ao nosso certificado de assinatura. Isso é feito codificando seu certificado .pfx ou .p12 em uma string base64. Para fazer isso em PowerShell, use o seguinte comando assumindo que seu certificado se chama 'my-cert.p12':
+
+```PowerShell
+certutil -encode .\my-cert.p12 my-cert-base64.txt
+```
+
+Você deve ter seu arquivo .txt com o certificado codificado em base64. Deve começar com _-----BEGIN CERTIFICATE-----_ e terminar com _-----END CERTIFICATE-----_. Agora você precisa criar duas ações secretas no GitHub. Navegue até _Configurações -> Segredos -> Ações_ e crie os dois seguintes segredos:
+
+- **WIN_SIGNING_CERT** com o conteúdo de seu texto codificado no certificado base64.
+- **WIN_SIGNING_CERT_PASSWORD** com o conteúdo da sua senha do certificado.
+
+Agora estamos prontos para implementar a assinatura em nosso fluxo de trabalho usando um dos dois métodos:
+
+### Método 1: Assinar com comandos
+
+Esse método usa comandos PowerShell para assinar nosso aplicativo, e deixa o controle de todo o processo de assinatura.
+
+Após o passo `Build Wails app`, podemos adicionar o seguinte passo ao nosso fluxo de trabalho:
+
+```yaml
+- name: Sign Windows binaries
+ if: matrix.platform == 'windows-latest'
+ run: |
+ echo "Creating certificate file"
+ New-Item -ItemType directory -Path certificate
+ Set-Content -Path certificate\certificate.txt -Value '${{ secrets.WIN_SIGNING_CERT }}'
+ certutil -decode certificate\certificate.txt certificate\certificate.pfx
+ echo "Signing our binaries"
+ & 'C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe' sign /fd /t /f certificate\certificate.pfx /p '${{ secrets.WIN_SIGNING_CERT_PASSWORD }}'
+
+```
+
+Este script cria um novo diretório para o seu arquivo de certificado, cria o arquivo de certificado do nosso segredo base64, converte-o em um arquivo .pfx, e finalmente assina o binário. As seguintes variáveis precisam ser substituídas na última linha:
+
+- **signing algorithm**: geralmente sha256.
+- **timestamping server**: URL para o servidor de timestamping a ser usado com seu certificado.
+- **path to binary**: caminho para o binário que você deseja assinar.
+
+Dado que nossa configuração Wails tem `outputfilename` definido para "app.exe" e que temos um certificado de SSL.com, este é o nosso fluxo de trabalho:
+
+```yaml
+name: "example"
+on:
+ workflow_dispatch:
+ # This Action only starts when you go to Actions and manually run the workflow.
+
+jobs:
+ package:
+ strategy:
+ matrix:
+ platform: [windows-latest, macos-latest]
+ go-version: [1.18]
+ runs-on: ${{ matrix.platform }}
+ steps:
+ - uses: actions/checkout@v3
+ - name: Install Go
+ uses: actions/setup-go@v2
+ with:
+ go-version: ${{ matrix.go-version }}
+ - name: setup node
+ uses: actions/setup-node@v2
+ with:
+ node-version: 14
+ # You may need to manually build you frontend here, unless you have configured frontend build and install commands in wails.json.
+ - name: Get Wails
+ run: go install github.com/wailsapp/wails/v2/cmd/wails@latest
+ - name: Build Wails app
+ run: |
+ wails build
+ - name: Sign Windows binaries
+ if: matrix.platform == 'windows-latest'
+ run: |
+ echo "Creating certificate file"
+ New-Item -ItemType directory -Path certificate
+ Set-Content -Path certificate\certificate.txt -Value '${{ secrets.WIN_SIGNING_CERT }}'
+ certutil -decode certificate\certificate.txt certificate\certificate.pfx
+ echo "Signing our binaries"
+ & 'C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe' sign /fd sha256 /tr http://ts.ssl.com /f certificate\certificate.pfx /p '${{ secrets.WIN_SIGNING_CERT_PASSWORD }}' .\build\bin\app.exe
+
+ - name: upload artifacts macOS
+ if: matrix.platform == 'macos-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-macos
+ path: build/bin/*
+ - name: upload artifacts windows
+ if: matrix.platform == 'windows-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-windows
+ path: build/bin/*
+```
+
+### Método 2: assinar automaticamente com Action
+
+É possível usar um código Windows assinando uma ação como [este](https://github.com/marketplace/actions/code-sign-a-file-with-pfx-certificate) um, mas nota que requer um hash SHA1 para o certificado e um nome de certificado. Veja um exemplo de como configurá-lo na [loja da ações](https://github.com/marketplace/actions/code-sign-a-file-with-pfx-certificate).
+
+---
+
+## MacOS
+
+Primeiro você precisa do seu certificado de assinatura de código da Apple. Se você não tem uma, uma pesquisa simples do Google irá ajudá-lo a adquirir uma. Depois de ter o certificado, você precisa exportá-lo e codificá-lo para base64. [Este tutorial](https://localazy.com/blog/how-to-automatically-sign-macos-apps-using-github-actions) te mostra como fazer isso de uma maneira fácil. Depois de ter exportado seu arquivo de certificado .p12, você pode codificá-lo para base64, como visto no tutorial com o seguinte comando:
+
+```bash
+base64 Certificates.p12 | pbcopy
+```
+
+Agora você está pronto para criar alguns segredos de projeto do GitHub, assim como no Windows:
+
+- **APPLE_DEVELOPER_CERTIFICATE_P12_BASE64** com o conteúdo de seu certificado base64 recém-copiado.
+- **APPLE_DEVELOPER_CERTIFICATE_PASSWORD** com o conteúdo da senha do seu certificado.
+- **APPLE_PASSWORD** com o conteúdo de uma senha específica para sua conta Apple-ID que pode gerar [aqui](https://appleid.apple.com/account/manage).
+
+Vamos nos certificar de que somos capazes de construir nosso aplicativo Wails em nosso fluxo de trabalho do GitHub. Aqui está um pequeno modelo:
+
+```yaml
+name: "example"
+on:
+ workflow_dispatch:
+ # This Action only starts when you go to Actions and manually run the workflow.
+
+jobs:
+ package:
+ strategy:
+ matrix:
+ platform: [windows-latest, macos-latest]
+ go-version: [1.18]
+ runs-on: ${{ matrix.platform }}
+ steps:
+ - uses: actions/checkout@v3
+ - name: Install Go
+ uses: actions/setup-go@v2
+ with:
+ go-version: ${{ matrix.go-version }}
+ - name: setup node
+ uses: actions/setup-node@v2
+ with:
+ node-version: 14
+ # You may need to manually build you frontend here, unless you have configured frontend build and install commands in wails.json.
+ - name: Get Wails
+ run: go install github.com/wailsapp/wails/v2/cmd/wails@latest
+ - name: Build Wails app
+ run: |
+ wails build
+ - name: upload artifacts macOS
+ if: matrix.platform == 'macos-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-macos
+ path: build/bin/*
+ - name: upload artifacts windows
+ if: matrix.platform == 'windows-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-windows
+ path: build/bin/*
+```
+
+Para assinar o código no macOS, [gon](https://github.com/mitchellh/gon) é uma ferramenta muito útil para a assinatura do código e a comunicação com os servidores Apple, também escrito em Go, e será usado neste guia.
+
+Após o passo `Build Wails app`, adicione o seguinte ao fluxo de trabalho:
+
+```yaml
+- name: MacOS download gon for code signing and app notarization
+ if: matrix.platform == 'macos-latest'
+ run: |
+ brew install mitchellh/gon/gon
+```
+
+Agora precisamos configurar alguns arquivos de configuração do gon no nosso diretório `build/darwin`:
+
+1. gon-sign.json:
+
+```json
+{
+ "source": ["./build/bin/app.app"],
+ "bundle_id": "app.myapp",
+ "apple_id": {
+ "username": "my-appleid@email.com",
+ "password": "@env:APPLE_PASSWORD"
+ },
+ "sign": {
+ "application_identity": "Developer ID Application: My Name"
+ }
+}
+```
+
+Onde o `source` é o binário do seu Wails, `bundle_id` é o seu ID do pacote, `apple_id` contém o seu nome de usuário do ID Apple e a senha do aplicativo que você criou antes, e `sign.application_identity` é sua identidade que você pode encontrar executando o seguinte comando:
+
+```bash
+security find-identity -v -p codesigning
+```
+
+2. entitlements.plist:
+
+```plist
+
+
+
+
+ com.apple.security.app-sandbox
+
+ com.apple.security.network.client
+
+ com.apple.security.network.server
+
+ com.apple.security.files.user-selected.read-write
+
+ com.apple.security.files.downloads.read-write
+
+
+
+```
+
+Neste arquivo, você configura os direitos que você precisa para seu aplicativo, por exemplo, permissões de câmera se seu app usa a câmera. Leia mais sobre entitlements [aqui](https://developer.apple.com/documentation/bundleresources/entitlements).
+
+Verifique se você atualizou seu arquivo `Info.plist` com o mesmo pacote de ID que você digitou em `gon-sign.json`. Aqui está um arquivo `Info.plis` de exemplo:
+
+```plist
+
+
+ CFBundlePackageTypeAPPL
+ CFBundleNameMyApp
+ CFBundleExecutableapp
+ CFBundleIdentifierapp.myapp
+ CFBundleVersion0.1.0
+ CFBundleGetInfoStringMy app is cool and nice and chill and
+ CFBundleShortVersionString0.1.0
+ CFBundleIconFileiconfile
+ LSMinimumSystemVersion10.13.0
+ NSHighResolutionCapabletrue
+ LSApplicationCategoryTypepublic.app-category.utilities
+ NSHumanReadableCopyright© Me
+
+```
+
+Agora estamos prontos para adicionar a etapa de assinatura em nosso fluxo de trabalho após a construção do aplicativo Wails:
+
+```yaml
+- name: Import Code-Signing Certificates for macOS
+ if: matrix.platform == 'macos-latest'
+ uses: Apple-Actions/import-codesign-certs@v1
+ with:
+ # The certificates in a PKCS12 file encoded as a base64 string
+ p12-file-base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
+ # The password used to import the PKCS12 file.
+ p12-password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
+- name: Sign our macOS binary
+ if: matrix.platform == 'macos-latest'
+ run: |
+ echo "Signing Package"
+ gon -log-level=info ./build/darwin/gon-sign.json
+```
+
+Por favor, note que a assinatura de binários com Apple pode levar a de minutos a horas.
+
+## Arquivo de fluxo combinado:
+
+Aqui está nosso arquivo de fluxo de trabalho do GitHub com Windows + macOS combinados:
+
+```yaml
+name: "example combined"
+on:
+ workflow_dispatch:
+ # This Action only starts when you go to Actions and manually run the workflow.
+
+jobs:
+ package:
+ strategy:
+ matrix:
+ platform: [windows-latest, macos-latest]
+ go-version: [1.18]
+ runs-on: ${{ matrix.platform }}
+ steps:
+ - uses: actions/checkout@v3
+ - name: Install Go
+ uses: actions/setup-go@v2
+ with:
+ go-version: ${{ matrix.go-version }}
+ - name: setup node
+ uses: actions/setup-node@v2
+ with:
+ node-version: 14
+ # You may need to manually build you frontend here, unless you have configured frontend build and install commands in wails.json.
+ - name: Get Wails
+ run: go install github.com/wailsapp/wails/v2/cmd/wails@latest
+ - name: Build Wails app
+ run: |
+ wails build
+ - name: MacOS download gon for code signing and app notarization
+ if: matrix.platform == 'macos-latest'
+ run: |
+ brew install mitchellh/gon/gon
+ - name: Import Code-Signing Certificates for macOS
+ if: matrix.platform == 'macos-latest'
+ uses: Apple-Actions/import-codesign-certs@v1
+ with:
+ # The certificates in a PKCS12 file encoded as a base64 string
+ p12-file-base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
+ # The password used to import the PKCS12 file.
+ p12-password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
+ - name: Sign our macOS binary
+ if: matrix.platform == 'macos-latest'
+ run: |
+ echo "Signing Package"
+ gon -log-level=info ./build/darwin/gon-sign.json
+ - name: Sign Windows binaries
+ if: matrix.platform == 'windows-latest'
+ run: |
+ echo "Creating certificate file"
+ New-Item -ItemType directory -Path certificate
+ Set-Content -Path certificate\certificate.txt -Value '${{ secrets.WIN_SIGNING_CERT }}'
+ certutil -decode certificate\certificate.txt certificate\certificate.pfx
+ echo "Signing our binaries"
+ & 'C:/Program Files (x86)/Windows Kits/10/bin/10.0.17763.0/x86/signtool.exe' sign /fd sha256 /tr http://ts.ssl.com /f certificate\certificate.pfx /p '${{ secrets.WIN_SIGNING_CERT_PASSWORD }}' .\build\bin\Monitor.exe
+ - name: upload artifacts macOS
+ if: matrix.platform == 'macos-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-macos
+ path: build/bin/*
+ - name: upload artifacts windows
+ if: matrix.platform == 'windows-latest'
+ uses: actions/upload-artifact@v2
+ with:
+ name: wails-binaries-windows
+ path: build/bin/*
+```
+
+# Notas finais
+
+Este guia inspirado no projeto RiftShare e seu fluxo de trabalho, o que é altamente recomendado para verificar [aqui](https://github.com/achhabra2/riftshare/blob/main/.github/workflows/build.yaml).
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/single-instance-lock.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/single-instance-lock.mdx
new file mode 100644
index 00000000000..dc7706f8ffa
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/single-instance-lock.mdx
@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+ return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+ wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+ secondInstanceArgs = secondInstanceData.Args
+
+ println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+ println("user opened second from", secondInstanceData.WorkingDirectory)
+ runtime.WindowUnminimise(*wailsContext)
+ runtime.Show(*wailsContext)
+ go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+ // Create an instance of the app structure
+ app := NewApp()
+
+ // Create application with options
+ err := wails.Run(&options.App{
+ Title: "wails-open-file",
+ Width: 1024,
+ Height: 768,
+ AssetServer: &assetserver.Options{
+ Assets: assets,
+ },
+ BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+ OnStartup: app.startup,
+ SingleInstanceLock: &options.SingleInstanceLock{
+ UniqueId: "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+ OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+ },
+ Bind: []interface{}{
+ app,
+ },
+ })
+
+ if err != nil {
+ println("Error:", err.Error())
+ }
+}
+```
diff --git a/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/sveltekit.mdx b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/sveltekit.mdx
new file mode 100644
index 00000000000..8281281f325
--- /dev/null
+++ b/website/i18n/pt/docusaurus-plugin-content-docs/version-v2.9.0/guides/sveltekit.mdx
@@ -0,0 +1,153 @@
+# SvelteKit
+
+Este guia será para:
+
+1. Passos de instalação do Miminal - Os passos necessários para obter uma instalação mínima de Wails funcionando para o SvelteKit.
+2. Script de Instalação - Bash script para cumprir os passos de Instalação Mínima com a marca opcional de Wails.
+3. Notas importantes - Problemas que podem ser encontrados ao usar o SvelteKit + Wails e correções.
+
+## 1. Passos mínimos de instalação
+
+##### Instalar Wails para Svelte.
+
+- `wails init -n myapp -t svelte`
+
+##### Exclua o front-end do Svelte.
+
+- Navegue até a pasta myapp recém-criada.
+- Excluir a pasta chamada "frontend"
+
+##### Enquanto estiver na raiz do projeto Wails. Use o seu gerenciador de pacotes favorito e instale o SvelteKit como o novo frontend. Siga as instruções.
+
+- `npm create svelte@latest frontend`
+
+##### Modificar o wails.json.
+
+- Add `"wailsjsdir": "./frontend/src/lib",` Observe que é aqui que suas funções Go e runtime aparecerão.
+- Mude o frontend do seu gerenciador de pacotes se não estiver usando npm.
+
+##### Modificar o main.go.
+
+- O primeiro comentário `//go:embed all:frontend/dist` precisa ser alterado para `//go:embed all:frontend/build`
+
+##### Instalar/remover dependências usando seu gerenciador de pacote favorito.
+
+- Entre na sua pasta "frontend".
+- `npm i`
+- `npm uninstall @sveltejs/adapter-auto`
+- `npm i -D @sveltejs/adapter-static`
+
+##### Alterar adaptador em svelte.config.js
+
+- A primeira linha de arquivo altera `import adapter from '@sveltejs/adapter-auto';` to `import adapter from '@sveltejs/adapter-static';`
+
+##### Coloque o SvelteKit no modo SPA com pré-renderização.
+
+- Crie um arquivo sob myapp/frontend/src/routes/ chamado +layout.ts/+layout.js.
+- Adicione duas linhas ao recém-criado arquivo `export const prerender = true` e `export const ssr = false`
+
+##### Testar instalação.
+
+- Navegue de volta à raiz do projeto Wails (um diretório para cima).
+- execute `wails dev`
+- Se a aplicação não executar, por favor verifique os passos anteriores.
+
+## 2. Script de Instalação
+
+##### Este Script do Bash faz as etapas listadas acima. Certifique-se de ler o script e de entender o que o script está fazendo no seu computador.
+
+- Criar um arquivo sveltekit-wails.sh
+- Copie o código abaixo para o novo arquivo e o salve.
+- Torná-lo executável com `chmod +x sveltekit-wails.sh`
+- A marca é um parâmetro opcional abaixo que adiciona de volta na marca de fregueses. Deixe o terceiro parâmetro em branco para não inserir a marca das Wails.
+- Exemplo de uso: `./sveltekit-wails.sh pnpm newapp brand`
+
+##### sveltekit-wails.sh:
+
+```
+manager=$1
+project=$2
+brand=$3
+wails init -n $project -t svelte
+cd $project
+sed -i "s|npm|$manager|g" wails.json
+sed -i 's|"auto",|"auto",\n "wailsjsdir": "./frontend/src/lib",|' wails.json
+sed -i "s|all:frontend/dist|all:frontend/build|" main.go
+if [[ -n $brand ]]; then
+ mv frontend/src/App.svelte +page.svelte
+ sed -i "s|'./assets|'\$lib/assets|" +page.svelte
+ sed -i "s|'../wails|'\$lib/wails|" +page.svelte
+ mv frontend/src/assets .
+fi
+rm -r frontend
+$manager create svelte@latest frontend
+if [[ -n $brand ]]; then
+ mv +page.svelte frontend/src/routes/+page.svelte
+ mkdir frontend/src/lib
+ mv assets frontend/src/lib/
+fi
+cd frontend
+$manager i
+$manager uninstall @sveltejs/adapter-auto
+$manager i -D @sveltejs/adapter-static
+echo -e "export const prerender = true\nexport const ssr = false" > src/routes/+layout.ts
+sed -i "s|-auto';|-static';|" svelte.config.js
+cd ..
+wails dev
+```
+
+## 3. Notas importantes
+
+##### Os arquivos do servidor causarão falhas de construção.
+
+- \+layout.server.ts, +page.server.ts, +server.ts ou qualquer arquivo com "server" em nome falhará na construção enquanto todas as rotas forem pré-renderizadas.
+
+##### O tempo de execução do Wails descarrega com navegações de página inteira!
+
+- Tudo que causa navegações de página completa: `window.location.href = '//'` ou recarga do menu de contexto ao usar wails dev. Isso significa que você pode acabar perdendo a capacidade de chamar qualquer falha no aplicativo em tempo de execução. Há duas formas de trabalhar em torno desta questão.
+- Use `import { goto } from '$app/navigation'` e então chame `goto('//')` em sua + page.svelte. Isso impedirá uma navegação de página completa.
+- Se a navegação por página inteira não puder ser impedido que o tempo de execução do Wails seja adicionado a todas as páginas, adicionando o abaixo ao `` de myapp/frontend/src/app. Mt
+
+```
+
+...
+
+
+
+...
+
+```
+
+Veja https://wails.io/docs/guides/frontend para mais informações.
+
+##### Os dados de e-mail podem ser carregados e atualizados a partir de +page.ts/+page.js para +page.svelte.
+
+- \+page.ts/+page.js funciona bem com o load() https://kit.svelte.dev/docs/load#page-data
+- invalidateAll() em +page.svelte irá chamar load() de +page.ts/+page.js https://kit.svelte.dev/docs/load#rerunning-load-functions-manual-invalidation.
+
+##### Tratamento de erros
+
+- Erros esperados usando o erro Throw funcionam em +page.ts/+page.js com uma página +error.svelte. https://kit.svelte.dev/docs/errors#expected-errors
+- Erros inesperados farão com que o aplicativo se torne inutilizável. Somente a opção de recuperação (conhecida até agora) de erros inesperados é recarregar o aplicativo. Para fazer isso, crie um arquivo myapp/frontend/src/hooks.client.ts e adicione o código abaixo ao arquivo.
+
+```
+import { WindowReloadApp } from '$lib/wailsjs/runtime/runtime'
+export async function handleError() {
+ WindowReloadApp()
+}
+```
+
+##### Usando formas e funções de manipulação
+
+- A maneira mais simples é chamar uma função do formulário é o padrão, vincular:valor suas variáveis e evitar submissão `![]({require("@site/static/img/showcase/bboard.webp").default})
+ ![]({require("@site/static/img/showcase/cfntracker.webp").default}){kind=tracking}
+ ![]({require("@site/static/img/showcase/emailit.webp").default})
+ ![]({require("@site/static/img/showcase/encrypteasy.webp").default})
+ ![]({require("@site/static/img/showcase/esp-studio.png").default})
+ ![]({require("@site/static/img/showcase/filehound.webp").default})
+ ![]({require("@site/static/img/showcase/hiposter.webp").default})
+ ![]({require("@site/static/img/showcase/modalfilemanager.webp").default})
+ ![]({require("@site/static/img/showcase/mollywallet.webp").default})
+ ![]({require("@site/static/img/showcase/october.webp").default})
+ ![]({require("@site/static/img/showcase/optimus.webp").default})
+ ![]({require("@site/static/img/showcase/portfall.webp").default})
+ ![]({require("@site/static/img/showcase/restic-browser-2.png").default})
+ ![]({require("@site/static/img/showcase/riftshare-main.webp").default})
+ ![]({require("@site/static/img/showcase/scriptbar.webp").default})
+ ![]({require("@site/static/img/showcase/surge.png").default})
+ ![]({require("@site/static/img/showcase/wally.webp").default})
+ ![]({require("@site/static/img/showcase/warmine1.png").default})
+ ![]({require("@site/static/img/showcase/warmine2.png").default})
+ ![]({require("@site/static/img/showcase/wombat.webp").default})
+ ![]({require("@site/static/img/showcase/ytd.webp").default})
+ ![]({require("@site/static/img/defaultproject.webp").default})
+![]({require("@site/static/img/assetshandler-does-not-exist.webp").default})
+![]({require("@site/static/img/assetshandler-go-mod.webp").default})
+
+```
+
+Nous verrions ensuite ce qui suit:
+
+```mdx-code-block
+![]({require("@site/static/img/assetshandler-image.webp").default})
+![]({require("@site/static/img/vscode.webp").default})
+