Pular para o conteúdo principal
Versão: v2.8.1

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:

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 .

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 :

v1
  app := wails.CreateApp(/* options */)
app.Bind(basic)
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:

Nota: 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:

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.

Na v1, o runtime 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.

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:

.
├── 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:

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.

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:

v1v2Notes
namename
descriptionRemoved
author / nameauthor / name
author / emailauthor / email
versionversion
binarynameoutputfilenameChanged
frontend / dirRemoved
frontend / installfrontend:installChanged
frontend / buildfrontend:buildChanged
frontend / bridgeRemoved
frontend / serveRemoved
tagsRemoved
wailsjsdirThe directory to generate wailsjs modules
assetdirThe directory of the compiled frontend assets for dev mode. Normalmente, isto é inferido e pode ser deixado vazio.
reloaddirsLista 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.