runtime.Store => wails.Store

Update() can now take specialised functions

.github/workflows/latest-pre.yml

@@ -0,0 +1,32 @@
+name: latest pre-release
+on:
+  push:
+    tags:
+    - '**-pre**'
+jobs:
+
+  build:
+    name: Test Build Latest Pre-Release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+
+    - name: Set up Go 1.13
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v1
+
+    - name: Get dependencies
+      run: |
+        go get -v -d ./...
+    - name: Build
+      run: go build -v ./cmd/wails
+
+    - name: Test
+      run: ./wails version

.github/workflows/pr.yml

@@ -0,0 +1,32 @@
+name: pr
+on:
+  pull_request:
+    branches:
+    - develop
+jobs:
+
+  build:
+    name: Test Build PR
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+
+    - name: Set up Go 1.13
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v1
+
+    - name: Get dependencies
+      run: |
+        go get -v -d ./...
+    - name: Build
+      run: go build -v ./cmd/wails
+
+    - name: Test
+      run: ./wails version

.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: release
+on:
+  push:
+    branches:
+    - master
+    tags:
+    - '!**pre**'
+jobs:
+
+  build:
+    name: Test Build Latest Release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+
+    - name: Set up Go 1.13
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v1
+
+    - name: Get dependencies
+      run: |
+        go get -v -d ./...
+    - name: Build
+      run: go build -v ./cmd/wails
+
+    - name: Test
+      run: ./wails version

CONTRIBUTORS.md

@@ -2,22 +2,34 @@
 
 Wails is what it is because of the time and effort given by these great people. A huge thank you to each and every one!
 
-* [Dustin Krysak](https://wiki.ubuntu.com/bashfulrobot)
+  * [Dustin Krysak](https://wiki.ubuntu.com/bashfulrobot)
-* [Qais Patankar](https://github.com/qaisjp)
+  * [Qais Patankar](https://github.com/qaisjp)
-* [Anthony Lee](https://github.com/alee792)
+  * [Anthony Lee](https://github.com/alee792)
-* [Adrian Lanzafame](https://github.com/lanzafame)
+  * [Adrian Lanzafame](https://github.com/lanzafame)
-* [Mattn](https://github.com/mattn)
+  * [Mattn](https://github.com/mattn)
-* [0xflotus](https://github.com/0xflotus)
+  * [0xflotus](https://github.com/0xflotus)
-* [Michael D Henderson](https://github.com/mdhender)
+  * [Michael D Henderson](https://github.com/mdhender)
-* [fred2104](https://github.com/fishfishfish2104)
+  * [fred2104](https://github.com/fishfishfish2104)
-* [intelwalk](https://github.com/intelwalk)
+  * [intelwalk](https://github.com/intelwalk)
-* [Mark Stenglein](https://github.com/ocelotsloth)
+  * [Mark Stenglein](https://github.com/ocelotsloth)
-* [admin_3.exe](https://github.com/bh90210)
+  * [admin_3.exe](https://github.com/bh90210)
-* [iceleo-com](https://github.com/iceleo-com)
+  * [iceleo-com](https://github.com/iceleo-com)
-* [fallendusk](https://github.com/fallendusk)
+  * [fallendusk](https://github.com/fallendusk)
-* [Florian Didran](https://github.com/fdidron)
+  * [Nikolai Zimmermann](https://github.com/Chronophylos)
-* [Nikolai Zimmermann](https://github.com/Chronophylos)
+  * [Toyam Cox](https://github.com/Vaelatern)
-* [Toyam Cox](https://github.com/Vaelatern)
+  * [Robin Eklind](https://github.com/mewmew)
-* [Robin Eklind](https://github.com/mewmew)
+  * [Kris Raney](https://github.com/kraney)
-* [Kris Raney](https://github.com/kraney)
+  * [Jack Mordaunt](https://github.com/JackMordaunt)
-* [Jack Mordaunt](https://github.com/JackMordaunt)
+  * [Michael Hipp](https://github.com/MichaelHipp)
+  * [Travis McLane](https://github.com/tmclane)
+  * [Reuben Thomas-Davis](https://github.com/Rested)
+  * [Jarek](https://github.com/Jarek-SRT)
+  * [Konez2k](https://github.com/konez2k)
+  * [msms](https://github.com/sayuthisobri)
+  * [dedo1911](https://github.com/dedo1911)
+  * [Florian Didron](https://github.com/fdidron)
+  * [Christopher Murphy](https://github.com/Splode)
+  * [Zámbó, Levente](https://github.com/Lyimmi)
+  * [artem](https://github.com/Unix4ever)
+  * [Tim Kipp](https://github.com/timkippdev)
+  * [Dmitry Gomzyakov](https://github.com/kyoto44)

README.md

@@ -1,5 +1,5 @@
 <p align="center" style="text-align: center">
-   <img src="https://github.com/wailsapp/docs/raw/master/.vuepress/public/media/logo_cropped.png" width="40%"><br/>
+   <img src="logo_cropped.png" width="40%"><br/>
 </p>
 <p align="center">
    A framework for building desktop applications using Go & Web Technologies.<br/><br/>
@@ -11,11 +11,14 @@
    <a href="https://app.fossa.io/projects/git%2Bgithub.com%2Fwailsapp%2Fwails?ref=badge_shield" alt="FOSSA Status"><img src="https://app.fossa.io/api/projects/git%2Bgithub.com%2Fwailsapp%2Fwails.svg?type=shield"/></a>
    <a href="https://houndci.com"><img src="https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg"/></a>
    <a href="https://github.com/avelino/awesome-go" rel="nofollow"><img src="https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg" alt="Awesome"></a>
-   <a href="https://dev.azure.com/leaanthony/Wails/_build/latest?definitionId=1&branchName=master" rel="nofollow"><img src="https://dev.azure.com/leaanthony/Wails/_apis/build/status/wailsapp.wails?branchName=master" alt="Pipelines"></a>
+   <a href="https://github.com/wailsapp/wails/workflows/release/badge.svg?branch=master" rel="nofollow"><img src="https://github.com/wailsapp/wails/workflows/release/badge.svg?branch=master" alt="Release Pipelines"></a>
+   <a href="https://github.com/wailsapp/wails/workflows/latest-pre/badge.svg?branch=masterr" rel="nofollow"><img src="https://github.com/wailsapp/wails/workflows/latest-pre/badge.svg?branch=master" alt="Pre-Release Pipelines"></a>
 </p>
 
 The traditional method of providing web interfaces to Go programs is via a built-in web server. Wails offers a different approach: it provides the ability to wrap both Go code and a web frontend into a single binary. Tools are provided to make this easy for you by handling project creation, compilation and bundling. All you have to do is get creative!
 
+The official docs can be found at [https://wails.app](https://wails.app).
+
 ## Features
 
 - Use standard Go libraries/frameworks for the backend
@@ -28,15 +31,12 @@ The traditional method of providing web interfaces to Go programs is via a built
 - Powerful cli tool
 - Multiplatform
 
-## Project Status
-
-Wails is currently in Beta. Please make sure you read the [Project Status](https://wails.app/project_status.html) if you are interested in using this project.
 
 ## Installation
 
 Wails uses cgo to bind to the native rendering engines so a number of platform dependent libraries are needed as well as an installation of Go. The basic requirements are:
 
-- Go 1.12
+- Go 1.13
 - npm
 
 ### MacOS
@@ -55,9 +55,9 @@ _Debian: 8, 9, 10_
 
 _Ubuntu: 16.04, 18.04, 19.04_
 
-_Also succesfully tested on: Zorin 15, Parrot 4.7, Linuxmint 19, Elementary 5, Kali, Neon_
+_Also succesfully tested on: Zorin 15, Parrot 4.7, Linuxmint 19, Elementary 5, Kali, Neon_, Pop!_OS
 
-#### Arch Linux
+#### Arch Linux / ArchLabs / Ctlos Linux
 
 `sudo pacman -S webkit2gtk gtk3`
 
@@ -94,7 +94,7 @@ Windows requires gcc and related tooling. The recommended download is from [http
 Installation is as simple as running the following command:
 
 <pre style='color:white'>
-go get github.com/wailsapp/wails/cmd/wails
+go get -u github.com/wailsapp/wails/cmd/wails
 </pre>
 
 ## Next Steps
@@ -126,8 +126,7 @@ And without [these people](CONTRIBUTORS.md), it wouldn't be what it is today. A
 
 Special Mentions:
 
-  * [Bill Kennedy](https://twitter.com/goinggodotnet) - Go guru, encourager and all-round nice guy, whose infectious energy and inspiration powered me on when I had none left.
+  * [Byron](https://github.com/bh90210) - At times, Byron has single handedly kept this project alive. Without his incredible input, we never would have got to v1.
-  * [Mark Bates](https://github.com/markbates) - Creator of [Packr](https://github.com/gobuffalo/packr), inspiration for packing strategies which fed into some of the tooling.
 
 This project was mainly coded to the following albums:
 
@@ -148,3 +147,11 @@ This project was mainly coded to the following albums:
 ## Licensing
 
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fwailsapp%2Fwails.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fwailsapp%2Fwails?ref=badge_large)
+
+## Special Thank You
+
+<p align="center" style="text-align: center">
+   A special thank you to JetBrains for donating licenses to us!<br/><br/>
+   Please click the logo to let them know your appreciation!<br/><br/>
+   <a href="https://www.jetbrains.com?from=Wails"><img src="jetbrains-grayscale.png" width="30%"></a>
+</p>

app.go

@@ -1,7 +1,6 @@
 package wails
 
 import (
-	"fmt"
 	"os"
 	"runtime"
 	"syscall"
@@ -14,6 +13,7 @@ import (
 	"github.com/wailsapp/wails/lib/ipc"
 	"github.com/wailsapp/wails/lib/logger"
 	"github.com/wailsapp/wails/lib/renderer"
+	wailsruntime "github.com/wailsapp/wails/runtime"
 )
 
 // -------------------------------- Compile time Flags ------------------------------
@@ -21,6 +21,16 @@ import (
 // BuildMode indicates what mode we are in
 var BuildMode = cmd.BuildModeProd
 
+// Runtime is the Go Runtime struct
+type Runtime = wailsruntime.Runtime
+
+// Store is a state store used for syncing with
+// the front end
+type Store = wailsruntime.Store
+
+// CustomLogger is a specialised logger
+type CustomLogger = logger.CustomLogger
+
 // ----------------------------------------------------------------------------------
 
 // App defines the main application struct
@@ -45,7 +55,7 @@ func CreateApp(optionalConfig ...*AppConfig) *App {
 	}
 
 	result := &App{
-		logLevel:       "info",
+		logLevel:       "debug",
 		renderer:       renderer.NewWebView(),
 		ipc:            ipc.NewManager(),
 		bindingManager: binding.NewManager(),
@@ -67,28 +77,12 @@ func CreateApp(optionalConfig ...*AppConfig) *App {
 		result.config.DisableInspector = true
 	}
 
-	// If running windows, do a hidpi fix
+	// Platform specific init
-	if runtime.GOOS == "windows" {
+	platformInit()
-		err := SetProcessDPIAware()
-		if err != nil {
-			result.log.Fatalf(err.Error())
-		}
-	}
 
 	return result
 }
 
-// SetProcessDPIAware via user32.dll
-// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setprocessdpiaware
-// Also, thanks Jack Mordaunt! https://github.com/wailsapp/wails/issues/293
-func SetProcessDPIAware() error {
-	status, r, err := syscall.NewLazyDLL("user32.dll").NewProc("SetProcessDPIAware").Call()
-	if status == 0 {
-		return fmt.Errorf("exit status %d: %v %v", status, r, err)
-	}
-	return nil
-}
-
 // Run the app
 func (a *App) Run() error {
 
@@ -114,7 +108,7 @@ func (a *App) start() error {
 
 	// Check if we are to run in bridge mode
 	if BuildMode == cmd.BuildModeBridge {
-		a.renderer = &renderer.Bridge{}
+		a.renderer = renderer.NewBridge()
 	}
 
 	// Initialise the renderer
@@ -123,6 +117,11 @@ func (a *App) start() error {
 		return err
 	}
 
+	// Enable console for Windows debug builds
+	if runtime.GOOS == "windows" && BuildMode == cmd.BuildModeDebug {
+		a.renderer.EnableConsole()
+	}
+
 	// Start signal handler
 	t := tebata.New(os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
 	t.Reserve(func() {
@@ -137,7 +136,7 @@ func (a *App) start() error {
 	a.ipc.Start(a.eventManager, a.bindingManager)
 
 	// Create the runtime
-	a.runtime = NewRuntime(a.eventManager, a.renderer)
+	a.runtime = wailsruntime.NewRuntime(a.eventManager, a.renderer)
 
 	// Start binding manager and give it our renderer
 	err = a.bindingManager.Start(a.renderer, a.runtime)

app_other.go

@@ -0,0 +1,7 @@
+// +build linux darwin !windows
+
+package wails
+
+func platformInit() {
+
+}

app_windows.go

@@ -0,0 +1,27 @@
+// +build windows !linux !darwin
+
+package wails
+
+import (
+	"fmt"
+	"log"
+	"syscall"
+)
+
+func platformInit() {
+	err := SetProcessDPIAware()
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+}
+
+// SetProcessDPIAware via user32.dll
+// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setprocessdpiaware
+// Also, thanks Jack Mordaunt! https://github.com/wailsapp/wails/issues/293
+func SetProcessDPIAware() error {
+	status, r, err := syscall.NewLazyDLL("user32.dll").NewProc("SetProcessDPIAware").Call()
+	if status == 0 {
+		return fmt.Errorf("exit status %d: %v %v", status, r, err)
+	}
+	return nil
+}

azure-pipelines.yaml

@@ -1,138 +0,0 @@
-# avoid double trigger by applying some rules
-# start a pipeline when push to 'master' branch 
-trigger:
-- master
-# or when pull request on 'develop' branch
-pr:
-- develop
-
-# for now there is only one stage 'Build'
-# in the future we could use multistage strategy for releases
-stages:
-- stage: Build
-
-  # there are 3 jobs
-  # one for each os
-  jobs:
-  - deployment: Linux
-    displayName: Lin
-    variables:
-      GOPATH: '$(Agent.BuildDirectory)/gopath' # Go workspace path
-      GOROOT: '$(Agent.BuildDirectory)/go' # Go installation path
-      GOBIN:  '$(GOPATH)/bin' # Go binaries path
-      GOMODULE: 'on'
-      modulePath: '$(Agent.BuildDirectory)/wails' # Path to the module's code
-    pool:
-      vmImage: 'Ubuntu-16.04'
-    environment: 'linux-dev'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - checkout: self  # self represents the repo where the initial Pipelines YAML file was found
-            clean: true  # whether to fetch clean each time
-            path: wails  # path to check out source code, relative to the agent's build directory (e.g. \_work\1)
-            # go version 1.12.7
-          - script: |
-              wget "https://storage.googleapis.com/golang/go1.12.7.linux-amd64.tar.gz" --output-document "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-              tar -C '$(Agent.BuildDirectory)' -xzf "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-            displayName: 'Install Go 1.12.7 Linux'
-          - script: |
-              mkdir -p '$(GOBIN)'
-              mkdir -p '$(GOPATH)/pkg'
-              mkdir -p '$(GOROOT)'
-              shopt -s extglob
-              shopt -s dotglob
-              echo '##vso[task.prependpath]$(GOBIN)'
-              echo '##vso[task.prependpath]$(GOROOT)/bin'
-            displayName: 'Set up the Go workspace'
-          - script: |
-              go version
-              go get -v -d ./...
-              cd cmd/wails
-              go install
-            workingDirectory: '$(modulePath)'
-            displayName: 'Get dependencies, then build'
-          - script: |
-              wails version
-            workingDirectory: '$(modulePath)'
-            displayName: 'Check we have output'
-
-  - deployment: Mac
-    displayName: Mac
-    variables:
-      GOPATH: '$(Agent.BuildDirectory)/gopath' # Go workspace path
-      GOROOT: '$(Agent.BuildDirectory)/go' # Go installation path
-      GOBIN:  '$(GOPATH)/bin' # Go binaries path
-      GOMODULE: 'on'
-      modulePath: '$(Agent.BuildDirectory)/wails' # Path to the module's code
-    pool:
-      vmImage: 'macOS-10.14'
-    environment: 'mac-dev'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - checkout: self  # self represents the repo where the initial Pipelines YAML file was found
-            clean: true  # whether to fetch clean each time
-            path: wails  # path to check out source code, relative to the agent's build directory (e.g. \_work\1)
-          # go version 1.12.7
-          - script: |
-              wget "https://storage.googleapis.com/golang/go1.12.7.darwin-amd64.tar.gz" --output-document "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-              tar -C '$(Agent.BuildDirectory)' -xzf "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-            displayName: 'Install Go 1.12.7 Linux'
-          - script: |
-              mkdir -p '$(GOBIN)'
-              mkdir -p '$(GOPATH)/pkg'
-              mkdir -p '$(GOROOT)'
-              shopt -s extglob
-              shopt -s dotglob
-              echo '##vso[task.prependpath]$(GOBIN)'
-              echo '##vso[task.prependpath]$(GOROOT)/bin'
-            displayName: 'Set up the Go workspace'
-          - script: |
-              go version
-              go get -v -d ./...
-              cd cmd/wails
-              go install
-            workingDirectory: '$(modulePath)'
-            displayName: 'Get dependencies, then build'
-          - script: |
-              wails version
-            workingDirectory: '$(modulePath)'
-            displayName: 'Check we have output'
-
-  - deployment: Win
-    displayName: Win
-    variables:
-      GOMODULE: 'on'
-      modulePath: '$(Agent.BuildDirectory)/wails' # Path to the module's code
-    pool:
-      vmImage: 'windows-2019'
-    environment: 'win-dev'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - checkout: self  # self represents the repo where the initial Pipelines YAML file was found
-            clean: true  # whether to fetch clean each time
-            path: wails  # path to check out source code, relative to the agent's build directory (e.g. \_work\1)
-          # Go tool installer
-          # Find in cache or download a specific version of Go and add it to the PATH
-          - task: GoTool@0
-            inputs:
-              version: '1.12.7' 
-              goPath: '$(Agent.BuildDirectory)/go'
-              goBin: '$(Agent.BuildDirectory)/go/bin'
-            displayName: 'Set up the Go workspace'
-          - script: |
-              go version
-              go get -v -d ./...
-              cd cmd/wails
-              go install
-            workingDirectory: '$(modulePath)'
-            displayName: 'Get dependencies, then build'
-          - script: |
-              wails version
-            workingDirectory: '$(Agent.BuildDirectory)/go/bin'
-            displayName: 'Check we have output'

azure-pipelines.yml

@@ -1,138 +0,0 @@
-# avoid double trigger by applying some rules
-# start a pipeline when push to 'master' branch 
-trigger:
-- master
-# or when pull request on 'develop' branch
-pr:
-- develop
-
-# for now there is only one stage 'Build'
-# in the future we could use multistage strategy for releases
-stages:
-- stage: Build
-
-  # there are 3 jobs
-  # one for each os
-  jobs:
-  - deployment: Linux
-    displayName: Lin
-    variables:
-      GOPATH: '$(Agent.BuildDirectory)/gopath' # Go workspace path
-      GOROOT: '$(Agent.BuildDirectory)/go' # Go installation path
-      GOBIN:  '$(GOPATH)/bin' # Go binaries path
-      GOMODULE: 'on'
-      modulePath: '$(Agent.BuildDirectory)/wails' # Path to the module's code
-    pool:
-      vmImage: 'Ubuntu-16.04'
-    environment: 'linux-dev'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - checkout: self  # self represents the repo where the initial Pipelines YAML file was found
-            clean: true  # whether to fetch clean each time
-            path: wails  # path to check out source code, relative to the agent's build directory (e.g. \_work\1)
-            # go version 1.12.7
-          - script: |
-              wget "https://storage.googleapis.com/golang/go1.12.7.linux-amd64.tar.gz" --output-document "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-              tar -C '$(Agent.BuildDirectory)' -xzf "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-            displayName: 'Install Go 1.12.7 Linux'
-          - script: |
-              mkdir -p '$(GOBIN)'
-              mkdir -p '$(GOPATH)/pkg'
-              mkdir -p '$(GOROOT)'
-              shopt -s extglob
-              shopt -s dotglob
-              echo '##vso[task.prependpath]$(GOBIN)'
-              echo '##vso[task.prependpath]$(GOROOT)/bin'
-            displayName: 'Set up the Go workspace'
-          - script: |
-              go version
-              go get -v -d ./...
-              cd cmd/wails
-              go install
-            workingDirectory: '$(modulePath)'
-            displayName: 'Get dependencies, then build'
-          - script: |
-              wails version
-            workingDirectory: '$(modulePath)'
-            displayName: 'Check we have output'
-
-  - deployment: Mac
-    displayName: Mac
-    variables:
-      GOPATH: '$(Agent.BuildDirectory)/gopath' # Go workspace path
-      GOROOT: '$(Agent.BuildDirectory)/go' # Go installation path
-      GOBIN:  '$(GOPATH)/bin' # Go binaries path
-      GOMODULE: 'on'
-      modulePath: '$(Agent.BuildDirectory)/wails' # Path to the module's code
-    pool:
-      vmImage: 'macOS-10.14'
-    environment: 'mac-dev'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - checkout: self  # self represents the repo where the initial Pipelines YAML file was found
-            clean: true  # whether to fetch clean each time
-            path: wails  # path to check out source code, relative to the agent's build directory (e.g. \_work\1)
-          # go version 1.12.7
-          - script: |
-              wget "https://storage.googleapis.com/golang/go1.12.7.darwin-amd64.tar.gz" --output-document "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-              tar -C '$(Agent.BuildDirectory)' -xzf "$(Agent.BuildDirectory)/go1.12.7.tar.gz"
-            displayName: 'Install Go 1.12.7 Linux'
-          - script: |
-              mkdir -p '$(GOBIN)'
-              mkdir -p '$(GOPATH)/pkg'
-              mkdir -p '$(GOROOT)'
-              shopt -s extglob
-              shopt -s dotglob
-              echo '##vso[task.prependpath]$(GOBIN)'
-              echo '##vso[task.prependpath]$(GOROOT)/bin'
-            displayName: 'Set up the Go workspace'
-          - script: |
-              go version
-              go get -v -d ./...
-              cd cmd/wails
-              go install
-            workingDirectory: '$(modulePath)'
-            displayName: 'Get dependencies, then build'
-          - script: |
-              wails version
-            workingDirectory: '$(modulePath)'
-            displayName: 'Check we have output'
-
-  - deployment: Win
-    displayName: Win
-    variables:
-      GOMODULE: 'on'
-      modulePath: '$(Agent.BuildDirectory)/wails' # Path to the module's code
-    pool:
-      vmImage: 'windows-2019'
-    environment: 'win-dev'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - checkout: self  # self represents the repo where the initial Pipelines YAML file was found
-            clean: true  # whether to fetch clean each time
-            path: wails  # path to check out source code, relative to the agent's build directory (e.g. \_work\1)
-          # Go tool installer
-          # Find in cache or download a specific version of Go and add it to the PATH
-          - task: GoTool@0
-            inputs:
-              version: '1.12.7' 
-              goPath: '$(Agent.BuildDirectory)/go'
-              goBin: '$(Agent.BuildDirectory)/go/bin'
-            displayName: 'Set up the Go workspace'
-          - script: |
-              go version
-              go get -v -d ./...
-              cd cmd/wails
-              go install
-            workingDirectory: '$(modulePath)'
-            displayName: 'Get dependencies, then build'
-          - script: |
-              wails version
-            workingDirectory: '$(Agent.BuildDirectory)/go/bin'
-            displayName: 'Check we have output'

cmd/fs.go

@@ -12,6 +12,7 @@ import (
 	"path"
 	"path/filepath"
 	"runtime"
+	"strings"
 
 	"github.com/leaanthony/slicer"
 )
@@ -47,6 +48,22 @@ func (fs *FSHelper) FileExists(path string) bool {
 	return fi.Mode().IsRegular()
 }
 
+// FindFile returns the first occurrence of match inside path.
+func (fs *FSHelper) FindFile(path, match string) (string, error) {
+	files, err := ioutil.ReadDir(path)
+	if err != nil {
+		return "", err
+	}
+
+	for _, f := range files {
+		if !f.IsDir() && strings.Contains(f.Name(), match) {
+			return f.Name(), nil
+		}
+	}
+
+	return "", fmt.Errorf("file not found")
+}
+
 // CreateFile creates a file at the given filename location with the contents
 // set to the given data. It will create intermediary directories if needed.
 func (fs *FSHelper) CreateFile(filename string, data []byte) error {
@@ -100,10 +117,10 @@ func (fs *FSHelper) RemoveFile(filename string) error {
 }
 
 // RemoveFiles removes the given filenames
-func (fs *FSHelper) RemoveFiles(files []string) error {
+func (fs *FSHelper) RemoveFiles(files []string, continueOnError bool) error {
 	for _, filename := range files {
 		err := os.Remove(filename)
-		if err != nil {
+		if err != nil && !continueOnError {
 			return err
 		}
 	}
@@ -132,6 +149,16 @@ func (fs *FSHelper) LocalDir(dir string) (*Dir, error) {
 	}, err
 }
 
+// LoadRelativeFile loads the given file relative to the caller's directory
+func (fs *FSHelper) LoadRelativeFile(relativePath string) ([]byte, error) {
+	_, filename, _, _ := runtime.Caller(0)
+	fullPath, err := filepath.Abs(filepath.Join(path.Dir(filename), relativePath))
+	if err != nil {
+		return nil, err
+	}
+	return ioutil.ReadFile(fullPath)
+}
+
 // GetSubdirs will return a list of FQPs to subdirectories in the given directory
 func (d *Dir) GetSubdirs() (map[string]string, error) {
 

cmd/gomod.go

@@ -0,0 +1,78 @@
+package cmd
+
+import (
+	"fmt"
+	"path/filepath"
+	"regexp"
+
+	"github.com/Masterminds/semver"
+)
+
+func GetWailsVersion() (*semver.Version, error) {
+	var FS = NewFSHelper()
+	var result *semver.Version
+
+	// Load file
+	var err error
+	goModFile, err := filepath.Abs(filepath.Join(".", "go.mod"))
+	if err != nil {
+		return nil, fmt.Errorf("Unable to load go.mod at %s", goModFile)
+	}
+	goMod, err := FS.LoadAsString(goModFile)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to load go.mod")
+	}
+
+	// Find wails version
+	versionRegexp := regexp.MustCompile(`.*github.com/wailsapp/wails.*(v\d+.\d+.\d+(?:-pre\d+)?)`)
+	versions := versionRegexp.FindStringSubmatch(goMod)
+
+	if len(versions) != 2 {
+		return nil, fmt.Errorf("Unable to determine Wails version")
+	}
+
+	version := versions[1]
+	result, err = semver.NewVersion(version)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to parse Wails version: %s", version)
+	}
+	return result, nil
+
+}
+
+func GetCurrentVersion() (*semver.Version, error) {
+	result, err := semver.NewVersion(Version)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to parse Wails version: %s", Version)
+	}
+	return result, nil
+}
+
+func GoModOutOfSync() (bool, error) {
+	gomodversion, err := GetWailsVersion()
+	if err != nil {
+		return true, err
+	}
+	currentVersion, err := GetCurrentVersion()
+	if err != nil {
+		return true, err
+	}
+	result := !currentVersion.Equal(gomodversion)
+	return result, nil
+}
+
+func UpdateGoModVersion() error {
+	currentVersion, err := GetCurrentVersion()
+	if err != nil {
+		return err
+	}
+	currentVersionString := currentVersion.String()
+
+	requireLine := "-require=github.com/wailsapp/wails@v" + currentVersionString
+
+	// Issue: go mod edit -require=github.com/wailsapp/wails@1.0.2-pre5
+	helper := NewProgramHelper()
+	command := []string{"go", "mod", "edit", requireLine}
+	return helper.RunCommandArray(command)
+
+}

cmd/helpers.go

@@ -5,12 +5,15 @@ import (
 	"io/ioutil"
 	"os"
 	"os/exec"
+	"os/user"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/leaanthony/mewn"
+	"github.com/leaanthony/mewn/lib"
 	"github.com/leaanthony/slicer"
 	"github.com/leaanthony/spinner"
 )
@@ -36,34 +39,161 @@ func ValidateFrontendConfig(projectOptions *ProjectOptions) error {
 }
 
 // InstallGoDependencies will run go get in the current directory
-func InstallGoDependencies() error {
+func InstallGoDependencies(verbose bool) error {
-	depSpinner := spinner.New("Ensuring Dependencies are up to date...")
+	var depSpinner *spinner.Spinner
-	depSpinner.SetSpinSpeed(50)
+	if !verbose {
-	depSpinner.Start()
+		depSpinner = spinner.New("Ensuring Dependencies are up to date...")
-	err := NewProgramHelper().RunCommand("go get")
+		depSpinner.SetSpinSpeed(50)
+		depSpinner.Start()
+	}
+	err := NewProgramHelper(verbose).RunCommand("go get")
 	if err != nil {
-		depSpinner.Error()
+		if !verbose {
+			depSpinner.Error()
+		}
 		return err
 	}
-	depSpinner.Success()
+	if !verbose {
+		depSpinner.Success()
+	}
 	return nil
 }
 
-// BuildApplication will attempt to build the project based on the given inputs
+// EmbedAssets will embed the built frontend assets via mewn.
-func BuildApplication(binaryName string, forceRebuild bool, buildMode string, packageApp bool, projectOptions *ProjectOptions) error {
+func EmbedAssets() ([]string, error) {
+	mewnFiles := lib.GetMewnFiles([]string{}, false)
 
-	// Generate Windows assets if needed
+	referencedAssets, err := lib.GetReferencedAssets(mewnFiles)
-	if runtime.GOOS == "windows" {
+	if err != nil {
-		cleanUp := !packageApp
+		return []string{}, err
-		err := NewPackageHelper().PackageWindows(projectOptions, cleanUp)
-		if err != nil {
-			return err
-		}
 	}
 
-	// Check Mewn is installed
+	targetFiles := []string{}
-	err := CheckMewn()
+
+	for _, referencedAsset := range referencedAssets {
+		packfileData, err := lib.GeneratePackFileString(referencedAsset, false)
+		if err != nil {
+			return []string{}, err
+		}
+		targetFile := filepath.Join(referencedAsset.BaseDir, referencedAsset.PackageName+"-mewn.go")
+		targetFiles = append(targetFiles, targetFile)
+		ioutil.WriteFile(targetFile, []byte(packfileData), 0644)
+	}
+
+	return targetFiles, nil
+}
+
+func InitializeCrossCompilation(verbose bool) error {
+	// Check Docker
+	if err := CheckIfInstalled("docker"); err != nil {
+		return err
+	}
+
+	var packSpinner *spinner.Spinner
+	if !verbose {
+		packSpinner = spinner.New("Pulling wailsapp/xgo:latest docker image... (may take a while)")
+		packSpinner.SetSpinSpeed(50)
+		packSpinner.Start()
+	} else {
+		println("Pulling wailsapp/xgo:latest docker image... (may take a while)")
+	}
+
+	err := NewProgramHelper(verbose).RunCommandArray([]string{"docker",
+		"pull", "wailsapp/xgo:latest"})
+
 	if err != nil {
+		if packSpinner != nil {
+			packSpinner.Error()
+		}
+		return err
+	}
+	if packSpinner != nil {
+		packSpinner.Success()
+	}
+
+	return nil
+}
+
+// BuildDocker builds the project using the cross compiling wailsapp/xgo:latest container
+func BuildDocker(binaryName string, buildMode string, projectOptions *ProjectOptions) error {
+	var packSpinner *spinner.Spinner
+	if buildMode == BuildModeBridge {
+		return fmt.Errorf("you cant serve the application in cross-compilation")
+	}
+
+	// Check build directory
+	buildDirectory := filepath.Join(fs.Cwd(), "build")
+	if !fs.DirExists(buildDirectory) {
+		fs.MkDir(buildDirectory)
+	}
+
+	buildCommand := slicer.String()
+	userid := 1000
+	user, _ := user.Current()
+	if i, err := strconv.Atoi(user.Uid); err == nil {
+		userid = i
+	}
+	for _, arg := range []string{
+		"docker",
+		"run",
+		"--rm",
+		"-v", fmt.Sprintf("%s:/build", filepath.Join(fs.Cwd(), "build")),
+		"-v", fmt.Sprintf("%s:/source", fs.Cwd()),
+		"-e", fmt.Sprintf("LOCAL_USER_ID=%v", userid),
+		"-e", fmt.Sprintf("FLAG_LDFLAGS=%s", ldFlags(projectOptions, buildMode)),
+		"-e", "FLAG_V=false",
+		"-e", "FLAG_X=false",
+		"-e", "FLAG_RACE=false",
+		"-e", "FLAG_BUILDMODE=default",
+		"-e", "FLAG_TRIMPATH=false",
+		"-e", fmt.Sprintf("TARGETS=%s", projectOptions.Platform+"/"+projectOptions.Architecture),
+		"-e", "GOPROXY=",
+		"-e", "GO111MODULE=on",
+		"wailsapp/xgo:latest",
+		".",
+	} {
+		buildCommand.Add(arg)
+	}
+
+	compileMessage := fmt.Sprintf(
+		"Packing + Compiling project for %s/%s using docker image wailsapp/xgo:latest",
+		projectOptions.Platform, projectOptions.Architecture)
+
+	if buildMode == BuildModeDebug {
+		compileMessage += " (Debug Mode)"
+	}
+
+	if !projectOptions.Verbose {
+		packSpinner = spinner.New(compileMessage + "...")
+		packSpinner.SetSpinSpeed(50)
+		packSpinner.Start()
+	} else {
+		println(compileMessage)
+	}
+
+	err := NewProgramHelper(projectOptions.Verbose).RunCommandArray(buildCommand.AsSlice())
+	if err != nil {
+		if packSpinner != nil {
+			packSpinner.Error()
+		}
+		return err
+	}
+	if packSpinner != nil {
+		packSpinner.Success()
+	}
+
+	return nil
+}
+
+// BuildNative builds on the target platform itself.
+func BuildNative(binaryName string, forceRebuild bool, buildMode string, projectOptions *ProjectOptions) error {
+
+	// Check Mewn is installed
+	if err := CheckMewn(projectOptions.Verbose); err != nil {
+		return err
+	}
+
+	if err := CheckWindres(); err != nil {
 		return err
 	}
 
@@ -73,23 +203,27 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 		compileMessage += " (Debug Mode)"
 	}
 
-	packSpinner := spinner.New(compileMessage + "...")
+	var packSpinner *spinner.Spinner
-	packSpinner.SetSpinSpeed(50)
+	if !projectOptions.Verbose {
-	packSpinner.Start()
+		packSpinner = spinner.New(compileMessage + "...")
+		packSpinner.SetSpinSpeed(50)
+		packSpinner.Start()
+	} else {
+		println(compileMessage)
+	}
 
 	buildCommand := slicer.String()
-	buildCommand.Add("mewn")
+	buildCommand.Add("go")
 
+	buildCommand.Add("build")
 	if buildMode == BuildModeBridge {
 		// Ignore errors
 		buildCommand.Add("-i")
 	}
 
-	buildCommand.Add("build")
-
 	if binaryName != "" {
 		// Alter binary name based on OS
-		switch runtime.GOOS {
+		switch projectOptions.Platform {
 		case "windows":
 			if !strings.HasSuffix(binaryName, ".exe") {
 				binaryName += ".exe"
@@ -99,8 +233,7 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 				binaryName = strings.TrimSuffix(binaryName, ".exe")
 			}
 		}
-		buildCommand.Add("-o")
+		buildCommand.Add("-o", filepath.Join("build", binaryName))
-		buildCommand.Add(binaryName)
 	}
 
 	// If we are forcing a rebuild
@@ -108,28 +241,74 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 		buildCommand.Add("-a")
 	}
 
-	// Setup ld flags
+	buildCommand.AddSlice([]string{"-ldflags", ldFlags(projectOptions, buildMode)})
-	ldflags := "-w -s "
+
-	if buildMode == BuildModeDebug {
+	if projectOptions.Verbose {
-		ldflags = ""
+		fmt.Printf("Command: %v\n", buildCommand.AsSlice())
 	}
 
-	// Add windows flags
+	err := NewProgramHelper(projectOptions.Verbose).RunCommandArray(buildCommand.AsSlice())
-	if runtime.GOOS == "windows" && buildMode == BuildModeProd {
+	if err != nil {
-		ldflags += "-H windowsgui "
+		if packSpinner != nil {
-	}
+			packSpinner.Error()
-
+		}
-	ldflags += "-X github.com/wailsapp/wails.BuildMode=" + buildMode
+		return err
-
+	}
-	buildCommand.AddSlice([]string{"-ldflags", ldflags})
+	if packSpinner != nil {
-	err = NewProgramHelper().RunCommandArray(buildCommand.AsSlice())
+		packSpinner.Success()
+	}
+
+	return nil
+}
+
+// BuildApplication will attempt to build the project based on the given inputs
+func BuildApplication(binaryName string, forceRebuild bool, buildMode string, packageApp bool, projectOptions *ProjectOptions) error {
+	var err error
+
+	// embed resources
+	targetFiles, err := EmbedAssets()
+	if err != nil {
+		return err
+	}
+
+	if projectOptions.CrossCompile {
+		if err := InitializeCrossCompilation(projectOptions.Verbose); err != nil {
+			return err
+		}
+	}
+
+	helper := NewPackageHelper(projectOptions.Platform)
+
+	// Generate windows resources
+	if projectOptions.Platform == "windows" {
+		if err := helper.PackageWindows(projectOptions, false); err != nil {
+			return err
+		}
+	}
+
+	// cleanup temporary embedded assets
+	defer func() {
+		for _, filename := range targetFiles {
+			if err := os.Remove(filename); err != nil {
+				fmt.Println(err)
+			}
+		}
+		// Removed by popular demand
+		// TODO: Potentially add a flag to cleanup
+		// if projectOptions.Platform == "windows" {
+		// 	helper.CleanWindows(projectOptions)
+		// }
+	}()
+
+	if projectOptions.CrossCompile {
+		err = BuildDocker(binaryName, buildMode, projectOptions)
+	} else {
+		err = BuildNative(binaryName, forceRebuild, buildMode, projectOptions)
+	}
 	if err != nil {
-		packSpinner.Error()
 		return err
 	}
-	packSpinner.Success()
 
-	// packageApp
 	if packageApp {
 		err = PackageApplication(projectOptions)
 		if err != nil {
@@ -142,61 +321,76 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 
 // PackageApplication will attempt to package the application in a platform dependent way
 func PackageApplication(projectOptions *ProjectOptions) error {
-	// Package app
+	var packageSpinner *spinner.Spinner
-	message := "Generating .app"
+	if projectOptions.Verbose {
-	if runtime.GOOS == "windows" {
+		packageSpinner = spinner.New("Packaging application...")
-		err := CheckWindres()
+		packageSpinner.SetSpinSpeed(50)
-		if err != nil {
+		packageSpinner.Start()
-			return err
-		}
-		message = "Generating resource bundle"
 	}
-	packageSpinner := spinner.New(message)
+
-	packageSpinner.SetSpinSpeed(50)
+	err := NewPackageHelper(projectOptions.Platform).Package(projectOptions)
-	packageSpinner.Start()
-	err := NewPackageHelper().Package(projectOptions)
 	if err != nil {
-		packageSpinner.Error()
+		if packageSpinner != nil {
+			packageSpinner.Error()
+		}
 		return err
 	}
-	packageSpinner.Success()
+	if packageSpinner != nil {
+		packageSpinner.Success()
+	}
 	return nil
 }
 
 // BuildFrontend runs the given build command
-func BuildFrontend(buildCommand string) error {
+func BuildFrontend(projectOptions *ProjectOptions) error {
-	buildFESpinner := spinner.New("Building frontend...")
+	var buildFESpinner *spinner.Spinner
-	buildFESpinner.SetSpinSpeed(50)
+	if !projectOptions.Verbose {
-	buildFESpinner.Start()
+		buildFESpinner = spinner.New("Building frontend...")
-	err := NewProgramHelper().RunCommand(buildCommand)
+		buildFESpinner.SetSpinSpeed(50)
+		buildFESpinner.Start()
+	} else {
+		println("Building frontend...")
+	}
+	err := NewProgramHelper(projectOptions.Verbose).RunCommand(projectOptions.FrontEnd.Build)
 	if err != nil {
-		buildFESpinner.Error()
+		if buildFESpinner != nil {
+			buildFESpinner.Error()
+		}
 		return err
 	}
-	buildFESpinner.Success()
+	if buildFESpinner != nil {
+		buildFESpinner.Success()
+	}
 	return nil
 }
 
 // CheckMewn checks if mewn is installed and if not, attempts to fetch it
-func CheckMewn() (err error) {
+func CheckMewn(verbose bool) (err error) {
-	programHelper := NewProgramHelper()
+	programHelper := NewProgramHelper(verbose)
 	if !programHelper.IsInstalled("mewn") {
-		buildSpinner := spinner.New()
+		var buildSpinner *spinner.Spinner
-		buildSpinner.SetSpinSpeed(50)
+		if !verbose {
-		buildSpinner.Start("Installing Mewn asset packer...")
+			buildSpinner = spinner.New()
+			buildSpinner.SetSpinSpeed(50)
+			buildSpinner.Start("Installing Mewn asset packer...")
+		}
 		err := programHelper.InstallGoPackage("github.com/leaanthony/mewn/cmd/mewn")
 		if err != nil {
-			buildSpinner.Error()
+			if buildSpinner != nil {
+				buildSpinner.Error()
+			}
 			return err
 		}
-		buildSpinner.Success()
+		if buildSpinner != nil {
+			buildSpinner.Success()
+		}
 	}
 	return nil
 }
 
 // CheckWindres checks if Windres is installed and if not, aborts
 func CheckWindres() (err error) {
-	if runtime.GOOS != "windows" {
+	if runtime.GOOS != "windows" { // FIXME: Handle windows cross-compile for windows!
 		return nil
 	}
 	programHelper := NewProgramHelper()
@@ -206,6 +400,15 @@ func CheckWindres() (err error) {
 	return nil
 }
 
+// CheckIfInstalled returns if application is installed
+func CheckIfInstalled(application string) (err error) {
+	programHelper := NewProgramHelper()
+	if !programHelper.IsInstalled(application) {
+		return fmt.Errorf("%s not installed. Ensure you have installed %s correctly", application, application)
+	}
+	return nil
+}
+
 // InstallFrontendDeps attempts to install the frontend dependencies based on the given options
 func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forceRebuild bool, caller string) error {
 
@@ -216,9 +419,14 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
 	}
 
 	// Check if frontend deps have been updated
-	feSpinner := spinner.New("Ensuring frontend dependencies are up to date (This may take a while)")
+	var feSpinner *spinner.Spinner
-	feSpinner.SetSpinSpeed(50)
+	if !projectOptions.Verbose {
-	feSpinner.Start()
+		feSpinner = spinner.New("Ensuring frontend dependencies are up to date (This may take a while)")
+		feSpinner.SetSpinSpeed(50)
+		feSpinner.Start()
+	} else {
+		println("Ensuring frontend dependencies are up to date (This may take a while)")
+	}
 
 	requiresNPMInstall := true
 
@@ -250,7 +458,11 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
 			if savedMD5sum == packageJSONMD5 {
 				// Same - no need for reinstall
 				requiresNPMInstall = false
-				feSpinner.Success("Skipped frontend dependencies (-f to force rebuild)")
+				if feSpinner != nil {
+					feSpinner.Success("Skipped frontend dependencies (-f to force rebuild)")
+				} else {
+					println("Skipped frontend dependencies (-f to force rebuild)")
+				}
 			}
 		}
 	}
@@ -259,12 +471,16 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
 	// Different? Build
 	if requiresNPMInstall || forceRebuild {
 		// Install dependencies
-		err = NewProgramHelper().RunCommand(projectOptions.FrontEnd.Install)
+		err = NewProgramHelper(projectOptions.Verbose).RunCommand(projectOptions.FrontEnd.Install)
 		if err != nil {
-			feSpinner.Error()
+			if feSpinner != nil {
+				feSpinner.Error()
+			}
 			return err
 		}
-		feSpinner.Success()
+		if feSpinner != nil {
+			feSpinner.Success()
+		}
 
 		// Update md5sum file
 		ioutil.WriteFile(md5sumFile, []byte(packageJSONMD5), 0644)
@@ -277,7 +493,7 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
 	}
 
 	// Build frontend
-	err = BuildFrontend(projectOptions.FrontEnd.Build)
+	err = BuildFrontend(projectOptions)
 	if err != nil {
 		return err
 	}
@@ -316,7 +532,7 @@ func ServeProject(projectOptions *ProjectOptions, logger *Logger) error {
 		time.Sleep(2 * time.Second)
 		logger.Green(">>>>> To connect, you will need to run '" + projectOptions.FrontEnd.Serve + "' in the '" + projectOptions.FrontEnd.Dir + "' directory <<<<<")
 	}()
-	location, err := filepath.Abs(projectOptions.BinaryName)
+	location, err := filepath.Abs(filepath.Join("build", projectOptions.BinaryName))
 	if err != nil {
 		return err
 	}
@@ -332,3 +548,33 @@ func ServeProject(projectOptions *ProjectOptions, logger *Logger) error {
 
 	return nil
 }
+
+func ldFlags(po *ProjectOptions, buildMode string) string {
+	// Setup ld flags
+	ldflags := "-w -s "
+	if buildMode == BuildModeDebug {
+		ldflags = ""
+	}
+
+	// Add windows flags
+	if po.Platform == "windows" && buildMode == BuildModeProd {
+		ldflags += "-H windowsgui "
+	}
+
+	ldflags += "-X github.com/wailsapp/wails.BuildMode=" + buildMode
+
+	// Add additional ldflags passed in via the `ldflags` cli flag
+	if len(po.LdFlags) > 0 {
+		ldflags += " " + po.LdFlags
+	}
+
+	// If we wish to generate typescript
+	if po.typescriptDefsFilename != "" {
+		cwd, err := os.Getwd()
+		if err == nil {
+			filename := filepath.Join(cwd, po.FrontEnd.Dir, po.typescriptDefsFilename)
+			ldflags += " -X github.com/wailsapp/wails/lib/binding.typescriptDefinitionFilename=" + filename
+		}
+	}
+	return ldflags
+}

cmd/linux.go

@@ -43,8 +43,28 @@ const (
 	Kali
 	// Neon distribution
 	Neon
+	// ArcoLinux distribution
+	ArcoLinux
 	// Manjaro distribution
 	Manjaro
+	// ManjaroARM distribution
+	ManjaroARM
+	// Deepin distribution
+	Deepin
+	// Raspbian distribution
+	Raspbian
+	// Tumbleweed (OpenSUSE) distribution
+	Tumbleweed
+	// Leap (OpenSUSE) distribution
+	Leap
+	// ArchLabs distribution
+	ArchLabs
+	// PopOS distribution
+	PopOS
+	// Solus distribution
+	Solus
+	// Ctlos Linux distribution
+	Ctlos
 )
 
 // DistroInfo contains all the information relating to a linux distribution
@@ -93,13 +113,14 @@ func parseOsRelease(osRelease string) *DistroInfo {
 		}
 		switch splitLine[0] {
 		case "ID":
-			osID = strings.Trim(splitLine[1], "\"")
+			osID = strings.ToLower(strings.Trim(splitLine[1], "\""))
 		case "NAME":
 			osNAME = strings.Trim(splitLine[1], "\"")
 		case "VERSION_ID":
 			version = strings.Trim(splitLine[1], "\"")
 		}
 	}
+
 	// Check distro name against list of distros
 	switch osID {
 	case "fedora":
@@ -108,6 +129,10 @@ func parseOsRelease(osRelease string) *DistroInfo {
 		result.Distribution = CentOS
 	case "arch":
 		result.Distribution = Arch
+	case "archlabs":
+		result.Distribution = ArchLabs
+	case "ctlos":
+		result.Distribution = Ctlos	
 	case "debian":
 		result.Distribution = Debian
 	case "ubuntu":
@@ -128,8 +153,24 @@ func parseOsRelease(osRelease string) *DistroInfo {
 		result.Distribution = Kali
 	case "neon":
 		result.Distribution = Neon
+	case "arcolinux":
+		result.Distribution = ArcoLinux
 	case "manjaro":
 		result.Distribution = Manjaro
+	case "manjaro-arm":
+		result.Distribution = ManjaroARM
+	case "deepin":
+		result.Distribution = Deepin
+	case "raspbian":
+		result.Distribution = Raspbian
+	case "opensuse-tumbleweed":
+		result.Distribution = Tumbleweed
+	case "opensuse-leap":
+		result.Distribution = Leap
+	case "pop":
+		result.Distribution = PopOS
+	case "solus":
+		result.Distribution = Solus
 	default:
 		result.Distribution = Unknown
 	}
@@ -166,6 +207,17 @@ func DpkgInstalled(packageName string) (bool, error) {
 	return exitCode == 0, nil
 }
 
+// EOpkgInstalled uses dpkg to see if a package is installed
+func EOpkgInstalled(packageName string) (bool, error) {
+	program := NewProgramHelper()
+	eopkg := program.FindProgram("eopkg")
+	if eopkg == nil {
+		return false, fmt.Errorf("cannot check dependencies: eopkg not found")
+	}
+	stdout, _, _, _ := eopkg.Run("info", packageName)
+	return strings.HasPrefix(stdout, "Installed"), nil
+}
+
 // PacmanInstalled uses pacman to see if a package is installed.
 func PacmanInstalled(packageName string) (bool, error) {
 	program := NewProgramHelper()
@@ -237,5 +289,9 @@ func RequestSupportForDistribution(distroInfo *DistroInfo) error {
 
 	fmt.Println("Opening browser to file request.")
 	browser.OpenURL(fullURL + url.PathEscape(params))
+	result = Prompt("We have a guide for adding support for your distribution. Would you like to view it?", "yes")
+	if strings.ToLower(result) == "yes" {
+		browser.OpenURL("https://wails.app/guides/distro/")
+	}
 	return nil
 }

cmd/linux_test.go

@@ -22,5 +22,25 @@ UBUNTU_CODENAME=bionic
 	if result.Distribution != Ubuntu {
 		t.Errorf("expected 'Ubuntu' ID but got '%d'", result.Distribution)
 	}
-
+}
+
+func TestTumbleweedDetection(t *testing.T) {
+	osrelease := `
+NAME="openSUSE Tumbleweed"
+# VERSION="20200414"
+ID="opensuse-tumbleweed"
+ID_LIKE="opensuse suse"
+VERSION_ID="20200414"
+PRETTY_NAME="openSUSE Tumbleweed"
+ANSI_COLOR="0;32"
+CPE_NAME="cpe:/o:opensuse:tumbleweed:20200414"
+BUG_REPORT_URL="https://bugs.opensuse.org"
+HOME_URL="https://www.opensuse.org/"
+LOGO="distributor-logo"
+`
+
+	result := parseOsRelease(osrelease)
+	if result.Distribution != Tumbleweed {
+		t.Errorf("expected 'Tumbleweed' ID but got '%d'", result.Distribution)
+	}
 }

cmd/linuxdb.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"log"
 
-	"github.com/leaanthony/mewn"
 	"gopkg.in/yaml.v3"
 )
 
@@ -79,11 +78,14 @@ func (l *LinuxDB) GetDistro(distro string) *Distribution {
 // NewLinuxDB creates a new LinuxDB instance from the bundled
 // linuxdb.yaml file.
 func NewLinuxDB() *LinuxDB {
-	data := mewn.Bytes("./linuxdb.yaml")
+	data, err := fs.LoadRelativeFile("./linuxdb.yaml")
+	if err != nil {
+		log.Fatal("Could not load linuxdb.yaml")
+	}
 	result := LinuxDB{
 		Distributions: make(map[string]*Distribution),
 	}
-	err := result.ImportData(data)
+	err = result.ImportData(data)
 	if err != nil {
 		log.Fatal(err)
 	}

cmd/linuxdb.yaml

@@ -28,6 +28,15 @@ distributions:
         gccversioncommand: &gccdumpfullversion -dumpfullversion
         programs: *debiandefaultprograms
         libraries: *debiandefaultlibraries
+  pop:
+    id: pop
+    releases:
+      default:
+        version: default
+        name: Pop!_OS
+        gccversioncommand: &gccdumpfullversion -dumpfullversion
+        programs: *debiandefaultprograms
+        libraries: *debiandefaultlibraries
   kali:
     id: kali
     releases:
@@ -82,6 +91,15 @@ distributions:
         gccversioncommand: *gccdumpfullversion
         programs: *debiandefaultprograms
         libraries: *debiandefaultlibraries
+  deepin:
+    id: deepin
+    releases:
+      default:
+        version: default
+        name: Deepin
+        gccversioncommand: *gccdumpfullversion
+        programs: *debiandefaultprograms
+        libraries: *debiandefaultlibraries
   void:
     id: void
     releases:
@@ -158,6 +176,33 @@ distributions:
             help: Please install with `sudo pacman -S gtk3` and try again
           - name: webkit2gtk
             help: Please install with `sudo pacman -S webkit2gtk` and try again
+  arcolinux:
+    id: arcolinux
+    releases:
+      default:
+        version: default
+        name: ArcoLinux
+        gccversioncommand: *gccdumpversion
+        programs: *archdefaultprograms
+        libraries: *archdefaultlibraries
+  archlabs:
+    id: archlabs
+    releases:
+      default:
+        version: default
+        name: ArchLabs
+        gccversioncommand: *gccdumpversion
+        programs: *archdefaultprograms
+        libraries: *archdefaultlibraries
+  ctlos:
+    id: ctlos
+    releases:
+      default:
+        version: default
+        name: Ctlos Linux
+        gccversioncommand: *gccdumpversion
+        programs: *archdefaultprograms
+        libraries: *archdefaultlibraries                
   manjaro:
     id: manjaro
     releases:
@@ -167,6 +212,15 @@ distributions:
         gccversioncommand: *gccdumpversion
         programs: *archdefaultprograms
         libraries: *archdefaultlibraries
+  manjaro-arm:
+    id: manjaro-arm
+    releases:
+      default:
+        version: default
+        name: Manjaro-ARM
+        gccversioncommand: *gccdumpversion
+        programs: *archdefaultprograms
+        libraries: *archdefaultlibraries
   gentoo:
     id: gentoo
     releases:
@@ -185,4 +239,62 @@ distributions:
           - name: gtk+:3
             help: Please install with `sudo emerge gtk+:3` and try again
           - name: webkit-gtk
-            help: Please install with `sudo emerge webkit-gtk` and try again
+            help: Please install with `sudo emerge webkit-gtk` and try again
+
+  raspbian:
+    id: raspbian
+    releases:
+      default:
+        version: default
+        name: Raspbian
+        gccversioncommand: *gccdumpfullversion
+        programs: *debiandefaultprograms
+        libraries: *debiandefaultlibraries
+  solus:
+    id: solus
+    releases:
+      default:
+        version: default
+        name: Solus
+        gccversioncommand: *gccdumpfullversion
+        programs: &solusdefaultprograms
+          - name: gcc
+            help: Please install with `sudo eopkg it -c system.devel` and try again
+          - name: pkg-config
+            help: Please install with `sudo eopkg it -c system.devel` and try again
+          - name: npm
+            help: Please install with `sudo eopkg it nodejs` and try again
+        libraries: &solusdefaultlibraries
+          - name: libgtk-3-devel
+            help: Please install with `sudo eopkg it libgtk-3-devel` and try again
+          - name: libwebkit-gtk-devel
+            help: Please install with `sudo eopkg it libwebkit-gtk-devel` and try again
+        
+  opensuse-tumbleweed:
+    id: opensuse-tumbleweed
+    releases:
+      default:
+        version: default
+        name: openSUSE Tumbleweed
+        gccversioncommand: *gccdumpfullversion
+        programs: &opensusedefaultprograms
+          - name: gcc
+            help: Please install with `sudo zypper in gcc-c++` and try again
+          - name: pkg-config
+            help: Please install with `sudo zypper in pkgconf-pkg-config` and try again
+          - name: npm
+            help: Please install `sudo zypper in nodejs` and try again
+        libraries: &opensusedefaultlibraries
+          - name: gtk3-devel
+            help: Please install with `sudo zypper in gtk3-devel` and try again
+          - name: webkit2gtk3-devel
+            help: Please install with `sudo zypper in webkit2gtk3-devel` and try again
+  opensuse-leap:
+      id: opensuse-leap
+      releases:
+        default:
+          version: default
+          name: openSUSE Leap
+          gccversioncommand: *gccdumpfullversion
+          programs: *opensusedefaultprograms
+          libraries: *opensusedefaultlibraries

cmd/package.go

@@ -1,9 +1,12 @@
 package cmd
 
 import (
+	"bufio"
 	"bytes"
+	"encoding/binary"
 	"fmt"
 	"image"
+	"image/png"
 	"io/ioutil"
 	"os"
 	"path"
@@ -14,21 +17,24 @@ import (
 	"time"
 
 	"github.com/jackmordaunt/icns"
+	"golang.org/x/image/draw"
 )
 
 // PackageHelper helps with the 'wails package' command
 type PackageHelper struct {
-	fs     *FSHelper
+	platform string
-	log    *Logger
+	fs       *FSHelper
-	system *SystemHelper
+	log      *Logger
+	system   *SystemHelper
 }
 
 // NewPackageHelper creates a new PackageHelper!
-func NewPackageHelper() *PackageHelper {
+func NewPackageHelper(platform string) *PackageHelper {
 	return &PackageHelper{
-		fs:     NewFSHelper(),
+		platform: platform,
-		log:    NewLogger(),
+		fs:       NewFSHelper(),
-		system: NewSystemHelper(),
+		log:      NewLogger(),
+		system:   NewSystemHelper(),
 	}
 }
 
@@ -53,6 +59,111 @@ func newPlistData(title, exe, packageID, version, author string) *plistData {
 	}
 }
 
+type windowsIcoHeader struct {
+	_          uint16
+	imageType  uint16
+	imageCount uint16
+}
+
+type windowsIcoDescriptor struct {
+	width   uint8
+	height  uint8
+	colours uint8
+	_       uint8
+	planes  uint16
+	bpp     uint16
+	size    uint32
+	offset  uint32
+}
+
+type windowsIcoContainer struct {
+	Header windowsIcoDescriptor
+	Data   []byte
+}
+
+func generateWindowsIcon(pngFilename string, iconfile string) error {
+	sizes := []int{256, 128, 64, 48, 32, 16}
+
+	pngfile, err := os.Open(pngFilename)
+	if err != nil {
+		return err
+	}
+	defer pngfile.Close()
+
+	pngdata, err := png.Decode(pngfile)
+	if err != nil {
+		return err
+	}
+
+	icons := []windowsIcoContainer{}
+
+	for _, size := range sizes {
+		rect := image.Rect(0, 0, int(size), int(size))
+		rawdata := image.NewRGBA(rect)
+		scale := draw.CatmullRom
+		scale.Scale(rawdata, rect, pngdata, pngdata.Bounds(), draw.Over, nil)
+
+		icondata := new(bytes.Buffer)
+		writer := bufio.NewWriter(icondata)
+		err = png.Encode(writer, rawdata)
+		if err != nil {
+			return err
+		}
+		writer.Flush()
+
+		imgSize := size
+		if imgSize >= 256 {
+			imgSize = 0
+		}
+
+		data := icondata.Bytes()
+
+		icn := windowsIcoContainer{
+			Header: windowsIcoDescriptor{
+				width:  uint8(imgSize),
+				height: uint8(imgSize),
+				planes: 1,
+				bpp:    32,
+				size:   uint32(len(data)),
+			},
+			Data: data,
+		}
+		icons = append(icons, icn)
+	}
+
+	outfile, err := os.Create(iconfile)
+	if err != nil {
+		return err
+	}
+	defer outfile.Close()
+
+	ico := windowsIcoHeader{
+		imageType:  1,
+		imageCount: uint16(len(sizes)),
+	}
+	err = binary.Write(outfile, binary.LittleEndian, ico)
+	if err != nil {
+		return err
+	}
+
+	offset := uint32(6 + 16*len(sizes))
+	for _, icon := range icons {
+		icon.Header.offset = offset
+		err = binary.Write(outfile, binary.LittleEndian, icon.Header)
+		if err != nil {
+			return err
+		}
+		offset += icon.Header.size
+	}
+	for _, icon := range icons {
+		_, err = outfile.Write(icon.Data)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func defaultString(val string, defaultVal string) string {
 	if val != "" {
 		return val
@@ -63,29 +174,30 @@ func defaultString(val string, defaultVal string) string {
 func (b *PackageHelper) getPackageFileBaseDir() string {
 	// Calculate template base dir
 	_, filename, _, _ := runtime.Caller(1)
-	return filepath.Join(path.Dir(filename), "packages", runtime.GOOS)
+	return filepath.Join(path.Dir(filename), "packages", b.platform)
 }
 
 // Package the application into a platform specific package
 func (b *PackageHelper) Package(po *ProjectOptions) error {
-	switch runtime.GOOS {
+	switch b.platform {
 	case "darwin":
-		// Check we have the exe
-		if !b.fs.FileExists(po.BinaryName) {
-			return fmt.Errorf("cannot bundle non-existent binary file '%s'. Please build with 'wails build' first", po.BinaryName)
-		}
 		return b.packageOSX(po)
 	case "windows":
-		return b.PackageWindows(po, false)
+		return b.PackageWindows(po, true)
 	case "linux":
-		return fmt.Errorf("linux is not supported at this time. Please see https://github.com/wailsapp/wails/issues/2")
+		return b.packageLinux(po)
 	default:
-		return fmt.Errorf("platform '%s' not supported for bundling yet", runtime.GOOS)
+		return fmt.Errorf("platform '%s' not supported for bundling yet", b.platform)
 	}
 }
 
+func (b *PackageHelper) packageLinux(po *ProjectOptions) error {
+	return nil
+}
+
 // Package the application for OSX
 func (b *PackageHelper) packageOSX(po *ProjectOptions) error {
+	build := path.Join(b.fs.Cwd(), "build")
 
 	system := NewSystemHelper()
 	config, err := system.LoadConfig()
@@ -100,39 +212,68 @@ func (b *PackageHelper) packageOSX(po *ProjectOptions) error {
 	packageID := strings.Join([]string{"wails", name, version}, ".")
 	plistData := newPlistData(name, exe, packageID, version, author)
 	appname := po.Name + ".app"
+	plistFilename := path.Join(build, appname, "Contents", "Info.plist")
+	customPlist := path.Join(b.fs.Cwd(), "info.plist")
 
 	// Check binary exists
-	source := path.Join(b.fs.Cwd(), exe)
+	source := path.Join(build, exe)
-	if !b.fs.FileExists(source) {
+	if po.CrossCompile == true {
-		// We need to build!
+		file, err := b.fs.FindFile(build, "darwin")
-		return fmt.Errorf("Target '%s' not available. Has it been compiled yet?", exe)
+		if err != nil {
+			return err
+		}
+		source = path.Join(build, file)
 	}
 
+	if !b.fs.FileExists(source) {
+		// We need to build!
+		return fmt.Errorf("Target '%s' not available. Has it been compiled yet?", source)
+	}
 	// Remove the existing package
 	os.RemoveAll(appname)
 
-	exeDir := path.Join(b.fs.Cwd(), appname, "/Contents/MacOS")
+	// Create directories
+	exeDir := path.Join(build, appname, "/Contents/MacOS")
 	b.fs.MkDirs(exeDir, 0755)
-	resourceDir := path.Join(b.fs.Cwd(), appname, "/Contents/Resources")
+	resourceDir := path.Join(build, appname, "/Contents/Resources")
 	b.fs.MkDirs(resourceDir, 0755)
-	tmpl := template.New("infoPlist")
-	plistFile := filepath.Join(b.getPackageFileBaseDir(), "info.plist")
-	infoPlist, err := ioutil.ReadFile(plistFile)
-	if err != nil {
-		return err
-	}
-	tmpl.Parse(string(infoPlist))
 
-	// Write the template to a buffer
+	// Do we have a custom plist in the project directory?
-	var tpl bytes.Buffer
+	if !fs.FileExists(customPlist) {
-	err = tmpl.Execute(&tpl, plistData)
+
-	if err != nil {
+		// No - create a new plist from our defaults
-		return err
+		tmpl := template.New("infoPlist")
-	}
+		plistFile := filepath.Join(b.getPackageFileBaseDir(), "info.plist")
-	filename := path.Join(b.fs.Cwd(), appname, "Contents", "Info.plist")
+		infoPlist, err := ioutil.ReadFile(plistFile)
-	err = ioutil.WriteFile(filename, tpl.Bytes(), 0644)
+		if err != nil {
-	if err != nil {
+			return err
-		return err
+		}
+		tmpl.Parse(string(infoPlist))
+
+		// Write the template to a buffer
+		var tpl bytes.Buffer
+		err = tmpl.Execute(&tpl, plistData)
+		if err != nil {
+			return err
+		}
+
+		// Save to the package
+		err = ioutil.WriteFile(plistFilename, tpl.Bytes(), 0644)
+		if err != nil {
+			return err
+		}
+
+		// Also write to project directory for customisation
+		err = ioutil.WriteFile(customPlist, tpl.Bytes(), 0644)
+		if err != nil {
+			return err
+		}
+	} else {
+		// Yes - we have a plist. Copy it to the package verbatim
+		err = fs.CopyFile(customPlist, plistFilename)
+		if err != nil {
+			return err
+		}
 	}
 
 	// Copy executable
@@ -150,22 +291,37 @@ func (b *PackageHelper) packageOSX(po *ProjectOptions) error {
 	return err
 }
 
+// CleanWindows removes any windows related files found in the directory
+func (b *PackageHelper) CleanWindows(po *ProjectOptions) {
+	pdir := b.fs.Cwd()
+	basename := strings.TrimSuffix(po.BinaryName, ".exe")
+	exts := []string{".ico", ".exe.manifest", ".rc", "-res.syso"}
+	rsrcs := []string{}
+	for _, ext := range exts {
+		rsrcs = append(rsrcs, filepath.Join(pdir, basename+ext))
+	}
+	b.fs.RemoveFiles(rsrcs, true)
+}
+
 // PackageWindows packages the application for windows platforms
 func (b *PackageHelper) PackageWindows(po *ProjectOptions, cleanUp bool) error {
+	outputDir := b.fs.Cwd()
 	basename := strings.TrimSuffix(po.BinaryName, ".exe")
 
-	// Copy icon
+	// Copy default icon if needed
-	tgtIconFile := filepath.Join(b.fs.Cwd(), basename+".ico")
+	icon, err := b.copyIcon()
-	if !b.fs.FileExists(tgtIconFile) {
+	if err != nil {
-		srcIconfile := filepath.Join(b.getPackageFileBaseDir(), "wails.ico")
+		return err
-		err := b.fs.CopyFile(srcIconfile, tgtIconFile)
+	}
-		if err != nil {
+
-			return err
+	// Generate icon from PNG
-		}
+	err = generateWindowsIcon(icon, basename+".ico")
+	if err != nil {
+		return err
 	}
 
 	// Copy manifest
-	tgtManifestFile := filepath.Join(b.fs.Cwd(), basename+".exe.manifest")
+	tgtManifestFile := filepath.Join(outputDir, basename+".exe.manifest")
 	if !b.fs.FileExists(tgtManifestFile) {
 		srcManifestfile := filepath.Join(b.getPackageFileBaseDir(), "wails.exe.manifest")
 		err := b.fs.CopyFile(srcManifestfile, tgtManifestFile)
@@ -175,7 +331,7 @@ func (b *PackageHelper) PackageWindows(po *ProjectOptions, cleanUp bool) error {
 	}
 
 	// Copy rc file
-	tgtRCFile := filepath.Join(b.fs.Cwd(), basename+".rc")
+	tgtRCFile := filepath.Join(outputDir, basename+".rc")
 	if !b.fs.FileExists(tgtRCFile) {
 		srcRCfile := filepath.Join(b.getPackageFileBaseDir(), "wails.rc")
 		rcfilebytes, err := ioutil.ReadFile(srcRCfile)
@@ -190,33 +346,37 @@ func (b *PackageHelper) PackageWindows(po *ProjectOptions, cleanUp bool) error {
 	}
 
 	// Build syso
-	sysofile := filepath.Join(b.fs.Cwd(), basename+"-res.syso")
+	sysofile := filepath.Join(outputDir, basename+"-res.syso")
 
-	batfile, err := fs.LocalDir(".")
+	// cross-compile
-	if err != nil {
+	if b.platform != runtime.GOOS {
-		return err
+		args := []string{
-	}
+			"docker", "run", "--rm",
+			"-v", outputDir + ":/build",
+			"--entrypoint", "/bin/sh",
+			"wailsapp/xgo:latest",
+			"-c", "/usr/bin/x86_64-w64-mingw32-windres -o /build/" + basename + "-res.syso /build/" + basename + ".rc",
+		}
+		if err := NewProgramHelper().RunCommandArray(args); err != nil {
+			return err
+		}
+	} else {
+		batfile, err := fs.LocalDir(".")
+		if err != nil {
+			return err
+		}
 
-	windresBatFile := filepath.Join(batfile.fullPath, "windres.bat")
+		windresBatFile := filepath.Join(batfile.fullPath, "windres.bat")
-	windresCommand := []string{windresBatFile, sysofile, tgtRCFile}
+		windresCommand := []string{windresBatFile, sysofile, tgtRCFile}
-	err = NewProgramHelper().RunCommandArray(windresCommand)
+		err = NewProgramHelper().RunCommandArray(windresCommand)
-	if err != nil {
-		return err
-	}
-
-	// clean up
-	if cleanUp {
-		filesToDelete := []string{tgtIconFile, tgtManifestFile, tgtRCFile, sysofile}
-		err := b.fs.RemoveFiles(filesToDelete)
 		if err != nil {
 			return err
 		}
 	}
-
 	return nil
 }
 
-func (b *PackageHelper) copyIcon(resourceDir string) (string, error) {
+func (b *PackageHelper) copyIcon() (string, error) {
 
 	// TODO: Read this from project.json
 	const appIconFilename = "appicon.png"
@@ -241,7 +401,7 @@ func (b *PackageHelper) copyIcon(resourceDir string) (string, error) {
 
 func (b *PackageHelper) packageIconOSX(resourceDir string) error {
 
-	srcIcon, err := b.copyIcon(resourceDir)
+	srcIcon, err := b.copyIcon()
 	if err != nil {
 		return err
 	}

cmd/packages/darwin/info.plist

@@ -1,5 +1,6 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>
+	<key>CFBundlePackageType</key><string>APPL</string>
 	<key>CFBundleName</key><string>{{.Title}}</string>
 	<key>CFBundleExecutable</key><string>{{.Exe}}</string>
 	<key>CFBundleIdentifier</key><string>{{.PackageID}}</string>

cmd/packages/windows/wails.rc

@@ -1,2 +1,2 @@
 100 ICON    "$NAME$.ico"
-100 24      "$NAME$.exe.manifest"
+110 24      "$NAME$.exe.manifest"

cmd/program.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
@@ -11,14 +12,22 @@ import (
 
 // ProgramHelper - Utility functions around installed applications
 type ProgramHelper struct {
-	shell *ShellHelper
+	shell   *ShellHelper
+	verbose bool
 }
 
 // NewProgramHelper - Creates a new ProgramHelper
-func NewProgramHelper() *ProgramHelper {
+func NewProgramHelper(verbose ...bool) *ProgramHelper {
-	return &ProgramHelper{
+	result := &ProgramHelper{
 		shell: NewShellHelper(),
 	}
+	if len(verbose) > 0 {
+		result.verbose = verbose[0]
+		if result.verbose {
+			result.shell.SetVerbose()
+		}
+	}
+	return result
 }
 
 // IsInstalled tries to determine if the given binary name is installed
@@ -29,8 +38,9 @@ func (p *ProgramHelper) IsInstalled(programName string) bool {
 
 // Program - A struct to define an installed application/binary
 type Program struct {
-	Name string `json:"name"`
+	Name    string `json:"name"`
-	Path string `json:"path"`
+	Path    string `json:"path"`
+	verbose bool
 }
 
 // FindProgram attempts to find the given program on the system.FindProgram
@@ -45,8 +55,9 @@ func (p *ProgramHelper) FindProgram(programName string) *Program {
 		return nil
 	}
 	return &Program{
-		Name: programName,
+		Name:    programName,
-		Path: path,
+		Path:    path,
+		verbose: p.verbose,
 	}
 }
 
@@ -63,12 +74,18 @@ func (p *Program) Run(vars ...string) (stdout, stderr string, exitCode int, err
 		return "", "", 1, err
 	}
 	cmd := exec.Command(command, vars...)
-	var stdo, stde bytes.Buffer
+	if !p.verbose {
-	cmd.Stdout = &stdo
+		var stdo, stde bytes.Buffer
-	cmd.Stderr = &stde
+		cmd.Stdout = &stdo
-	err = cmd.Run()
+		cmd.Stderr = &stde
-	stdout = string(stdo.Bytes())
+		err = cmd.Run()
-	stderr = string(stde.Bytes())
+		stdout = string(stdo.Bytes())
+		stderr = string(stde.Bytes())
+	} else {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err = cmd.Run()
+	}
 
 	// https://stackoverflow.com/questions/10385551/get-exit-code-go
 	if err != nil {
@@ -121,11 +138,11 @@ func (p *ProgramHelper) RunCommand(command string) error {
 
 // RunCommandArray runs the command specified in the array
 func (p *ProgramHelper) RunCommandArray(args []string, dir ...string) error {
-	program := args[0]
+	programCommand := args[0]
 	// TODO: Run FindProgram here and get the full path to the exe
-	program, err := exec.LookPath(program)
+	program, err := exec.LookPath(programCommand)
 	if err != nil {
-		fmt.Printf("ERROR: Looks like '%s' isn't installed. Please install and try again.", program)
+		fmt.Printf("ERROR: Looks like '%s' isn't installed. Please install and try again.", programCommand)
 		return err
 	}
 

cmd/project.go

@@ -6,7 +6,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"runtime"
 	"sort"
 	"strings"
 
@@ -142,21 +141,27 @@ func (ph *ProjectHelper) NewProjectOptions() *ProjectOptions {
 
 // ProjectOptions holds all the options available for a project
 type ProjectOptions struct {
-	Name             string    `json:"name"`
+	Name                   string    `json:"name"`
-	Description      string    `json:"description"`
+	Description            string    `json:"description"`
-	Author           *author   `json:"author,omitempty"`
+	Author                 *author   `json:"author,omitempty"`
-	Version          string    `json:"version"`
+	Version                string    `json:"version"`
-	OutputDirectory  string    `json:"-"`
+	OutputDirectory        string    `json:"-"`
-	UseDefaults      bool      `json:"-"`
+	UseDefaults            bool      `json:"-"`
-	Template         string    `json:"-"`
+	Template               string    `json:"-"`
-	BinaryName       string    `json:"binaryname"`
+	BinaryName             string    `json:"binaryname"`
-	FrontEnd         *frontend `json:"frontend,omitempty"`
+	FrontEnd               *frontend `json:"frontend,omitempty"`
-	NPMProjectName   string    `json:"-"`
+	NPMProjectName         string    `json:"-"`
-	system           *SystemHelper
+	system                 *SystemHelper
-	log              *Logger
+	log                    *Logger
-	templates        *TemplateHelper
+	templates              *TemplateHelper
-	selectedTemplate *TemplateDetails
+	selectedTemplate       *TemplateDetails
-	WailsVersion     string
+	WailsVersion           string
+	typescriptDefsFilename string
+	Verbose                bool `json:"-"`
+	CrossCompile           bool
+	Platform               string
+	Architecture           string
+	LdFlags                string
 }
 
 // Defaults sets the default project template
@@ -165,6 +170,11 @@ func (po *ProjectOptions) Defaults() {
 	po.WailsVersion = Version
 }
 
+// SetTypescriptDefsFilename indicates that we want to generate typescript bindings to the given file
+func (po *ProjectOptions) SetTypescriptDefsFilename(filename string) {
+	po.typescriptDefsFilename = filename
+}
+
 // GetNPMBinaryName returns the type of package manager used by the project
 func (po *ProjectOptions) GetNPMBinaryName() (PackageManager, error) {
 	if po.FrontEnd == nil {
@@ -326,11 +336,6 @@ func processBinaryName(po *ProjectOptions) {
 	if po.BinaryName == "" {
 		var binaryNameComputed = computeBinaryName(po.Name)
 		po.BinaryName = Prompt("The output binary name", binaryNameComputed)
-		if runtime.GOOS == "windows" {
-			if !strings.HasSuffix(po.BinaryName, ".exe") {
-				po.BinaryName += ".exe"
-			}
-		}
 	}
 	fmt.Println("Output binary Name: " + po.BinaryName)
 }

cmd/shell.go

@@ -8,6 +8,7 @@ import (
 
 // ShellHelper helps with Shell commands
 type ShellHelper struct {
+	verbose bool
 }
 
 // NewShellHelper creates a new ShellHelper!
@@ -15,16 +16,27 @@ func NewShellHelper() *ShellHelper {
 	return &ShellHelper{}
 }
 
+// SetVerbose sets the verbose flag
+func (sh *ShellHelper) SetVerbose() {
+	sh.verbose = true
+}
+
 // Run the given command
 func (sh *ShellHelper) Run(command string, vars ...string) (stdout, stderr string, err error) {
 	cmd := exec.Command(command, vars...)
 	cmd.Env = append(os.Environ(), "GO111MODULE=on")
-	var stdo, stde bytes.Buffer
+	if !sh.verbose {
-	cmd.Stdout = &stdo
+		var stdo, stde bytes.Buffer
-	cmd.Stderr = &stde
+		cmd.Stdout = &stdo
-	err = cmd.Run()
+		cmd.Stderr = &stde
-	stdout = string(stdo.Bytes())
+		err = cmd.Run()
-	stderr = string(stde.Bytes())
+		stdout = string(stdo.Bytes())
+		stderr = string(stde.Bytes())
+	} else {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err = cmd.Run()
+	}
 	return
 }
 
@@ -33,11 +45,17 @@ func (sh *ShellHelper) RunInDirectory(dir string, command string, vars ...string
 	cmd := exec.Command(command, vars...)
 	cmd.Dir = dir
 	cmd.Env = append(os.Environ(), "GO111MODULE=on")
-	var stdo, stde bytes.Buffer
+	if !sh.verbose {
-	cmd.Stdout = &stdo
+		var stdo, stde bytes.Buffer
-	cmd.Stderr = &stde
+		cmd.Stdout = &stdo
-	err = cmd.Run()
+		cmd.Stderr = &stde
-	stdout = string(stdo.Bytes())
+		err = cmd.Run()
-	stderr = string(stde.Bytes())
+		stdout = string(stdo.Bytes())
+		stderr = string(stde.Bytes())
+	} else {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err = cmd.Run()
+	}
 	return
 }

cmd/system.go

@@ -5,12 +5,11 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
+	"os"
 	"path/filepath"
 	"runtime"
 	"strconv"
 	"time"
-
-	homedir "github.com/mitchellh/go-homedir"
 )
 
 // SystemHelper - Defines everything related to the system
@@ -38,10 +37,11 @@ func NewSystemHelper() *SystemHelper {
 // setSystemDirs calculates the system directories it is interested in
 func (s *SystemHelper) setSystemDirs() {
 	var err error
-	s.homeDir, err = homedir.Dir()
+	s.homeDir, err = os.UserHomeDir()
 	if err != nil {
 		log.Fatal("Cannot find home directory! Please file a bug report!")
 	}
+
 	// TODO: A better config system
 	s.wailsSystemDir = filepath.Join(s.homeDir, ".wails")
 	s.wailsSystemConfig = filepath.Join(s.wailsSystemDir, s.configFilename)
@@ -132,7 +132,7 @@ func (s *SystemHelper) setup() error {
 }
 
 const introText = `
-Wails is a lightweight framework for creating web-like desktop apps in Go. 
+Wails is a lightweight framework for creating web-like desktop apps in Go.
 I'll need to ask you a few questions so I can fill in your project templates and then I will try and see if you have the correct dependencies installed. If you don't have the right tools installed, I'll try and suggest how to install them.
 `
 
@@ -274,16 +274,18 @@ func CheckDependencies(logger *Logger) (bool, error) {
 		distroInfo := GetLinuxDistroInfo()
 
 		switch distroInfo.Distribution {
-		case Ubuntu, Debian, Zorin, Parrot, Linuxmint, Elementary, Kali, Neon:
+		case Ubuntu, Debian, Zorin, Parrot, Linuxmint, Elementary, Kali, Neon, Deepin, Raspbian, PopOS:
 			libraryChecker = DpkgInstalled
-		case Arch, Manjaro:
+		case Arch, ArcoLinux, ArchLabs, Ctlos, Manjaro, ManjaroARM:
 			libraryChecker = PacmanInstalled
-		case CentOS, Fedora:
+		case CentOS, Fedora, Tumbleweed, Leap:
 			libraryChecker = RpmInstalled
 		case Gentoo:
 			libraryChecker = EqueryInstalled
 		case VoidLinux:
 			libraryChecker = XbpsInstalled
+		case Solus:
+			libraryChecker = EOpkgInstalled
 		default:
 			return false, RequestSupportForDistribution(distroInfo)
 		}

cmd/templates/angular-template/frontend/browserslist

@@ -9,4 +9,4 @@
 last 2 versions
 Firefox ESR
 not dead
-IE 9-11 # For IE 9-11 support, remove 'not'.
+IE 9-11 # For IE 9-11 support, remove 'not'.

cmd/templates/angular-template/frontend/package.json.template

@@ -3,7 +3,7 @@
   "version": "0.0.0",
   "scripts": {
     "ng": "npx ng",
-    "start": "npx ng serve --poll=2000",
+    "start": "npx ng serve --poll=2000 --host=0.0.0.0",
     "build": "npx ng build --single-bundle true --output-hashing none --prod --bundle-styles false",
     "test": "npx ng test",
     "lint": "npx ng lint",

cmd/templates/create-react-app/frontend/package.json.template

@@ -4,12 +4,12 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
-    "core-js": "^3.1.4",
+    "core-js": "^3.6.4",
-    "react": "^16.8.6",
+    "react": "^16.13.1",
-    "react-dom": "^16.8.6",
+    "react-dom": "^16.13.1",
     "wails-react-scripts": "3.0.1-2",
-    "react-modal": "3.8.1",
+    "react-modal": "3.11.2",
-    "@wailsapp/runtime": "^1.0.0"
+    "@wailsapp/runtime": "^1.0.10"
   },
   "scripts": {
     "start": "react-scripts start",

cmd/templates/create-react-app/frontend/public/index.html

@@ -1,10 +1,13 @@
 <!DOCTYPE html>
 <html lang="en">
-  <head>
+
+<head>
     <meta charset="utf-8" />
-    <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico" />
+    <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="theme-color" content="#000000" />
+    <meta name="description" content="Web site created using create-react-app" />
+    <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
     <!--
       manifest.json provides metadata used when your web app is installed on a
       user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
@@ -20,8 +23,9 @@
       Learn how to configure a non-root public URL by running `npm run build`.
     -->
     <title>React App</title>
-  </head>
+</head>
-  <body>
+
+<body>
     <noscript>You need to enable JavaScript to run this app.</noscript>
     <div id="app"></div>
     <!--
@@ -34,5 +38,6 @@
       To begin the development, run `npm start` or `yarn start`.
       To create a production bundle, use `npm run build` or `yarn build`.
     -->
-  </body>
+</body>
-</html>
+
+</html>

cmd/templates/create-react-app/frontend/public/manifest.json

@@ -6,6 +6,16 @@
       "src": "favicon.ico",
       "sizes": "64x64 32x32 24x24 16x16",
       "type": "image/x-icon"
+    },
+    {
+      "src": "logo192.png",
+      "type": "image/png",
+      "sizes": "192x192"
+    },
+    {
+      "src": "logo512.png",
+      "type": "image/png",
+      "sizes": "512x512"
     }
   ],
   "start_url": ".",

cmd/templates/create-react-app/frontend/public/robots.txt

@@ -0,0 +1,3 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:

cmd/templates/create-react-app/frontend/src/App.css

@@ -3,11 +3,16 @@
 }
 
 .App-logo {
-  animation: App-logo-spin infinite 20s linear;
   height: 40vmin;
   pointer-events: none;
 }
 
+@media (prefers-reduced-motion: no-preference) {
+  .App-logo {
+    animation: App-logo-spin infinite 20s linear;
+  }
+}
+
 .App-header {
   background-color: #282c34;
   min-height: 100vh;

cmd/templates/create-react-app/frontend/src/components/HelloWorld.js

@@ -1,48 +1,35 @@
-import React from 'react';
+import React, { useState } from 'react';
 import Modal from 'react-modal';
 
-class HelloWorld extends React.Component {
+function HelloWorld() {
-  constructor(props, context) {
+	const [showModal, setShowModal] = useState(false);
-    super();
+	const [result, setResult] = useState(null);
-    this.state = {
-      showModal: false
-    };
 
-    this.handleOpenModal = this.handleOpenModal.bind(this);
+	const handleOpenModal = () => {
-    this.handleCloseModal = this.handleCloseModal.bind(this);
+		setShowModal(true);
-  }
 
-  handleOpenModal () {
+		window.backend.basic().then((result) => setResult(result));
-    this.setState({ showModal: true });
+	};
 
-    window.backend.basic().then(result =>
+	const handleCloseModal = () => {
-      this.setState({
+		setShowModal(false);
-        result
+	};
-      })
-    );
-  }
 
-  handleCloseModal () {
+	return (
-    this.setState({ showModal: false });
+		<div className="App">
-  }
+			<button onClick={() => handleOpenModal()} type="button">
-
+				Hello
-  render() {
+      </button>
-    const { result } = this.state;
+			<Modal
-    return (
+				appElement={document.getElementById("app")}
-      <div className="App">
+				isOpen={showModal}
-        <button onClick={this.handleOpenModal} type="button">
+				contentLabel="Minimal Modal Example"
-          Hello
+			>
-        </button>
+				<p>{result}</p>
-        <Modal
+				<button onClick={() => handleCloseModal()}>Close Modal</button>
-          isOpen={this.state.showModal}
+			</Modal>
-          contentLabel="Minimal Modal Example"
+		</div>
-        >
+	);
-        <p>{result}</p>
-        <button onClick={this.handleCloseModal}>Close Modal</button>
-        </Modal>
-      </div>
-    );
-  }
 }
 
 export default HelloWorld;

cmd/templates/create-react-app/frontend/src/index.js

@@ -3,9 +3,20 @@ import ReactDOM from 'react-dom';
 import 'core-js/stable';
 import './index.css';
 import App from './App';
+import * as serviceWorker from './serviceWorker';
 
 import * as Wails from '@wailsapp/runtime';
 
 Wails.Init(() => {
-  ReactDOM.render(<App />, document.getElementById('app'));
+  ReactDOM.render(
+    <React.StrictMode>
+      <App />
+    </React.StrictMode>,
+    document.getElementById("app")
+  );
 });
+
+// If you want your app to work offline and load faster, you can change
+// unregister() to register() below. Note this comes with some pitfalls.
+// Learn more about service workers: https://bit.ly/CRA-PWA
+serviceWorker.unregister();

cmd/templates/create-react-app/template.json

@@ -1,8 +1,8 @@
 {
   "name": "React JS",
   "version": "1.0.0",
-  "shortdescription": "Create React App v3 template",
+  "shortdescription": "Create React App v4 template",
-  "description": "Create React App v3 standar tooling",
+  "description": "Create React App v4 standard tooling",
   "install": "npm install",
   "build": "npm run build",
   "author": "bh90210 <ktc@pm.me>",

cmd/templates/vanilla/README.md

@@ -0,0 +1,5 @@
+# README
+
+This is an experimental template for vanilla HTML/JS/CSS.
+
+The webpack rules may need to be adjusted to correctly embed all assets. Babel may also need to be setup correctly.

cmd/templates/vanilla/counter.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/wailsapp/wails"
+)
+
+// Counter is what we use for counting
+type Counter struct {
+	r     *wails.Runtime
+	store *wails.Store
+}
+
+// WailsInit is called when the component is being initialised
+func (c *Counter) WailsInit(runtime *wails.Runtime) error {
+	c.r = runtime
+	c.store = runtime.Store.New("Counter", 0)
+	return nil
+}
+
+// RandomValue sets the counter to a random value
+func (c *Counter) RandomValue() {
+	c.store.Set(rand.Intn(1000))
+}
+
+// Increment will increment the counter
+func (c *Counter) Increment() {
+
+	increment := func(data int) int {
+		return data + 1
+	}
+
+	// Update the store using the increment function
+	c.store.Update(increment)
+}
+
+// Decrement will decrement the counter
+func (c *Counter) Decrement() {
+
+	decrement := func(data int) int {
+		return data - 1
+	}
+	// Update the store using the decrement function
+	c.store.Update(decrement)
+}

cmd/templates/vanilla/frontend/package.json.template

@@ -0,0 +1,42 @@
+{
+  "name": "vanilla",
+  "author": "Lea<l>",
+  "private": true,
+  "scripts": {
+    "serve": "webpack-dev-server",
+    "build": "npx webpack"
+  },
+  "dependencies": {
+    "core-js": "^3.6.4",
+    "regenerator-runtime": "^0.13.3",
+    "@wailsapp/runtime": "^1.0.10"
+  },
+  "devDependencies": {
+    "babel-eslint": "^10.1.0",
+    "copy-webpack-plugin": "^6.0.2",
+    "eslint": "^6.8.0",
+    "eventsource-polyfill": "^0.9.6",
+    "webpack": "^4.43.0",
+    "webpack-cli": "^3.3.11",
+    "webpack-dev-server": "^3.11.0",
+    "webpack-hot-middleware": "^2.25.0"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "node": true
+    },
+    "extends": [
+      "eslint:recommended"
+    ],
+    "rules": {},
+    "parserOptions": {
+      "parser": "babel-eslint"
+    }
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not ie <= 8"
+  ]
+}

cmd/templates/vanilla/frontend/src/index.html

@@ -0,0 +1,9 @@
+<html>
+    <head>
+        <link rel="stylesheet" type="text/css" href="main.css">
+    </head>
+    <body>
+        <div id="app"></div>
+        <script src="main.js"></script>
+    </body>
+</html>

cmd/templates/vanilla/frontend/src/main.js

@@ -0,0 +1,47 @@
+import 'core-js/stable';
+const runtime = require('@wailsapp/runtime');
+
+// Main entry point
+function start() {
+
+	var mystore = wails.Store.New('Counter');
+
+	// Ensure the default app div is 100% wide/high
+	var app = document.getElementById('app');
+	app.style.width = '100%';
+	app.style.height = '100%';
+
+	// Inject html
+	app.innerHTML = `
+	<div class='logo'></div>
+	<div class='container'>
+	<button onClick='window.backend.Counter.Increment()'>
+		Increment Counter
+	</button>
+	<button onClick='window.backend.Counter.Decrement()'>
+		Decrement Counter
+		</button>
+	</div>
+	<div class='result'>Counter: <span id='counter'></span></div>
+	<div class='container'>
+		<input id='newCounter' type="number" value="0"/>
+		<button id='setvalue'>Set Counter Value</button>
+		<button onclick='window.backend.Counter.RandomValue()'>Set to Random Value</button>
+	</div>
+	`;
+
+	// Connect counter value button to Go method
+	document.getElementById('setvalue').onclick = function() {
+		let newValue = parseInt(document.getElementById('newCounter').value,10);
+		mystore.set(newValue);
+	};
+
+	mystore.subscribe( (state) => {
+		document.getElementById('counter').innerText = state;
+	});
+
+	mystore.set(0);
+};
+
+// We provide our entrypoint as a callback for runtime.Init
+runtime.Init(start);

cmd/templates/vanilla/frontend/webpack.config.js

@@ -0,0 +1,56 @@
+const path = require('path');
+const CopyWebpackPlugin = require('copy-webpack-plugin');
+
+let imageSizeLimit = 9007199254740991; // Number.MAX_SAFE_INTEGER
+let sourceDir = path.resolve(__dirname, 'src');
+let buildDir = path.resolve(__dirname, 'build');
+
+module.exports = {
+	entry: {
+		index: path.resolve(sourceDir, 'main.js')
+	},
+	output: {
+		path: buildDir,
+		filename: 'main.js'
+	},
+	optimization: {
+		splitChunks: false
+	},
+	devServer: {
+		disableHostCheck: true,
+		contentBase: path.join(__dirname, 'src'),
+		compress: true,
+		open: true,
+		port: 8090
+	},
+	mode: 'production',
+	module: {
+		rules: [
+			{
+				test: /\.(png|gif|jpg|woff2?|eot|ttf|otf|svg)(\?.*)?$/i,
+				use: [
+					{
+						loader: 'url-loader',
+						options: {
+							limit: imageSizeLimit
+						}
+					}
+				],
+			}
+		]
+	},
+	plugins: [
+		new CopyWebpackPlugin({
+			patterns: [
+				{
+					from: path.resolve(sourceDir, 'main.css'),
+					to: path.resolve(buildDir, 'main.css')
+				},
+				{
+					from: path.resolve(sourceDir, 'index.html'),
+					to: path.resolve(buildDir, 'index.html')
+				},
+			]
+		})
+	]
+};

cmd/templates/vanilla/go.mod.template

@@ -0,0 +1,5 @@
+module {{.BinaryName}}
+
+require (
+	github.com/wailsapp/wails {{.WailsVersion}}
+)

cmd/templates/vanilla/main.go.template

@@ -0,0 +1,23 @@
+package main
+
+import (
+  "github.com/leaanthony/mewn"
+  "github.com/wailsapp/wails"
+)
+
+func main() {
+
+	js := mewn.String("./frontend/build/main.js")
+	css := mewn.String("./frontend/build/main.css")
+
+  app := wails.CreateApp(&wails.AppConfig{
+    Width:  1024,
+    Height: 768,
+    Title:  "{{.Name}}",
+    JS:     js,
+    CSS:    css,
+    Colour: "#131313",
+  })
+  app.Bind(&Counter{})
+  app.Run()
+}

cmd/templates/vanilla/template.json

@@ -0,0 +1,12 @@
+{
+  "name": "Vanilla",
+  "shortdescription": "A Vanilla HTML/JS template",
+  "description": "A basic template using plain html/js and bundled using Webpack 4",
+  "author": "Lea Anthony<lea.anthony@gmail.com>",
+  "created": "2020-06-14",
+  "frontenddir": "frontend",
+  "install": "npm install",
+  "build": "npm run build",
+  "serve": "npm run serve",
+  "bridge": "src"
+}

cmd/templates/vuebasic/frontend/babel.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   presets: [
-    '@vue/app'
+		[ '@vue/app', { useBuiltIns: 'entry' } ]
   ]
 }

cmd/templates/vuebasic/frontend/package.json.template

@@ -8,20 +8,21 @@
     "lint": "vue-cli-service lint"
   },
   "dependencies": {
-    "core-js": "^2.6.4",
+    "core-js": "^3.6.4",
-    "vue": "^2.5.22",
+    "regenerator-runtime": "^0.13.3",
-    "@wailsapp/runtime": "^1.0.0"
+    "vue": "^2.6.11",
+    "@wailsapp/runtime": "^1.0.10"
   },
   "devDependencies": {
-    "@vue/cli-plugin-babel": "^3.4.0",
+    "@vue/cli-plugin-babel": "^4.2.3",
-    "@vue/cli-plugin-eslint": "^3.4.0",
+    "@vue/cli-plugin-eslint": "^4.2.3",
-    "@vue/cli-service": "^3.4.0",
+    "@vue/cli-service": "^4.2.3",
-    "babel-eslint": "^10.0.1",
+    "babel-eslint": "^10.1.0",
-    "eslint": "^5.8.0",
+    "eslint": "^6.8.0",
-    "eslint-plugin-vue": "^5.0.0",
+    "eslint-plugin-vue": "^6.2.1",
     "eventsource-polyfill": "^0.9.6",
-    "vue-template-compiler": "^2.5.21",
+    "vue-template-compiler": "^2.6.11",
-    "webpack-hot-middleware": "^2.24.3"
+    "webpack-hot-middleware": "^2.25.0"
   },
   "eslintConfig": {
     "root": true,

cmd/templates/vuebasic/frontend/src/main.js

@@ -1,3 +1,5 @@
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
 import Vue from 'vue';
 import App from './App.vue';
 

cmd/templates/vuebasic/frontend/vue.config.js

@@ -37,7 +37,6 @@ module.exports = {
     }
   },
   devServer: {
-    disableHostCheck: true,
+		disableHostCheck: true
-    host: "localhost"
   }
 };

cmd/templates/vuetify-basic/frontend/babel.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   presets: [
-    '@vue/app'
+		[ '@vue/app', { useBuiltIns: 'entry' } ]
   ]
 }

cmd/templates/vuetify-basic/frontend/package.json.template

@@ -7,24 +7,24 @@
     "build": "vue-cli-service build",
     "lint": "vue-cli-service lint"
   },
-  "dependencies": {
+"dependencies": {
-    "babel-polyfill": "^6.26.0",
+    "core-js": "^3.6.4",
-    "core-js": "^2.6.4",
+    "regenerator-runtime": "^0.13.3",
     "material-design-icons-iconfont": "^5.0.1",
     "vue": "^2.5.22",
     "vuetify": "^1.5.14",
-    "@wailsapp/runtime": "^1.0.0"
+    "@wailsapp/runtime": "^1.0.10"
   },
   "devDependencies": {
-    "@vue/cli-plugin-babel": "^3.4.0",
+    "@vue/cli-plugin-babel": "^4.2.3",
-    "@vue/cli-plugin-eslint": "^3.4.0",
+    "@vue/cli-plugin-eslint": "^4.2.3",
-    "@vue/cli-service": "^3.4.0",
+    "@vue/cli-service": "^4.2.3",
-    "babel-eslint": "^10.0.1",
+    "babel-eslint": "^10.1.0",
-    "eslint": "^5.8.0",
+    "eslint": "^6.8.0",
-    "eslint-plugin-vue": "^5.0.0",
+    "eslint-plugin-vue": "^6.2.1",
     "eventsource-polyfill": "^0.9.6",
-    "vue-template-compiler": "^2.5.21",
+    "vue-template-compiler": "^2.6.11",
-    "webpack-hot-middleware": "^2.24.3"
+    "webpack-hot-middleware": "^2.25.0"
   },
   "eslintConfig": {
     "root": true,
@@ -50,4 +50,4 @@
     "last 2 versions",
     "not ie <= 8"
   ]
-}
+}

cmd/templates/vuetify-basic/frontend/src/main.js

@@ -1,4 +1,5 @@
-import 'babel-polyfill';
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
 import Vue from 'vue';
 
 // Setup Vuetify

cmd/templates/vuetify-basic/frontend/vue.config.js

@@ -37,7 +37,6 @@ module.exports = {
     }
   },
   devServer: {
-    disableHostCheck: true,
+		disableHostCheck: true
-    host: "localhost"
   }
 };

cmd/templates/vuetify-basic/template.json

@@ -1,8 +1,8 @@
 {
-  "name": "Vuetify Basic",
+  "name": "Vuetify1.5/Webpack Basic",
   "version": "1.0.0",
-  "shortdescription": "Vuetify + Webpack",
+  "shortdescription": "A basic Vuetify1.5/Webpack4 template",
-  "description": "Basic template using Vuetify and bundled using Webpack",
+  "description": "Basic template using Vuetify v1.5 and bundled using Webpack",
   "install": "npm install",
   "build": "npm run build",
   "author": "lea <lea.anthony@gmail.com>",
@@ -11,4 +11,4 @@
   "serve": "npm run serve",
   "bridge": "src",
   "wailsdir": ""
-}
+}

cmd/templates/vuetify2-basic/.jshint

@@ -0,0 +1,3 @@
+{ 
+  "esversion": 6 
+}

cmd/templates/vuetify2-basic/frontend/.gitignore

@@ -0,0 +1,21 @@
+.DS_Store
+node_modules
+/dist
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw*

cmd/templates/vuetify2-basic/frontend/babel.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+	presets: [
+		[ '@vue/app', { useBuiltIns: 'entry' } ]
+	]
+};

cmd/templates/vuetify2-basic/frontend/package.json.template

@@ -0,0 +1,53 @@
+{
+  "name": "{{.NPMProjectName}}",
+  "author": "{{.Author.Name}}<{{.Author.Email}}>",
+  "private": true,
+  "scripts": {
+    "serve": "vue-cli-service serve",
+    "build": "vue-cli-service build",
+    "lint": "vue-cli-service lint"
+  },
+  "dependencies": {
+    "core-js": "^3.6.4",
+    "regenerator-runtime": "^0.13.3",
+    "vue": "^2.6.11",
+    "vuetify": "^2.2.15",
+    "@wailsapp/runtime": "^1.0.10"
+  },
+  "devDependencies": {
+    "@mdi/font": "^4.9.95",
+    "@vue/cli-plugin-babel": "^4.2.3",
+    "@vue/cli-plugin-eslint": "^4.2.3",
+    "@vue/cli-service": "^4.2.3",
+    "babel-eslint": "^10.1.0",
+    "eslint": "^6.8.0",
+    "eslint-plugin-vue": "^6.2.1",
+    "eventsource-polyfill": "^0.9.6",
+    "vue-template-compiler": "^2.6.11",
+    "webpack-hot-middleware": "^2.25.0"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "node": true
+    },
+    "extends": [
+      "plugin:vue/essential",
+      "eslint:recommended"
+    ],
+    "rules": {},
+    "parserOptions": {
+      "parser": "babel-eslint"
+    }
+  },
+  "postcss": {
+    "plugins": {
+      "autoprefixer": {}
+    }
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not ie <= 8"
+  ]
+}

cmd/templates/vuetify2-basic/frontend/src/App.vue

@@ -0,0 +1,60 @@
+<template>
+  <v-app id="inspire">
+    <v-navigation-drawer v-model="drawer" clipped fixed app>
+      <v-list dense>
+        <v-list-item>
+          <v-list-item-icon>
+            <v-icon>mdi-view-dashboard</v-icon>
+          </v-list-item-icon>
+          <v-list-item-content>
+            <v-list-item-title>Dashboard</v-list-item-title>
+          </v-list-item-content>
+        </v-list-item>
+        <v-list-item>
+          <v-list-item-icon>
+            <v-icon>mdi-settings</v-icon>
+          </v-list-item-icon>
+          <v-list-item-content>
+            <v-list-item-title>Settings</v-list-item-title>
+          </v-list-item-content>
+        </v-list-item>
+      </v-list>
+    </v-navigation-drawer>
+    <v-app-bar app fixed clipped-left>
+      <v-app-bar-nav-icon @click.stop="drawer = !drawer"></v-app-bar-nav-icon>
+      <v-toolbar-title>Application</v-toolbar-title>
+    </v-app-bar>
+    <v-content>
+      <v-container fluid class="px-0">
+        <v-layout justify-center align-center class="px-0">
+          <hello-world></hello-world>
+        </v-layout>
+      </v-container>
+    </v-content>
+    <v-footer app fixed>
+      <span style="margin-left:1em">&copy; You</span>
+    </v-footer>
+  </v-app>
+</template>
+
+<script>
+  import HelloWorld from "./components/HelloWorld.vue"
+
+  export default {
+    data: () => ({
+      drawer: false
+    }),
+    components: {
+      HelloWorld
+    },
+    props: {
+      source: String
+    }
+  }
+</script>
+
+<style>
+  .logo {
+    width: 16em;
+  }
+</style>

cmd/templates/vuetify2-basic/frontend/src/components/HelloWorld.vue

@@ -0,0 +1,85 @@
+<template>
+  <v-container fluid class="px-0">
+    <v-layout>
+      <v-flex xs12 sm6 offset-sm3>
+        <v-card raised="raised" class="pa-4 ma-4">
+          <v-layout justify-center align-center class="pa-4 ma-4">
+            <v-img :src="require('../assets/images/logo.png')"></v-img>
+          </v-layout>
+          <v-card-actions>
+            <v-layout justify-center align-center class="px-0">
+              <v-btn color="blue" @click="getMessage">Press Me</v-btn>
+            </v-layout>
+          </v-card-actions>
+        </v-card>
+      </v-flex>
+    </v-layout>
+    <div class="text-xs-center">
+      <v-dialog v-model="dialog" width="500">
+        <v-card>
+          <v-card-title class="headline" primary-title>Message from Go</v-card-title>
+          <v-card-text>{{message}}</v-card-text>
+          <v-divider></v-divider>
+          <v-card-actions>
+            <v-spacer></v-spacer>
+            <v-btn color="primary" text @click="dialog = false">Awesome</v-btn>
+          </v-card-actions>
+        </v-card>
+      </v-dialog>
+    </div>
+  </v-container>
+</template>
+
+<script>
+  export default {
+    data () {
+      return {
+        message: " ",
+        raised: true,
+        dialog: false
+      }
+    },
+    methods: {
+      getMessage: function () {
+        var self = this
+        window.backend.basic().then(result => {
+          self.message = result
+          self.dialog = true
+        })
+      }
+    }
+  }
+</script>
+
+<!-- Add "scoped" attribute to limit CSS to this component only -->
+<style scoped>
+  h1 {
+    margin-top: 2em;
+    position: relative;
+    min-height: 5rem;
+    width: 100%;
+  }
+
+  a:hover {
+    font-size: 1.7em;
+    border-color: blue;
+    background-color: blue;
+    color: white;
+    border: 3px solid white;
+    border-radius: 10px;
+    padding: 9px;
+    cursor: pointer;
+    transition: 500ms;
+  }
+
+  a {
+    font-size: 1.7em;
+    border-color: white;
+    background-color: #121212;
+    color: white;
+    border: 3px solid white;
+    border-radius: 10px;
+    padding: 9px;
+    cursor: pointer;
+  }
+</style>

cmd/templates/vuetify2-basic/frontend/src/main.js

@@ -0,0 +1,29 @@
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+import '@mdi/font/css/materialdesignicons.css';
+import Vue from 'vue';
+import Vuetify from 'vuetify';
+import 'vuetify/dist/vuetify.min.css';
+
+Vue.use(Vuetify);
+
+import App from './App.vue';
+
+Vue.config.productionTip = false;
+Vue.config.devtools = true;
+
+import Wails from '@wailsapp/runtime';
+
+Wails.Init(() => {
+	new Vue({
+		vuetify: new Vuetify({
+			icons: {
+				iconfont: 'mdi'
+			},
+			theme: {
+				dark: true
+			}
+		}),
+		render: h => h(App)
+	}).$mount('#app');
+});

cmd/templates/vuetify2-basic/frontend/vue.config.js

@@ -0,0 +1,42 @@
+let cssConfig = {};
+
+if (process.env.NODE_ENV == 'production') {
+	cssConfig = {
+		extract: {
+			filename: '[name].css',
+			chunkFilename: '[name].css'
+		}
+	};
+}
+
+module.exports = {
+	chainWebpack: config => {
+		let limit = 9999999999999999;
+		config.module
+			.rule('images')
+			.test(/\.(png|gif|jpg)(\?.*)?$/i)
+			.use('url-loader')
+			.loader('url-loader')
+			.tap(options => Object.assign(options, { limit: limit }));
+		config.module
+			.rule('fonts')
+			.test(/\.(woff2?|eot|ttf|otf|svg)(\?.*)?$/i)
+			.use('url-loader')
+			.loader('url-loader')
+			.options({
+				limit: limit
+			});
+	},
+	css: cssConfig,
+	configureWebpack: {
+		output: {
+			filename: '[name].js'
+		},
+		optimization: {
+			splitChunks: false
+		}
+	},
+	devServer: {
+		disableHostCheck: true
+	}
+};

cmd/templates/vuetify2-basic/go.mod.template

@@ -0,0 +1,5 @@
+module {{.BinaryName}}
+
+require (
+	github.com/wailsapp/wails {{.WailsVersion}}
+)

cmd/templates/vuetify2-basic/main.go.template

@@ -0,0 +1,27 @@
+package main
+
+import (
+  "github.com/leaanthony/mewn"
+  "github.com/wailsapp/wails"
+)
+
+func basic() string {
+  return "Hello World!"
+}
+
+func main() {
+
+  js := mewn.String("./frontend/dist/app.js")
+  css := mewn.String("./frontend/dist/app.css")
+
+  app := wails.CreateApp(&wails.AppConfig{
+    Width:  1024,
+    Height: 768,
+    Title:  "{{.Name}}",
+    JS:     js,
+    CSS:    css,
+    Colour: "#131313",
+  })
+  app.Bind(basic)
+  app.Run()
+}

cmd/templates/vuetify2-basic/template.json

@@ -0,0 +1,14 @@
+{
+  "name": "Vuetify2/Webpack Basic",
+  "version": "1.0.0",
+  "shortdescription": "A basic Vuetify2/Webpack4 template",
+  "description": "Basic template using Vuetify v2 and bundled using Webpack",
+  "install": "npm install",
+  "build": "npm run build",
+  "author": "Michael Hipp <michael@redmule.com>",
+  "created": "2019-09-06",
+  "frontenddir": "frontend",
+  "serve": "npm run serve",
+  "bridge": "src",
+  "wailsdir": ""
+}

cmd/version.go

@@ -1,4 +1,4 @@
 package cmd
 
 // Version - Wails version
-const Version = "v0.19.0"
+const Version = "v1.7.2-pre5"

cmd/wails/0_setup.go

@@ -40,7 +40,7 @@ Create your first project by running 'wails init'.`
 		}
 
 		// Check Mewn
-		err = cmd.CheckMewn()
+		err = cmd.CheckMewn(false)
 		if err != nil {
 			return err
 		}

cmd/wails/15_migrate.go

@@ -7,7 +7,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"regexp"
 	"strings"
 
 	"github.com/Masterminds/semver"
@@ -183,35 +182,13 @@ func checkProjectDirectory() error {
 
 func getWailsVersion() (*semver.Version, error) {
 	checkSpinner.Start("Get Wails Version")
-	var result *semver.Version
 
-	// Load file
+	result, err := cmd.GetWailsVersion()
-	var err error
+
-	goModFile, err = filepath.Abs(filepath.Join(".", "go.mod"))
 	if err != nil {
-		checkSpinner.Error()
+		checkSpinner.Error(err.Error())
-		return nil, fmt.Errorf("Unable to load go.mod at %s", goModFile)
+		return nil, err
 	}
-	goMod, err = migrateFS.LoadAsString(goModFile)
-	if err != nil {
-		checkSpinner.Error()
-		return nil, fmt.Errorf("Unable to load go.mod")
-	}
-
-	// Find wails version
-	versionRegexp := regexp.MustCompile(`.*github.com/wailsapp/wails.*(v\d+.\d+.\d+)`)
-	versions := versionRegexp.FindStringSubmatch(goMod)
-
-	if len(versions) != 2 {
-		return nil, fmt.Errorf("Unable to determine Wails version")
-	}
-
-	version := versions[1]
-	result, err = semver.NewVersion(version)
-	if err != nil {
-		return nil, fmt.Errorf("Unable to parse Wails version: %s", version)
-	}
-	checkSpinner.Success("Found Wails Version: " + version)
 	return result, nil
 
 }

cmd/wails/4_build.go

@@ -3,16 +3,34 @@ package main
 import (
 	"fmt"
 	"os"
+	"runtime"
+	"strings"
 
 	"github.com/leaanthony/spinner"
 	"github.com/wailsapp/wails/cmd"
 )
 
+// getSupportedPlatforms returns a slice of platform/architecture
+// targets that are buildable using the cross-platform 'x' option.
+func getSupportedPlatforms() []string {
+	return []string{
+		"darwin/amd64",
+		"linux/amd64",
+		"linux/arm-7",
+		"windows/amd64",
+	}
+}
+
 func init() {
 
 	var packageApp = false
 	var forceRebuild = false
 	var debugMode = false
+	var typescriptFilename = ""
+	var verbose = false
+	var platform = ""
+	var ldflags = ""
+
 	buildSpinner := spinner.NewSpinner()
 	buildSpinner.SetSpinSpeed(50)
 
@@ -21,7 +39,18 @@ func init() {
 		LongDescription(commandDescription).
 		BoolFlag("p", "Package application on successful build", &packageApp).
 		BoolFlag("f", "Force rebuild of application components", &forceRebuild).
-		BoolFlag("d", "Build in Debug mode", &debugMode)
+		BoolFlag("d", "Build in Debug mode", &debugMode).
+		BoolFlag("verbose", "Verbose output", &verbose).
+		StringFlag("t", "Generate Typescript definitions to given file (at runtime)", &typescriptFilename).
+		StringFlag("ldflags", "Extra options for -ldflags", &ldflags)
+
+	var b strings.Builder
+	for _, plat := range getSupportedPlatforms() {
+		fmt.Fprintf(&b, " - %s\n", plat)
+	}
+	initCmd.StringFlag("x",
+		fmt.Sprintf("Cross-compile application to specified platform via xgo\n%s", b.String()),
+		&platform)
 
 	initCmd.Action(func() error {
 
@@ -37,6 +66,7 @@ func init() {
 
 		// Project options
 		projectOptions := &cmd.ProjectOptions{}
+		projectOptions.Verbose = verbose
 
 		// Check we are in project directory
 		// Check project.json loads correctly
@@ -46,6 +76,28 @@ func init() {
 			return fmt.Errorf("Unable to find 'project.json'. Please check you are in a Wails project directory")
 		}
 
+		// Set cross-compile
+		projectOptions.Platform = runtime.GOOS
+		if len(platform) > 0 {
+			supported := false
+			for _, plat := range getSupportedPlatforms() {
+				if plat == platform {
+					supported = true
+				}
+			}
+			if !supported {
+				return fmt.Errorf("unsupported platform '%s' specified.\nPlease run `wails build -h` to see the supported platform/architecture options", platform)
+			}
+
+			projectOptions.CrossCompile = true
+			plat := strings.Split(platform, "/")
+			projectOptions.Platform = plat[0]
+			projectOptions.Architecture = plat[1]
+		}
+
+		// Add ldflags
+		projectOptions.LdFlags = ldflags
+
 		// Validate config
 		// Check if we have a frontend
 		err = cmd.ValidateFrontendConfig(projectOptions)
@@ -73,16 +125,13 @@ func init() {
 				return err
 			}
 
-				// Ensure that runtime init.js is the production version
+			// Ensure that runtime init.js is the production version
-				err = cmd.InstallProdRuntime(projectDir, projectOptions)
+			err = cmd.InstallProdRuntime(projectDir, projectOptions)
-				if err != nil {
+			if err != nil {
-					return err
+				return err
-				}
+			}
 		}
 
-	
-
-
 		// Move to project directory
 		err = os.Chdir(projectDir)
 		if err != nil {
@@ -90,7 +139,7 @@ func init() {
 		}
 
 		// Install dependencies
-		err = cmd.InstallGoDependencies()
+		err = cmd.InstallGoDependencies(projectOptions.Verbose)
 		if err != nil {
 			return err
 		}
@@ -101,6 +150,32 @@ func init() {
 			buildMode = cmd.BuildModeDebug
 		}
 
+		// Save if we wish to dump typescript or not
+		if typescriptFilename != "" {
+			projectOptions.SetTypescriptDefsFilename(typescriptFilename)
+		}
+
+		// Update go.mod if it is out of sync with current version
+		outofsync, err := cmd.GoModOutOfSync()
+		if err != nil {
+			return err
+		}
+		gomodVersion, err := cmd.GetWailsVersion()
+		if err != nil {
+			return err
+		}
+		if outofsync {
+			syncMessage := fmt.Sprintf("Updating go.mod (Wails version %s => %s)", gomodVersion, cmd.Version)
+			buildSpinner := spinner.NewSpinner(syncMessage)
+			buildSpinner.Start()
+			err := cmd.UpdateGoModVersion()
+			if err != nil {
+				buildSpinner.Error(err.Error())
+				return err
+			}
+			buildSpinner.Success()
+		}
+
 		err = cmd.BuildApplication(projectOptions.BinaryName, forceRebuild, buildMode, packageApp, projectOptions)
 		if err != nil {
 			return err

cmd/wails/6_serve.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"runtime"
 
 	"github.com/leaanthony/spinner"
 	"github.com/wailsapp/wails/cmd"
@@ -10,12 +11,14 @@ import (
 func init() {
 
 	var forceRebuild = false
+	var verbose = false
 	buildSpinner := spinner.NewSpinner()
 	buildSpinner.SetSpinSpeed(50)
 
 	commandDescription := `This command builds then serves your application in bridge mode. Useful for developing your app in a browser.`
 	initCmd := app.Command("serve", "Run your Wails project in bridge mode").
 		LongDescription(commandDescription).
+		BoolFlag("verbose", "Verbose output", &verbose).
 		BoolFlag("f", "Force rebuild of application components", &forceRebuild)
 
 	initCmd.Action(func() error {
@@ -25,7 +28,7 @@ func init() {
 		fmt.Println()
 
 		// Check Mewn is installed
-		err := cmd.CheckMewn()
+		err := cmd.CheckMewn(verbose)
 		if err != nil {
 			return err
 		}
@@ -41,6 +44,10 @@ func init() {
 			return err
 		}
 
+		// Set project options
+		projectOptions.Verbose = verbose
+		projectOptions.Platform = runtime.GOOS
+
 		// Save project directory
 		projectDir := fs.Cwd()
 
@@ -51,7 +58,7 @@ func init() {
 		}
 
 		// Install dependencies
-		err = cmd.InstallGoDependencies()
+		err = cmd.InstallGoDependencies(projectOptions.Verbose)
 		if err != nil {
 			return err
 		}

cmd/wails/8_update.go

@@ -3,9 +3,9 @@ package main
 import (
 	"fmt"
 	"log"
+	"os"
 
 	"github.com/leaanthony/spinner"
-	"github.com/mitchellh/go-homedir"
 	"github.com/wailsapp/wails/cmd"
 )
 
@@ -146,7 +146,7 @@ func updateToVersion(targetVersion *cmd.SemanticVersion, force bool) error {
 	updateSpinner.Start("Installing Wails " + desiredVersion)
 
 	// Run command in non module directory
-	homeDir, err := homedir.Dir()
+	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		log.Fatal("Cannot find home directory! Please file a bug report!")
 	}

go.mod

@@ -3,9 +3,6 @@ module github.com/wailsapp/wails
 require (
 	github.com/Masterminds/semver v1.4.2
 	github.com/abadojack/whatlanggo v1.0.1
-	github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc // indirect
-	github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac
-	github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947 // indirect
 	github.com/fatih/color v1.7.0
 	github.com/go-playground/colors v1.2.0
 	github.com/gorilla/websocket v1.4.0
@@ -13,21 +10,22 @@ require (
 	github.com/kennygrant/sanitize v1.2.4
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/leaanthony/mewn v0.10.7
-	github.com/leaanthony/slicer v1.3.2
+	github.com/leaanthony/slicer v1.4.0
 	github.com/leaanthony/spinner v0.5.3
 	github.com/mattn/go-colorable v0.1.1 // indirect
 	github.com/mattn/go-isatty v0.0.7 // indirect
-	github.com/mitchellh/go-homedir v1.1.0
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
 	github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4
 	github.com/pkg/errors v0.8.1 // indirect
 	github.com/sirupsen/logrus v1.4.1
 	github.com/stretchr/testify v1.3.0 // indirect
 	github.com/syossan27/tebata v0.0.0-20180602121909-b283fe4bc5ba
-	golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529 // indirect
+	golang.org/x/image v0.0.0-20200430140353-33d19683fad8
-	golang.org/x/net v0.0.0-20190509222800-a4d6f7feada5 // indirect
+	golang.org/x/net v0.0.0-20200625001655-4c5254603344 // indirect
-	golang.org/x/sys v0.0.0-20190509141414-a5b02f93d862
+	golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd
 	golang.org/x/text v0.3.0
 	gopkg.in/AlecAivazis/survey.v1 v1.8.4
 	gopkg.in/yaml.v3 v3.0.0-20190709130402-674ba3eaed22
 )
+
+go 1.13

go.sum

@@ -7,12 +7,6 @@ github.com/abadojack/whatlanggo v1.0.1/go.mod h1:66WiQbSbJBIlOZMsvbKe5m6pzQovxCH
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc h1:VBS1z48BFEe00G81z8MKOtwX7f/ISkuH38NscT8iVPw=
-github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc/go.mod h1:ABJPuor7YlcsHmvJ1QxX38e2NcufLY3hm0yXv+cy9sI=
-github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac h1:DpMwFluHWoZpV9ex5XjkWO4HyCz5HLVI8XbHw0FhHi4=
-github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac/go.mod h1:XsAE+b4rOZc8gvgsgF+wU75mNBvBcyED1wdd9PBLlJ0=
-github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947 h1:Fm10/KNuoAyBm2P5P5H91Xy21hGcZnBdjR+cMdytv1M=
-github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947/go.mod h1:Dv9D0NUlAsaQcGQZa5kc5mqR9ua72SmA8VXi4cd+cBw=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/go-playground/colors v1.2.0 h1:0EdjTXKrr2g1L/LQTYtIqabeHpZuGZz1U4osS1T8+5M=
@@ -34,8 +28,8 @@ github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/leaanthony/mewn v0.10.7 h1:jCcNJyIUOpwj+I5SuATvCugDjHkoo+j6ubEOxxrxmPA=
 github.com/leaanthony/mewn v0.10.7/go.mod h1:CRkTx8unLiSSilu/Sd7i1LwrdaAL+3eQ3ses99qGMEQ=
-github.com/leaanthony/slicer v1.3.2 h1:kGWWFoyaY5WzwGrUsHXMmGbssuYthP4qYBNlkNpNAB8=
+github.com/leaanthony/slicer v1.4.0 h1:Q9u4w+UBU4WHjXnEDdz+eRLMKF/rnyosRBiqULnc1J8=
-github.com/leaanthony/slicer v1.3.2/go.mod h1:VMB/HGvr3uR3MRpFWHWAm0w+DHQLzPHYe2pKfpFlQIQ=
+github.com/leaanthony/slicer v1.4.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
 github.com/leaanthony/spinner v0.5.3 h1:IMTvgdQCec5QA4qRy0wil4XsRP+QcG1OwLWVK/LPZ5Y=
 github.com/leaanthony/spinner v0.5.3/go.mod h1:oHlrvWicr++CVV7ALWYi+qHk/XNA91D9IJ48IqmpVUo=
 github.com/leaanthony/synx v0.1.0 h1:R0lmg2w6VMb8XcotOwAe5DLyzwjLrskNkwU7LLWsyL8=
@@ -52,8 +46,6 @@ github.com/mattn/go-isatty v0.0.7 h1:UvyT9uN+3r7yLEYSlJsbQGdsaB/a0DlgWP3pql6iwOc
 github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
 github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4 h1:49lOXmGaUpV9Fz3gd7TFZY106KVlPVa5jcYD1gaQf98=
@@ -74,19 +66,21 @@ github.com/syossan27/tebata v0.0.0-20180602121909-b283fe4bc5ba h1:2DHfQOxcpWdGf5
 github.com/syossan27/tebata v0.0.0-20180602121909-b283fe4bc5ba/go.mod h1:iLnlXG2Pakcii2CU0cbY07DRCSvpWNa7nFxtevhOChk=
 golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529 h1:iMGN4xG0cnqj3t+zOM8wUB0BiPKHEwSxEZCvzcbZuvk=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/image v0.0.0-20200430140353-33d19683fad8 h1:6WW6V3x1P/jokJBpRQYUJnMHRP6isStQwCozxnU7XQw=
+golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190509222800-a4d6f7feada5 h1:6M3SDHlHHDCx2PcQw3S4KsR170vGqDhJDOmpVd4Hjak=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4=
-golang.org/x/net v0.0.0-20190509222800-a4d6f7feada5/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/sys v0.0.0-20180606202747-9527bec2660b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181228144115-9a3f9b0469bb/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190509141414-a5b02f93d862 h1:rM0ROo5vb9AdYJi1110yjWGMej9ITfKddS89P3Fkhug=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
-golang.org/x/sys v0.0.0-20190509141414-a5b02f93d862/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/AlecAivazis/survey.v1 v1.8.4 h1:10xXXN3wgIhPheb5NI58zFgZv32Ana7P3Tl4shW+0Qc=

lib/binding/manager.go

@@ -2,7 +2,11 @@ package binding
 
 import (
 	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
 	"reflect"
+	"strings"
 	"unicode"
 
 	"github.com/wailsapp/wails/lib/interfaces"
@@ -10,6 +14,8 @@ import (
 	"github.com/wailsapp/wails/lib/messages"
 )
 
+var typescriptDefinitionFilename = ""
+
 // Manager handles method binding
 type Manager struct {
 	methods          map[string]*boundMethod
@@ -21,16 +27,19 @@ type Manager struct {
 	renderer         interfaces.Renderer
 	runtime          interfaces.Runtime // The runtime object to pass to bound structs
 	objectsToBind    []interface{}
-	bindPackageNames bool // Package name should be considered when binding
+	bindPackageNames bool                // Package name should be considered when binding
+	structList       map[string][]string // structList["mystruct"] = []string{"Method1", "Method2"}
 }
 
 // NewManager creates a new Manager struct
 func NewManager() interfaces.BindingManager {
+
 	result := &Manager{
 		methods:         make(map[string]*boundMethod),
 		functions:       make(map[string]*boundFunction),
 		log:             logger.NewCustomLogger("Bind"),
 		internalMethods: newInternalMethods(),
+		structList:      make(map[string][]string),
 	}
 	return result
 }
@@ -88,9 +97,55 @@ func (b *Manager) initialise() error {
 			return err
 		}
 	}
+
+	// If we wish to generate a typescript definition file...
+	if typescriptDefinitionFilename != "" {
+		err := b.generateTypescriptDefinitions()
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
+// Generate typescript
+func (b *Manager) generateTypescriptDefinitions() error {
+
+	var output strings.Builder
+
+	for structname, methodList := range b.structList {
+		structname = strings.SplitN(structname, ".", 2)[1]
+		output.WriteString(fmt.Sprintf("Interface %s {\n", structname))
+		for _, method := range methodList {
+			output.WriteString(fmt.Sprintf("\t%s: (...args : any[]) => Promise\n", method))
+		}
+		output.WriteString("}\n")
+	}
+
+	output.WriteString("\n")
+	output.WriteString("Interface Backend {\n")
+
+	for structname := range b.structList {
+		structname = strings.SplitN(structname, ".", 2)[1]
+		output.WriteString(fmt.Sprintf("\t%[1]s: %[1]s\n", structname))
+	}
+	output.WriteString("}\n")
+
+	globals := `
+declare global {
+	interface Window {
+		backend: Backend;
+	}
+}`
+	output.WriteString(globals)
+
+	b.log.Info("Written Typescript file: " + typescriptDefinitionFilename)
+
+	dir := filepath.Dir(typescriptDefinitionFilename)
+	os.MkdirAll(dir, 0755)
+	return ioutil.WriteFile(typescriptDefinitionFilename, []byte(output.String()), 0755)
+}
+
 // bind the given struct method
 func (b *Manager) bindMethod(object interface{}) error {
 
@@ -104,6 +159,12 @@ func (b *Manager) bindMethod(object interface{}) error {
 
 	b.log.Debugf("Processing struct: %s", baseName)
 
+	// Calc actual name
+	actualName := strings.TrimPrefix(baseName, "main.")
+	if b.structList[actualName] == nil {
+		b.structList[actualName] = []string{}
+	}
+
 	// Iterate over method definitions
 	for i := 0; i < objectType.NumMethod(); i++ {
 
@@ -113,6 +174,8 @@ func (b *Manager) bindMethod(object interface{}) error {
 		fullMethodName := baseName + "." + methodName
 		method := reflect.ValueOf(object).MethodByName(methodName)
 
+		b.structList[actualName] = append(b.structList[actualName], methodName)
+
 		// Skip unexported methods
 		if !unicode.IsUpper([]rune(methodName)[0]) {
 			continue

lib/binding/method.go

@@ -196,7 +196,7 @@ func (b *boundMethod) processWailsInit() error {
 	// It must be *wails.Runtime
 	inputName := b.inputs[0].String()
 	b.log.Debugf("WailsInit input type: %s", inputName)
-	if inputName != "*wails.Runtime" {
+	if inputName != "*runtime.Runtime" {
 		return fmt.Errorf("Invalid WailsInit() definition. Expected input to be wails.Runtime, but got %s", inputName)
 	}
 
@@ -219,7 +219,7 @@ func (b *boundMethod) processWailsInit() error {
 }
 
 func (b *boundMethod) processWailsShutdown() error {
-	// We must have only 1 input, it must be *wails.Runtime
+	// We must not have any inputs
 	if len(b.inputs) != 0 {
 		return fmt.Errorf("Invalid WailsShutdown() definition. Expected 0 inputs, but got %d", len(b.inputs))
 	}

lib/event/manager.go

@@ -3,7 +3,6 @@ package event
 import (
 	"fmt"
 	"sync"
-	"time"
 
 	"github.com/wailsapp/wails/lib/interfaces"
 	"github.com/wailsapp/wails/lib/logger"
@@ -13,6 +12,7 @@ import (
 // Manager handles and processes events
 type Manager struct {
 	incomingEvents chan *messages.EventData
+	quitChannel    chan struct{}
 	listeners      map[string][]*eventListener
 	running        bool
 	log            *logger.CustomLogger
@@ -24,6 +24,7 @@ type Manager struct {
 func NewManager() interfaces.EventManager {
 	return &Manager{
 		incomingEvents: make(chan *messages.EventData, 100),
+		quitChannel:    make(chan struct{}, 1),
 		listeners:      make(map[string][]*eventListener),
 		running:        false,
 		log:            logger.NewCustomLogger("Events"),
@@ -141,8 +142,8 @@ func (e *Manager) Start(renderer interfaces.Renderer) {
 						}
 					}
 				}
-			default:
+			case <-e.quitChannel:
-				time.Sleep(1 * time.Millisecond)
+				e.running = false
 			}
 		}
 		e.wg.Done()
@@ -152,7 +153,7 @@ func (e *Manager) Start(renderer interfaces.Renderer) {
 // Shutdown is called when exiting the Application
 func (e *Manager) Shutdown() {
 	e.log.Debug("Shutting Down")
-	e.running = false
+	e.quitChannel <- struct{}{}
 	e.log.Debug("Waiting for main loop to exit")
 	e.wg.Wait()
 }

lib/interfaces/ipcmanager.go

@@ -1,9 +1,13 @@
 package interfaces
 
+// CallbackFunc defines the signature of a function required to be provided to the
+// Dispatch function so that the response may be returned
+type CallbackFunc func(string) error
+
 // IPCManager is the event manager interface
 type IPCManager interface {
 	BindRenderer(Renderer)
-	Dispatch(message string)
+	Dispatch(message string, f CallbackFunc)
 	Start(eventManager EventManager, bindingManager BindingManager)
 	Shutdown()
 }

lib/interfaces/renderer.go

@@ -3,22 +3,23 @@ package interfaces
 import (
 	"github.com/wailsapp/wails/lib/messages"
 )
+
 // Renderer is an interface describing a Wails target to render the app to
 type Renderer interface {
 	Initialise(AppConfig, IPCManager, EventManager) error
 	Run() error
+	EnableConsole()
 
 	// Binding
 	NewBinding(bindingName string) error
-	Callback(data string) error
 
 	// Events
 	NotifyEvent(eventData *messages.EventData) error
 
 	// Dialog Runtime
-	SelectFile() string
+	SelectFile(title string, filter string) string
 	SelectDirectory() string
-	SelectSaveFile() string
+	SelectSaveFile(title string, filter string) string
 
 	// Window Runtime
 	SetColour(string) error

lib/ipc/manager.go

@@ -3,7 +3,6 @@ package ipc
 import (
 	"fmt"
 	"sync"
-	"time"
 
 	"github.com/wailsapp/wails/lib/interfaces"
 	"github.com/wailsapp/wails/lib/logger"
@@ -124,8 +123,8 @@ func (i *Manager) Start(eventManager interfaces.EventManager, bindingManager int
 				i.log.DebugFields("Finished processing message", logger.Fields{
 					"1D": &incomingMessage,
 				})
-			default:
+			case <-i.quitChannel:
-				time.Sleep(1 * time.Millisecond)
+				i.running = false
 			}
 		}
 		i.log.Debug("Stopping")
@@ -136,10 +135,10 @@ func (i *Manager) Start(eventManager interfaces.EventManager, bindingManager int
 // Dispatch receives JSON encoded messages from the renderer.
 // It processes the message to ensure that it is valid and places
 // the processed message on the message queue
-func (i *Manager) Dispatch(message string) {
+func (i *Manager) Dispatch(message string, cb interfaces.CallbackFunc) {
 
 	// Create a new IPC Message
-	incomingMessage, err := newIPCMessage(message, i.SendResponse)
+	incomingMessage, err := newIPCMessage(message, i.SendResponse(cb))
 	if err != nil {
 		i.log.ErrorFields("Could not understand incoming message! ", map[string]interface{}{
 			"message": message,
@@ -159,23 +158,25 @@ func (i *Manager) Dispatch(message string) {
 }
 
 // SendResponse sends the given response back to the frontend
-func (i *Manager) SendResponse(response *ipcResponse) error {
+// It sends the data back to the correct renderer by way of the provided callback function
+func (i *Manager) SendResponse(cb interfaces.CallbackFunc) func(i *ipcResponse) error {
 
-	// Serialise the Message
+	return func(response *ipcResponse) error {
-	data, err := response.Serialise()
+		// Serialise the Message
-	if err != nil {
+		data, err := response.Serialise()
-		fmt.Printf(err.Error())
+		if err != nil {
-		return err
+			fmt.Printf(err.Error())
+			return err
+		}
+		return cb(data)
 	}
 
-	// Call back to the front end
-	return i.renderer.Callback(data)
 }
 
 // Shutdown is called when exiting the Application
 func (i *Manager) Shutdown() {
 	i.log.Debug("Shutdown called")
-	i.running = false
+	i.quitChannel <- struct{}{}
 	i.log.Debug("Waiting of main loop shutdown")
 	i.wg.Wait()
 }

lib/renderer/bridge.go

@@ -1,258 +1,10 @@
 package renderer
 
 import (
-	"encoding/json"
+	bridge "github.com/wailsapp/wails/lib/renderer/bridge"
-	"fmt"
-	"net/http"
-	"strings"
-	"sync"
-
-	"github.com/dchest/htmlmin"
-	"github.com/gorilla/websocket"
-	"github.com/leaanthony/mewn"
-	"github.com/wailsapp/wails/lib/interfaces"
-	"github.com/wailsapp/wails/lib/logger"
-	"github.com/wailsapp/wails/lib/messages"
 )
 
-type messageType int
+// NewBridge returns a new Bridge struct
-
+func NewBridge() *bridge.Bridge {
-const (
+	return &bridge.Bridge{}
-	jsMessage messageType = iota
-	cssMessage
-	htmlMessage
-	notifyMessage
-	bindingMessage
-	callbackMessage
-	wailsRuntimeMessage
-)
-
-func (m messageType) toString() string {
-	return [...]string{"j", "s", "h", "n", "b", "c", "w"}[m]
-}
-
-// Bridge is a backend that opens a local web server
-// and renders the files over a websocket
-type Bridge struct {
-	// Common
-	log          *logger.CustomLogger
-	ipcManager   interfaces.IPCManager
-	appConfig    interfaces.AppConfig
-	eventManager interfaces.EventManager
-	bindingCache []string
-
-	// Bridge specific
-	initialisationJS []string
-	server           *http.Server
-	theConnection    *websocket.Conn
-
-	// Mutex for writing to the socket
-	lock sync.Mutex
-}
-
-// Initialise the Bridge Renderer
-func (h *Bridge) Initialise(appConfig interfaces.AppConfig, ipcManager interfaces.IPCManager, eventManager interfaces.EventManager) error {
-	h.ipcManager = ipcManager
-	h.appConfig = appConfig
-	h.eventManager = eventManager
-	ipcManager.BindRenderer(h)
-	h.log = logger.NewCustomLogger("Bridge")
-	return nil
-}
-
-func (h *Bridge) evalJS(js string, mtype messageType) error {
-
-	message := mtype.toString() + js
-
-	if h.theConnection == nil {
-		h.initialisationJS = append(h.initialisationJS, message)
-	} else {
-		// Prepend message type to message
-		h.sendMessage(h.theConnection, message)
-	}
-
-	return nil
-}
-
-func (h *Bridge) injectCSS(css string) {
-	// Minify css to overcome issues in the browser with carriage returns
-	minified, err := htmlmin.Minify([]byte(css), &htmlmin.Options{
-		MinifyStyles: true,
-	})
-	if err != nil {
-		h.log.Fatal("Unable to minify CSS: " + css)
-	}
-	minifiedCSS := string(minified)
-	minifiedCSS = strings.Replace(minifiedCSS, "\\", "\\\\", -1)
-	minifiedCSS = strings.Replace(minifiedCSS, "'", "\\'", -1)
-	minifiedCSS = strings.Replace(minifiedCSS, "\n", " ", -1)
-	inject := fmt.Sprintf("wails._.InjectCSS('%s')", minifiedCSS)
-	h.evalJS(inject, cssMessage)
-}
-
-func (h *Bridge) wsBridgeHandler(w http.ResponseWriter, r *http.Request) {
-	conn, err := websocket.Upgrade(w, r, w.Header(), 1024, 1024)
-	if err != nil {
-		http.Error(w, "Could not open websocket connection", http.StatusBadRequest)
-	}
-	h.theConnection = conn
-	h.log.Infof("Connection from frontend accepted [%p].", h.theConnection)
-	conn.SetCloseHandler(func(int, string) error {
-		h.log.Infof("Connection dropped [%p].", h.theConnection)
-		h.theConnection = nil
-		return nil
-	})
-	go h.start(conn)
-}
-
-func (h *Bridge) sendMessage(conn *websocket.Conn, msg string) {
-
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	if err := conn.WriteMessage(websocket.TextMessage, []byte(msg)); err != nil {
-		h.log.Error(err.Error())
-	}
-}
-
-func (h *Bridge) start(conn *websocket.Conn) {
-
-	// set external.invoke
-	h.log.Infof("Connected to frontend.")
-
-	wailsRuntime := mewn.String("../../runtime/assets/wails.js")
-	h.evalJS(wailsRuntime, wailsRuntimeMessage)
-
-	// Inject bindings
-	for _, binding := range h.bindingCache {
-		h.evalJS(binding, bindingMessage)
-	}
-
-	// Emit that everything is loaded and ready
-	h.eventManager.Emit("wails:ready")
-
-	for {
-		messageType, buffer, err := conn.ReadMessage()
-		if messageType == -1 {
-			return
-		}
-		if err != nil {
-			h.log.Errorf("Error reading message: ", err)
-			continue
-		}
-
-		h.log.Debugf("Got message: %#v\n", string(buffer))
-
-		h.ipcManager.Dispatch(string(buffer))
-	}
-}
-
-// Run the app in Bridge mode!
-func (h *Bridge) Run() error {
-	h.server = &http.Server{Addr: ":34115"}
-	http.HandleFunc("/bridge", h.wsBridgeHandler)
-
-	h.log.Info("Bridge mode started.")
-	h.log.Info("The frontend will connect automatically.")
-
-	err := h.server.ListenAndServe()
-	if err != nil && err != http.ErrServerClosed {
-		h.log.Fatal(err.Error())
-	}
-	return err
-}
-
-// NewBinding creates a new binding with the frontend
-func (h *Bridge) NewBinding(methodName string) error {
-	h.bindingCache = append(h.bindingCache, methodName)
-	return nil
-}
-
-// SelectFile is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) SelectFile() string {
-	h.log.Warn("SelectFile() unsupported in bridge mode")
-	return ""
-}
-
-// SelectDirectory is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) SelectDirectory() string {
-	h.log.Warn("SelectDirectory() unsupported in bridge mode")
-	return ""
-}
-
-// SelectSaveFile is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) SelectSaveFile() string {
-	h.log.Warn("SelectSaveFile() unsupported in bridge mode")
-	return ""
-}
-
-// Callback sends a callback to the frontend
-func (h *Bridge) Callback(data string) error {
-	return h.evalJS(data, callbackMessage)
-}
-
-// NotifyEvent notifies the frontend of an event
-func (h *Bridge) NotifyEvent(event *messages.EventData) error {
-
-	// Look out! Nils about!
-	var err error
-	if event == nil {
-		err = fmt.Errorf("Sent nil event to renderer.webViewRenderer")
-		h.log.Error(err.Error())
-		return err
-	}
-
-	// Default data is a blank array
-	data := []byte("[]")
-
-	// Process event data
-	if event.Data != nil {
-		// Marshall the data
-		data, err = json.Marshal(event.Data)
-		if err != nil {
-			h.log.Errorf("Cannot unmarshall JSON data in event: %s ", err.Error())
-			return err
-		}
-	}
-
-	message := fmt.Sprintf("window.wails._.Notify('%s','%s')", event.Name, data)
-	return h.evalJS(message, notifyMessage)
-}
-
-// SetColour is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) SetColour(colour string) error {
-	h.log.WarnFields("SetColour ignored for Bridge more", logger.Fields{"col": colour})
-	return nil
-}
-
-// Fullscreen is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) Fullscreen() {
-	h.log.Warn("Fullscreen() unsupported in bridge mode")
-}
-
-// UnFullscreen is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) UnFullscreen() {
-	h.log.Warn("UnFullscreen() unsupported in bridge mode")
-}
-
-// SetTitle is currently unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) SetTitle(title string) {
-	h.log.WarnFields("SetTitle() unsupported in bridge mode", logger.Fields{"title": title})
-}
-
-// Close is unsupported for Bridge but required
-// for the Renderer interface
-func (h *Bridge) Close() {
-	h.log.Debug("Shutting down")
-	err := h.server.Close()
-	if err != nil {
-		h.log.Errorf(err.Error())
-	}
 }

lib/renderer/bridge/bridge.go

@@ -0,0 +1,222 @@
+package renderer
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sync"
+
+	"github.com/gorilla/websocket"
+	"github.com/wailsapp/wails/lib/interfaces"
+	"github.com/wailsapp/wails/lib/logger"
+	"github.com/wailsapp/wails/lib/messages"
+)
+
+type messageType int
+
+const (
+	jsMessage messageType = iota
+	cssMessage
+	htmlMessage
+	notifyMessage
+	bindingMessage
+	callbackMessage
+	wailsRuntimeMessage
+)
+
+func (m messageType) toString() string {
+	return [...]string{"j", "s", "h", "n", "b", "c", "w"}[m]
+}
+
+// Bridge is a backend that opens a local web server
+// and renders the files over a websocket
+type Bridge struct {
+	// Common
+	log          *logger.CustomLogger
+	ipcManager   interfaces.IPCManager
+	appConfig    interfaces.AppConfig
+	eventManager interfaces.EventManager
+	bindingCache []string
+
+	// Bridge specific
+	server *http.Server
+
+	lock     sync.Mutex
+	sessions map[string]*session
+}
+
+// Initialise the Bridge Renderer
+func (h *Bridge) Initialise(appConfig interfaces.AppConfig, ipcManager interfaces.IPCManager, eventManager interfaces.EventManager) error {
+	h.sessions = map[string]*session{}
+	h.ipcManager = ipcManager
+	h.appConfig = appConfig
+	h.eventManager = eventManager
+	ipcManager.BindRenderer(h)
+	h.log = logger.NewCustomLogger("Bridge")
+	return nil
+}
+
+// EnableConsole not needed for bridge!
+func (h *Bridge) EnableConsole() {
+}
+
+func (h *Bridge) wsBridgeHandler(w http.ResponseWriter, r *http.Request) {
+	conn, err := websocket.Upgrade(w, r, w.Header(), 1024, 1024)
+	if err != nil {
+		http.Error(w, "Could not open websocket connection", http.StatusBadRequest)
+	}
+	h.log.Infof("Connection from frontend accepted [%s].", conn.RemoteAddr().String())
+	h.startSession(conn)
+}
+
+func (h *Bridge) startSession(conn *websocket.Conn) {
+	s := newSession(conn,
+		h.bindingCache,
+		h.ipcManager,
+		logger.NewCustomLogger("BridgeSession"),
+		h.eventManager)
+
+	conn.SetCloseHandler(func(int, string) error {
+		h.log.Infof("Connection dropped [%s].", s.Identifier())
+		h.eventManager.Emit("wails:bridge:session:closed", s.Identifier())
+		h.lock.Lock()
+		defer h.lock.Unlock()
+		delete(h.sessions, s.Identifier())
+		return nil
+	})
+
+	h.lock.Lock()
+	defer h.lock.Unlock()
+	go s.start(len(h.sessions) == 0)
+	h.sessions[s.Identifier()] = s
+}
+
+// Run the app in Bridge mode!
+func (h *Bridge) Run() error {
+	h.server = &http.Server{Addr: ":34115"}
+	http.HandleFunc("/bridge", h.wsBridgeHandler)
+
+	h.log.Info("Bridge mode started.")
+	h.log.Info("The frontend will connect automatically.")
+
+	err := h.server.ListenAndServe()
+	if err != nil && err != http.ErrServerClosed {
+		h.log.Fatal(err.Error())
+	}
+	return err
+}
+
+// NewBinding creates a new binding with the frontend
+func (h *Bridge) NewBinding(methodName string) error {
+	h.bindingCache = append(h.bindingCache, methodName)
+	return nil
+}
+
+// SelectFile is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) SelectFile(title string, filter string) string {
+	h.log.Warn("SelectFile() unsupported in bridge mode")
+	return ""
+}
+
+// SelectDirectory is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) SelectDirectory() string {
+	h.log.Warn("SelectDirectory() unsupported in bridge mode")
+	return ""
+}
+
+// SelectSaveFile is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) SelectSaveFile(title string, filter string) string {
+	h.log.Warn("SelectSaveFile() unsupported in bridge mode")
+	return ""
+}
+
+// NotifyEvent notifies the frontend of an event
+func (h *Bridge) NotifyEvent(event *messages.EventData) error {
+
+	// Look out! Nils about!
+	var err error
+	if event == nil {
+		err = fmt.Errorf("Sent nil event to renderer.webViewRenderer")
+		h.log.Error(err.Error())
+		return err
+	}
+
+	// Default data is a blank array
+	data := []byte("[]")
+
+	// Process event data
+	if event.Data != nil {
+		// Marshall the data
+		data, err = json.Marshal(event.Data)
+		if err != nil {
+			h.log.Errorf("Cannot marshal JSON data in event: %s ", err.Error())
+			return err
+		}
+	}
+
+	// Double encode data to ensure everything is escaped correctly.
+	data, err = json.Marshal(string(data))
+	if err != nil {
+		h.log.Errorf("Cannot marshal JSON data in event: %s ", err.Error())
+		return err
+	}
+
+	message := "window.wails._.Notify('" + event.Name + "'," + string(data) + ")"
+	dead := []*session{}
+	for _, session := range h.sessions {
+		err := session.evalJS(message, notifyMessage)
+		if err != nil {
+			h.log.Debugf("Failed to send message to %s - Removing listener : %v", session.Identifier(), err)
+			h.log.Infof("Connection from [%v] unresponsive - dropping", session.Identifier())
+			dead = append(dead, session)
+		}
+	}
+	h.lock.Lock()
+	defer h.lock.Unlock()
+	for _, session := range dead {
+		delete(h.sessions, session.Identifier())
+	}
+
+	return nil
+}
+
+// SetColour is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) SetColour(colour string) error {
+	h.log.WarnFields("SetColour ignored for Bridge more", logger.Fields{"col": colour})
+	return nil
+}
+
+// Fullscreen is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) Fullscreen() {
+	h.log.Warn("Fullscreen() unsupported in bridge mode")
+}
+
+// UnFullscreen is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) UnFullscreen() {
+	h.log.Warn("UnFullscreen() unsupported in bridge mode")
+}
+
+// SetTitle is currently unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) SetTitle(title string) {
+	h.log.WarnFields("SetTitle() unsupported in bridge mode", logger.Fields{"title": title})
+}
+
+// Close is unsupported for Bridge but required
+// for the Renderer interface
+func (h *Bridge) Close() {
+	h.log.Debug("Shutting down")
+	for _, session := range h.sessions {
+		session.Shutdown()
+	}
+	err := h.server.Close()
+	if err != nil {
+		h.log.Errorf(err.Error())
+	}
+}

lib/renderer/bridge/renderer-mewn.go

@@ -0,0 +1,9 @@
+package renderer
+
+// Autogenerated by Mewn - Do not alter
+
+import "github.com/leaanthony/mewn"
+
+func init() {
+  mewn.AddAsset(".", "../../runtime/assets/wails.js", "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")
+}

lib/renderer/bridge/session.go

@@ -0,0 +1,136 @@
+package renderer
+
+import (
+	"time"
+	"unsafe"
+
+	"github.com/gorilla/websocket"
+	"github.com/leaanthony/mewn"
+	"github.com/wailsapp/wails/lib/interfaces"
+	"github.com/wailsapp/wails/lib/logger"
+)
+
+// TODO Move this back into bridge.go
+
+// session represents a single websocket session
+type session struct {
+	bindingCache []string
+	conn         *websocket.Conn
+	eventManager interfaces.EventManager
+	log          *logger.CustomLogger
+	ipc          interfaces.IPCManager
+
+	// Mutex for writing to the socket
+	shutdown  chan bool
+	writeChan chan []byte
+
+	done bool
+}
+
+func newSession(conn *websocket.Conn, bindingCache []string, ipc interfaces.IPCManager, logger *logger.CustomLogger, eventMgr interfaces.EventManager) *session {
+	return &session{
+		conn:         conn,
+		bindingCache: bindingCache,
+		ipc:          ipc,
+		log:          logger,
+		eventManager: eventMgr,
+		shutdown:     make(chan bool),
+		writeChan:    make(chan []byte, 100),
+	}
+}
+
+// Identifier returns a string identifier for the remote connection.
+// Taking the form of the client's <ip address>:<port>.
+func (s *session) Identifier() string {
+	if s.conn != nil {
+		return s.conn.RemoteAddr().String()
+	}
+	return ""
+}
+
+func (s *session) sendMessage(msg string) error {
+	if !s.done {
+		s.writeChan <- *(*[]byte)(unsafe.Pointer(&msg))
+	}
+	return nil
+}
+
+func (s *session) start(firstSession bool) {
+	s.log.Infof("Connected to frontend.")
+	go s.writePump()
+
+	wailsRuntime := mewn.String("../../runtime/assets/wails.js")
+	s.evalJS(wailsRuntime, wailsRuntimeMessage)
+
+	// Inject bindings
+	for _, binding := range s.bindingCache {
+		s.evalJS(binding, bindingMessage)
+	}
+	s.eventManager.Emit("wails:bridge:session:started", s.Identifier())
+
+	// Emit that everything is loaded and ready
+	if firstSession {
+		s.eventManager.Emit("wails:ready")
+	}
+
+	for {
+		messageType, buffer, err := s.conn.ReadMessage()
+		if messageType == -1 {
+			return
+		}
+		if err != nil {
+			s.log.Errorf("Error reading message: %v", err)
+			continue
+		}
+
+		s.log.Debugf("Got message: %#v\n", string(buffer))
+
+		s.ipc.Dispatch(string(buffer), s.Callback)
+
+		if s.done {
+			break
+		}
+	}
+}
+
+// Callback sends a callback to the frontend
+func (s *session) Callback(data string) error {
+	return s.evalJS(data, callbackMessage)
+}
+
+func (s *session) evalJS(js string, mtype messageType) error {
+	// Prepend message type to message
+	return s.sendMessage(mtype.toString() + js)
+}
+
+// Shutdown
+func (s *session) Shutdown() {
+	s.done = true
+	s.shutdown <- true
+	s.log.Debugf("session %v exit", s.Identifier())
+}
+
+// writePump pulls messages from the writeChan and sends them to the client
+// since it uses a channel to read the messages the socket is protected without locks
+func (s *session) writePump() {
+	s.log.Debugf("Session %v - writePump start", s.Identifier())
+	for {
+		select {
+		case msg, ok := <-s.writeChan:
+			s.conn.SetWriteDeadline(time.Now().Add(1 * time.Second))
+			if !ok {
+				s.log.Debug("writeChan was closed!")
+				s.conn.WriteMessage(websocket.CloseMessage, []byte{})
+				return
+			}
+
+			if err := s.conn.WriteMessage(websocket.TextMessage, msg); err != nil {
+				s.log.Debug(err.Error())
+				return
+			}
+		case <-s.shutdown:
+			break
+		}
+	}
+	s.log.Debug("writePump exiting...")
+}

lib/renderer/webview.go

@@ -19,12 +19,13 @@ import (
 // WebView defines the main webview application window
 // Default values in []
 type WebView struct {
-	window       wv.WebView // The webview object
+	window        wv.WebView // The webview object
-	ipc          interfaces.IPCManager
+	ipc           interfaces.IPCManager
-	log          *logger.CustomLogger
+	log           *logger.CustomLogger
-	config       interfaces.AppConfig
+	config        interfaces.AppConfig
-	eventManager interfaces.EventManager
+	eventManager  interfaces.EventManager
-	bindingCache []string
+	bindingCache  []string
+	enableConsole bool
 }
 
 // NewWebView returns a new WebView struct
@@ -57,7 +58,7 @@ func (w *WebView) Initialise(config interfaces.AppConfig, ipc interfaces.IPCMana
 		URL:       config.GetDefaultHTML(),
 		Debug:     !config.GetDisableInspector(),
 		ExternalInvokeCallback: func(_ wv.WebView, message string) {
-			w.ipc.Dispatch(message)
+			w.ipc.Dispatch(message, w.callback)
 		},
 	})
 
@@ -103,6 +104,11 @@ func (w *WebView) evalJS(js string) error {
 	return nil
 }
 
+// EnableConsole enables the console!
+func (w *WebView) EnableConsole() {
+	w.enableConsole = true
+}
+
 // Escape the Javascripts!
 func escapeJS(js string) (string, error) {
 	result := strings.Replace(js, "\\", "\\\\", -1)
@@ -172,6 +178,13 @@ func (w *WebView) Run() error {
 
 	w.log.Info("Running...")
 
+	// Inject firebug in debug mode on Windows
+	if w.enableConsole {
+		w.log.Debug("Enabling Wails console")
+		console := mewn.String("../../runtime/assets/console.js")
+		w.evalJS(console)
+	}
+
 	// Runtime assets
 	wailsRuntime := mewn.String("../../runtime/assets/wails.js")
 	w.evalJS(wailsRuntime)
@@ -232,7 +245,7 @@ func (w *WebView) NewBinding(methodName string) error {
 }
 
 // SelectFile opens a dialog that allows the user to select a file
-func (w *WebView) SelectFile() string {
+func (w *WebView) SelectFile(title string, filter string) string {
 	var result string
 
 	// We need to run this on the main thread, however Dispatch is
@@ -242,7 +255,7 @@ func (w *WebView) SelectFile() string {
 	wg.Add(1)
 	go func() {
 		w.window.Dispatch(func() {
-			result = w.window.Dialog(wv.DialogTypeOpen, 0, "Select File", "")
+			result = w.window.Dialog(wv.DialogTypeOpen, 0, title, "", filter)
 			wg.Done()
 		})
 	}()
@@ -260,7 +273,7 @@ func (w *WebView) SelectDirectory() string {
 	wg.Add(1)
 	go func() {
 		w.window.Dispatch(func() {
-			result = w.window.Dialog(wv.DialogTypeOpen, wv.DialogFlagDirectory, "Select Directory", "")
+			result = w.window.Dialog(wv.DialogTypeOpen, wv.DialogFlagDirectory, "Select Directory", "", "")
 			wg.Done()
 		})
 	}()
@@ -269,7 +282,7 @@ func (w *WebView) SelectDirectory() string {
 }
 
 // SelectSaveFile opens a dialog that allows the user to select a file to save
-func (w *WebView) SelectSaveFile() string {
+func (w *WebView) SelectSaveFile(title string, filter string) string {
 	var result string
 	// We need to run this on the main thread, however Dispatch is
 	// non-blocking so we launch this in a goroutine and wait for
@@ -278,7 +291,7 @@ func (w *WebView) SelectSaveFile() string {
 	wg.Add(1)
 	go func() {
 		w.window.Dispatch(func() {
-			result = w.window.Dialog(wv.DialogTypeSave, 0, "Save file", "")
+			result = w.window.Dialog(wv.DialogTypeSave, 0, title, "", filter)
 			wg.Done()
 		})
 	}()
@@ -286,8 +299,8 @@ func (w *WebView) SelectSaveFile() string {
 	return result
 }
 
-// Callback sends a callback to the frontend
+// callback sends a callback to the frontend
-func (w *WebView) Callback(data string) error {
+func (w *WebView) callback(data string) error {
 	callbackCMD := fmt.Sprintf("window.wails._.Callback('%s');", data)
 	return w.evalJS(callbackCMD)
 }
@@ -316,7 +329,14 @@ func (w *WebView) NotifyEvent(event *messages.EventData) error {
 		}
 	}
 
-	message := fmt.Sprintf("wails._.Notify('%s','%s')", event.Name, data)
+	// Double encode data to ensure everything is escaped correctly.
+	data, err = json.Marshal(string(data))
+	if err != nil {
+		w.log.Errorf("Cannot marshal JSON data in event: %s ", err.Error())
+		return err
+	}
+
+	message := "window.wails._.Notify('" + event.Name + "'," + string(data) + ")"
 	return w.evalJS(message)
 }
 

lib/renderer/webview/webview.go

@@ -74,9 +74,9 @@ static inline void CgoWebViewSetColor(void *w, uint8_t r, uint8_t g, uint8_t b,
 }
 
 static inline void CgoDialog(void *w, int dlgtype, int flags,
-		char *title, char *arg, char *res, size_t ressz) {
+char *title, char *arg, char *res, size_t ressz, char *filter) {
 	webview_dialog(w, dlgtype, flags,
-		(const char*)title, (const char*) arg, res, ressz);
+	(const char*)title, (const char*) arg, res, ressz, filter);
 }
 
 static inline int CgoWebViewEval(void *w, char *js) {
@@ -186,7 +186,7 @@ type WebView interface {
 	// Dialog() opens a system dialog of the given type and title. String
 	// argument can be provided for certain dialogs, such as alert boxes. For
 	// alert boxes argument is a message inside the dialog box.
-	Dialog(dlgType DialogType, flags int, title string, arg string) string
+	Dialog(dlgType DialogType, flags int, title string, arg string, filter string) string
 	// Terminate() breaks the main UI loop. This method must be called from the main thread
 	// only. See Dispatch() for more details.
 	Terminate()
@@ -311,7 +311,7 @@ func (w *webview) SetFullscreen(fullscreen bool) {
 	C.CgoWebViewSetFullscreen(w.w, C.int(boolToInt(fullscreen)))
 }
 
-func (w *webview) Dialog(dlgType DialogType, flags int, title string, arg string) string {
+func (w *webview) Dialog(dlgType DialogType, flags int, title string, arg string, filter string) string {
 	const maxPath = 4096
 	titlePtr := C.CString(title)
 	defer C.free(unsafe.Pointer(titlePtr))
@@ -319,8 +319,10 @@ func (w *webview) Dialog(dlgType DialogType, flags int, title string, arg string
 	defer C.free(unsafe.Pointer(argPtr))
 	resultPtr := (*C.char)(C.calloc((C.size_t)(unsafe.Sizeof((*C.char)(nil))), (C.size_t)(maxPath)))
 	defer C.free(unsafe.Pointer(resultPtr))
+	filterPtr := C.CString(filter)
+	defer C.free(unsafe.Pointer(filterPtr))
 	C.CgoDialog(w.w, C.int(dlgType), C.int(flags), titlePtr,
-		argPtr, resultPtr, C.size_t(maxPath))
+		argPtr, resultPtr, C.size_t(maxPath), filterPtr)
 	return C.GoString(resultPtr)
 }
 

lib/renderer/webview/webview.h

@@ -139,7 +139,7 @@ struct webview_priv
 #define DEFAULT_URL                                                            \
   "data:text/"                                                                 \
   "html,%3C%21DOCTYPE%20html%3E%0A%3Chtml%20lang=%22en%22%3E%0A%3Chead%3E%"    \
-  "3Cmeta%20charset=%22utf-8%22%3E%3Cmeta%20http-equiv=%22IE=edge%22%" \
+  "3Cmeta%20charset=%22utf-8%22%3E%3Cmeta%20http-equiv=%22IE=edge%22%"         \
   "20content=%22IE=edge%22%3E%3C%2Fhead%3E%0A%3Cbody%3E%3Cdiv%20id=%22app%22%" \
   "3E%3C%2Fdiv%3E%3Cscript%20type=%22text%2Fjavascript%22%3E%3C%2Fscript%3E%"  \
   "3C%2Fbody%3E%0A%3C%2Fhtml%3E"
@@ -174,7 +174,7 @@ struct webview_priv
   WEBVIEW_API void webview_dialog(struct webview *w,
                                   enum webview_dialog_type dlgtype, int flags,
                                   const char *title, const char *arg,
-                                  char *result, size_t resultsz);
+                                  char *result, size_t resultsz, char *filter);
   WEBVIEW_API void webview_dispatch(struct webview *w, webview_dispatch_fn fn,
                                     void *arg);
   WEBVIEW_API void webview_terminate(struct webview *w);
@@ -418,7 +418,7 @@ struct webview_priv
   WEBVIEW_API void webview_dialog(struct webview *w,
                                   enum webview_dialog_type dlgtype, int flags,
                                   const char *title, const char *arg,
-                                  char *result, size_t resultsz)
+                                  char *result, size_t resultsz, char *filter)
   {
     GtkWidget *dlg;
     if (result != NULL)
@@ -438,6 +438,17 @@ struct webview_priv
           "_Cancel", GTK_RESPONSE_CANCEL,
           (dlgtype == WEBVIEW_DIALOG_TYPE_OPEN ? "_Open" : "_Save"),
           GTK_RESPONSE_ACCEPT, NULL);
+      if (filter[0] != '\0') {
+          GtkFileFilter *file_filter = gtk_file_filter_new();
+          gchar **filters  = g_strsplit(filter, ",", -1);
+          gint i;
+          for(i = 0; filters && filters[i]; i++) {
+              gtk_file_filter_add_pattern(file_filter, filters[i]);
+          }
+          gtk_file_filter_set_name(file_filter, filter);
+          gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg), file_filter);
+          g_strfreev(filters);
+      }
       gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dlg), FALSE);
       gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dlg), FALSE);
       gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dlg), TRUE);
@@ -1227,7 +1238,7 @@ struct webview_priv
       }
       VariantInit(&myURL);
       myURL.vt = VT_BSTR;
-// #ifndef UNICODE
+      // #ifndef UNICODE
       {
         wchar_t *buffer = webview_to_utf16(webPageName);
         if (buffer == NULL)
@@ -1237,9 +1248,9 @@ struct webview_priv
         myURL.bstrVal = SysAllocString(buffer);
         GlobalFree(buffer);
       }
-// #else
+      // #else
-//       myURL.bstrVal = SysAllocString(webPageName);
+      //       myURL.bstrVal = SysAllocString(webPageName);
-// #endif
+      // #endif
       if (!myURL.bstrVal)
       {
       badalloc:
@@ -1277,7 +1288,7 @@ struct webview_priv
             if (!SafeArrayAccessData(sfArray, (void **)&pVar))
             {
               pVar->vt = VT_BSTR;
-// #ifndef UNICODE
+              // #ifndef UNICODE
               {
                 wchar_t *buffer = webview_to_utf16(url);
                 if (buffer == NULL)
@@ -1287,9 +1298,9 @@ struct webview_priv
                 bstr = SysAllocString(buffer);
                 GlobalFree(buffer);
               }
-// #else
+              // #else
-//               bstr = SysAllocString(url);
+              //               bstr = SysAllocString(url);
-// #endif
+              // #endif
               if ((pVar->bstrVal = bstr))
               {
                 htmlDoc2->lpVtbl->write(htmlDoc2, sfArray);
@@ -1410,6 +1421,8 @@ struct webview_priv
     wc.hInstance = hInstance;
     wc.lpfnWndProc = wndproc;
     wc.lpszClassName = classname;
+    wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(100));
+    wc.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(100));
     RegisterClassEx(&wc);
 
     style = WS_OVERLAPPEDWINDOW;
@@ -1444,12 +1457,12 @@ struct webview_priv
                        rect.right - rect.left, rect.bottom - rect.top,
                        HWND_DESKTOP, NULL, hInstance, (void *)w);
 #else
-  w->priv.hwnd =
+    w->priv.hwnd =
         CreateWindowEx(0, classname, w->title, style, rect.left, rect.top,
                        rect.right - rect.left, rect.bottom - rect.top,
                        HWND_DESKTOP, NULL, hInstance, (void *)w);
 #endif
-    
+
     if (w->priv.hwnd == 0)
     {
       OleUninitialize();
@@ -1466,8 +1479,7 @@ struct webview_priv
 #else
     SetWindowText(w->priv.hwnd, w->title);
 #endif
-    
+
-    
     ShowWindow(w->priv.hwnd, SW_SHOWDEFAULT);
     UpdateWindow(w->priv.hwnd);
     SetFocus(w->priv.hwnd);
@@ -1494,6 +1506,11 @@ struct webview_priv
     case WM_KEYDOWN:
     case WM_KEYUP:
     {
+      // Disable refresh when pressing F5 on windows
+      if (msg.wParam == VK_F5)
+      {
+        break;
+      }
       HRESULT r = S_OK;
       IWebBrowser2 *webBrowser2;
       IOleObject *browser = *w->priv.browser;
@@ -1603,7 +1620,7 @@ struct webview_priv
 
   WEBVIEW_API void webview_set_title(struct webview *w, const char *title)
   {
-  #ifdef UNICODE
+#ifdef UNICODE
     wchar_t *u16title = webview_to_utf16(title);
     if (u16title == NULL)
     {
@@ -1611,12 +1628,11 @@ struct webview_priv
     }
     SetWindowText(w->priv.hwnd, u16title);
     GlobalFree(u16title);
-  #else
+#else
     SetWindowText(w->priv.hwnd, title);
-  #endif
+#endif
   }
 
-
   WEBVIEW_API void webview_set_fullscreen(struct webview *w, int fullscreen)
   {
     if (w->priv.is_fullscreen == !!fullscreen)
@@ -1777,7 +1793,7 @@ struct webview_priv
   WEBVIEW_API void webview_dialog(struct webview *w,
                                   enum webview_dialog_type dlgtype, int flags,
                                   const char *title, const char *arg,
-                                  char *result, size_t resultsz)
+                                  char *result, size_t resultsz, char *filter)
   {
     if (dlgtype == WEBVIEW_DIALOG_TYPE_OPEN ||
         dlgtype == WEBVIEW_DIALOG_TYPE_SAVE)
@@ -1817,6 +1833,32 @@ struct webview_priv
                     FOS_NOTESTFILECREATE | FOS_NODEREFERENCELINKS |
                     FOS_FORCESHOWHIDDEN | FOS_DEFAULTNOMINIMODE;
       }
+      if (filter[0] != '\0')
+      {
+        int count;
+        int i=0;
+        char* token;
+        char* filter_dup = strdup(filter);
+        for (count=1; filter[count]; filter[count]==',' ? count++ : *filter++);
+        COMDLG_FILTERSPEC rgSpec[count];
+        char* filters[count];
+        token = strtok(filter_dup, ",");
+        while(token != NULL)
+        {
+          filters[i] = token;
+          token = strtok(NULL, ",");
+          i++;
+        }
+        for (int i=0; i < count; i++) {
+          wchar_t *wFilter = (wchar_t *)malloc(4096);
+          MultiByteToWideChar(CP_ACP, 0, filters[i], -1, wFilter, 4096);
+          rgSpec[i].pszName = wFilter;
+          rgSpec[i].pszSpec = wFilter;
+        }
+        if (dlg->lpVtbl->SetFileTypes(dlg, count, rgSpec) != S_OK) {
+          goto error_dlg;
+        }
+      }
       if (dlg->lpVtbl->GetOptions(dlg, &opts) != S_OK)
       {
         goto error_dlg;
@@ -1927,22 +1969,26 @@ struct webview_priv
     [script setValue:self forKey:@"external"];
   }
 
-static void webview_run_input_open_panel(id self, SEL cmd, id webview,
+  static void webview_run_input_open_panel(id self, SEL cmd, id webview,
-                                           id listener, BOOL allowMultiple) {
+                                           id listener, BOOL allowMultiple)
+  {
     char filename[256] = "";
     struct webview *w =
         (struct webview *)objc_getAssociatedObject(self, "webview");
 
     webview_dialog(w, WEBVIEW_DIALOG_TYPE_OPEN, WEBVIEW_DIALOG_FLAG_FILE, "", "",
-                   filename, 255);
+                   filename, 255, "");
-    if (strlen(filename)) {
+    filename[255] = '\0';
+    if (strlen(filename) > 0)
+    {
       [listener chooseFilename:[NSString stringWithUTF8String:filename]];
-    } else {
+    }
+    else
+    {
       [listener cancel];
     }
   }
 
-
   static void webview_external_invoke(id self, SEL cmd, id arg)
   {
     struct webview *w =
@@ -1955,7 +2001,7 @@ static void webview_run_input_open_panel(id self, SEL cmd, id webview,
     {
       return;
     }
-    w->external_invoke_cb(w, [(NSString *)(arg)UTF8String]);
+    w->external_invoke_cb(w, [(NSString *)(arg) UTF8String]);
   }
 
   WEBVIEW_API int webview_init(struct webview *w)
@@ -2194,12 +2240,16 @@ static void webview_run_input_open_panel(id self, SEL cmd, id webview,
   WEBVIEW_API void webview_dialog(struct webview *w,
                                   enum webview_dialog_type dlgtype, int flags,
                                   const char *title, const char *arg,
-                                  char *result, size_t resultsz)
+                                  char *result, size_t resultsz, char *filter)
   {
     if (dlgtype == WEBVIEW_DIALOG_TYPE_OPEN ||
         dlgtype == WEBVIEW_DIALOG_TYPE_SAVE)
     {
       NSSavePanel *panel;
+      NSString *filter_str = [NSString stringWithUTF8String:filter];
+      filter_str = [filter_str stringByReplacingOccurrencesOfString:@"*."
+                                     withString:@""];
+      NSArray *fileTypes = [filter_str componentsSeparatedByString:@","];
       if (dlgtype == WEBVIEW_DIALOG_TYPE_OPEN)
       {
         NSOpenPanel *openPanel = [NSOpenPanel openPanel];
@@ -2212,6 +2262,10 @@ static void webview_run_input_open_panel(id self, SEL cmd, id webview,
         {
           [openPanel setCanChooseFiles:YES];
           [openPanel setCanChooseDirectories:NO];
+          if(filter[0] != NULL)
+          {
+            [openPanel setAllowedFileTypes:fileTypes];
+          }
         }
         [openPanel setResolvesAliases:NO];
         [openPanel setAllowsMultipleSelection:NO];
@@ -2225,6 +2279,10 @@ static void webview_run_input_open_panel(id self, SEL cmd, id webview,
       [panel setShowsHiddenFiles:YES];
       [panel setExtensionHidden:NO];
       [panel setCanSelectHiddenExtension:NO];
+      if(filter[0] != NULL)
+      {
+        [panel setAllowedFileTypes:fileTypes];
+      }
       [panel setTreatsFilePackagesAsDirectories:YES];
       [panel beginSheetModalForWindow:w->priv.window
                     completionHandler:^(NSInteger result) {

runtime.go

@@ -1,32 +0,0 @@
-package wails
-
-import (
-	"github.com/wailsapp/wails/lib/interfaces"
-	"github.com/wailsapp/wails/lib/logger"
-	"github.com/wailsapp/wails/runtime"
-)
-
-// CustomLogger type alias
-type CustomLogger = logger.CustomLogger
-
-// Runtime is the Wails Runtime Interface, given to a user who has defined the WailsInit method
-type Runtime struct {
-	Events     *runtime.Events
-	Log        *runtime.Log
-	Dialog     *runtime.Dialog
-	Window     *runtime.Window
-	Browser    *runtime.Browser
-	FileSystem *runtime.FileSystem
-}
-
-// NewRuntime creates a new Runtime struct
-func NewRuntime(eventManager interfaces.EventManager, renderer interfaces.Renderer) *Runtime {
-	return &Runtime{
-		Events:     runtime.NewEvents(eventManager),
-		Log:        runtime.NewLog(),
-		Dialog:     runtime.NewDialog(renderer),
-		Window:     runtime.NewWindow(renderer),
-		Browser:    runtime.NewBrowser(),
-		FileSystem: runtime.NewFileSystem(),
-	}
-}

runtime/assets/bridge.js

@@ -14,7 +14,7 @@ function init() {
 	window.wailsbridge = {
 		reconnectOverlay: null,
 		reconnectTimer: 300,
-		wsURL: 'ws://localhost:34115/bridge',
+		wsURL: 'ws://' + window.location.hostname + ':34115/bridge',
 		connectionState: null,
 		config: {},
 		websocket: null,

runtime/assets/console.js

@@ -0,0 +1,175 @@
+(function () {
+
+    window.wailsconsole = {};
+
+    var debugconsole = document.createElement("div");
+    var header = document.createElement("div");
+    var consoleOut = document.createElement("div");
+
+
+    document.addEventListener('keyup', logKey);
+
+    debugconsole.id = "wailsdebug";
+    debugconsole.style.fontSize = "18px";
+    debugconsole.style.width = "100%";
+    debugconsole.style.height = "35%";
+    debugconsole.style.maxHeight = "35%";
+    debugconsole.style.position = "fixed";
+    debugconsole.style.left = "0px";
+    debugconsole.style.backgroundColor = "rgba(255,255,255,0.8)";
+    debugconsole.style.borderTop = '1px solid black';
+    debugconsole.style.color = "black";
+    debugconsole.style.display = "none";
+
+    header.style.width = "100%";
+    header.style.height = "30px";
+    header.style.display = "block";
+    // header.style.paddingTop = "3px";
+    header.style.verticalAlign = "middle";
+    header.style.paddingLeft = "10px";
+    header.style.background = "rgba(255,255,255,0.8)";
+    header.innerHTML = "  <span style='vertical-align: middle'> Wails Console > <input id='conin' style='border: solid 1px black; width: 50%'></input><span style='padding-left: 5px; cursor:pointer;' onclick='window.wailsconsole.clearConsole()'>Clear</span></span>";
+
+    consoleOut.style.position = "absolute";
+    consoleOut.style.width = "100%";
+    consoleOut.style.height = "auto";
+    consoleOut.style.top = "30px";
+    // consoleOut.style.paddingLeft = "10px";
+    consoleOut.style.bottom = "0px";
+    consoleOut.style.backgroundColor = "rgba(200,200,200,1)";
+    consoleOut.style.overflowY = "scroll";
+    consoleOut.style.msOverflowStyle = "-ms-autohiding-scrollbar";
+
+    debugconsole.appendChild(header);
+    debugconsole.appendChild(consoleOut);
+    document.body.appendChild(debugconsole);
+    console.log(debugconsole.style.display)
+
+    function logKey(e) {
+        var conin = document.getElementById('conin');
+        if (e.which == 27 && e.shiftKey) {
+            toggleConsole(conin);
+        }
+        if (e.which == 13 && consoleVisible()) {
+            var command = conin.value.trim();
+            if (command.length > 0) {
+                console.log("> " + command)
+                try {
+                    evaluateInput(command);
+                } catch (e) {
+                    console.error(e.message);
+                }
+                conin.value = "";
+            }
+        }
+    };
+
+
+    function consoleVisible() {
+        return debugconsole.style.display == "block";
+    }
+
+    function toggleConsole(conin) {
+        var display = "none"
+        if (debugconsole.style.display == "none") display = "block";
+        debugconsole.style.display = display;
+        if (display == "block") {
+            conin.focus();
+        }
+    }
+
+    function evaluateExpression(expression) {
+
+        var pathSegments = [].concat(expression.split('.'));
+        if (pathSegments[0] == 'window') {
+            pathSegments.shift()
+        }
+        var currentObject = window;
+        for (var i = 0; i < pathSegments.length; i++) {
+            var pathSegment = pathSegments[i];
+            if (currentObject[pathSegment] == undefined) {
+                return false;
+            }
+            currentObject = currentObject[pathSegment];
+        }
+        console.log(JSON.stringify(currentObject));
+
+        return true;
+    }
+
+    function evaluateInput(command) {
+        try {
+            if (evaluateExpression(command)) {
+                return
+            } else {
+                eval(command);
+            }
+        } catch (e) {
+            console.error(e.message)
+        }
+    }
+
+
+    // Set us up as a listener
+    function hookIntoIPC() {
+        if (window.wails && window.wails._ && window.wails._.AddIPCListener) {
+            window.wails._.AddIPCListener(processIPCMessage);
+        } else {
+            setTimeout(hookIntoIPC, 100);
+        }
+    }
+    hookIntoIPC();
+
+    function processIPCMessage(message) {
+        console.log(message);
+        var parsedMessage;
+        try {
+            parsedMessage = JSON.parse(message);
+        } catch (e) {
+            console.error("Error in parsing IPC message: " + e.message);
+            return false;
+        }
+        var logmessage = "[IPC] "
+        switch (parsedMessage.type) {
+            case 'call':
+                logmessage += " Call: " + parsedMessage.payload.bindingName;
+                var params = "";
+                var parsedParams = JSON.parse(parsedMessage.payload.data);
+                if (parsedParams.length > 0) {
+                    params = parsedParams;
+                }
+                logmessage += "(" + params + ")";
+                break;
+            case 'log':
+                logmessage += "Log (" + parsedMessage.payload.level + "): " + parsedMessage.payload.message;
+                break;
+            default:
+                logmessage = message;
+        }
+        console.log(logmessage);
+    }
+
+    window.wailsconsole.clearConsole = function () {
+        consoleOut.innerHTML = "";
+    }
+
+    console.log = function (message) {
+        consoleOut.innerHTML = consoleOut.innerHTML + "<span style='padding-left: 5px'>" + message + '</span><br/>';
+        consoleOut.scrollTop = consoleOut.scrollHeight;
+
+    };
+    console.error = function (message) {
+        consoleOut.innerHTML = consoleOut.innerHTML + "<span style='color:red; padding-left: 5px'> Error: " + message + '</span><br/>';
+        consoleOut.scrollTop = consoleOut.scrollHeight;
+    };
+    // var h = document.getElementsByTagName("html")[0];
+    // console.log("html margin: " + h.style.marginLeft);
+    // console.log("html padding: " + h.style.paddingLeft);
+
+    // setInterval(function() { console.log("test");}, 1000);
+    // setInterval(function() { console.error("oops");}, 3000);
+    // var script = document.createElement('script'); 
+    // script.src = "https://cdnjs.cloudflare.com/ajax/libs/firebug-lite/1.4.0/firebug-lite.js#startOpened=true"; 
+    // document.body.appendChild(script); 
+
+})();

runtime/dialog.go

@@ -1,6 +1,7 @@
 package runtime
 
 import "github.com/wailsapp/wails/lib/interfaces"
+import "strings"
 
 // Dialog exposes an interface to native dialogs
 type Dialog struct {
@@ -15,8 +16,16 @@ func NewDialog(renderer interfaces.Renderer) *Dialog {
 }
 
 // SelectFile prompts the user to select a file
-func (r *Dialog) SelectFile() string {
+func (r *Dialog) SelectFile(params ...string) string {
-	return r.renderer.SelectFile()
+	title := "Select File"
+	filter := ""
+	if len(params) > 0 {
+		title = params[0]
+	}
+	if len(params) > 1 {
+		filter = strings.Replace(params[1], " ", "", -1)
+	}
+	return r.renderer.SelectFile(title, filter)
 }
 
 // SelectDirectory prompts the user to select a directory
@@ -25,6 +34,14 @@ func (r *Dialog) SelectDirectory() string {
 }
 
 // SelectSaveFile prompts the user to select a file for saving
-func (r *Dialog) SelectSaveFile() string {
+func (r *Dialog) SelectSaveFile(params ...string) string {
-	return r.renderer.SelectSaveFile()
+	title := "Select Save"
+	filter := ""
+	if len(params) > 0 {
+		title = params[0]
+	}
+	if len(params) > 1 {
+		filter = strings.Replace(params[1], " ", "", -1)
+	}
+	return r.renderer.SelectSaveFile(title, filter)
 }

runtime/filesystem.go

@@ -1,9 +1,9 @@
 package runtime
 
-import homedir "github.com/mitchellh/go-homedir"
+import "os"
 
 // FileSystem exposes file system utilities to the runtime
-type FileSystem struct {}
+type FileSystem struct{}
 
 // NewFileSystem creates a new FileSystem struct
 func NewFileSystem() *FileSystem {
@@ -12,5 +12,5 @@ func NewFileSystem() *FileSystem {
 
 // HomeDir returns the user's home directory
 func (r *FileSystem) HomeDir() (string, error) {
-	return homedir.Dir()
+	return os.UserHomeDir()
 }

runtime/js/core/ipc.js

@@ -9,17 +9,35 @@ The lightweight framework for web-like apps
 */
 /* jshint esversion: 6 */
 
+// IPC Listeners
+var listeners = [];
+
+/**
+ * Adds a listener to IPC messages
+ * @param {function} callback 
+ */
+export function AddIPCListener(callback) {
+	listeners.push(callback);
+}
+
 /**
  * Invoke sends the given message to the backend
  *
  * @param {string} message
  */
 function Invoke(message) {
-	if ( window.wailsbridge ) {
+	if (window.wailsbridge) {
 		window.wailsbridge.websocket.send(message);
 	} else {
 		window.external.invoke(message);
 	}
+
+	// Also send to listeners
+	if (listeners.length > 0) {
+		for (var i = 0; i < listeners.length; i++) {
+			listeners[i](message);
+		}
+	}
 }
 
 /**