The runtime was rebuilt

[v2] Update Workflows + runtime

.github/ISSUE_TEMPLATE/bug_report.md

@@ -8,8 +8,12 @@ assignees: ''
 ---
 
 #####################################################
-     If you have a technical issue, please do not open a bug this way! 
-                      Please use the `wails issue` command!                          
+     **If you have a technical issue, please do not open a bug this way!** 
+                      Please use the `wails issue` command!
+          If you do not do this then the issue may be closed automatically.                      
+
+ NOTE: If your bug is related to Windows, make sure you read 
+ the [Windows Developer Guide](https://wails.app/guides/windows/)
 #####################################################
 
 **Description**
@@ -33,3 +37,5 @@ Please provide your platform, GO version and variables, etc
 
 **Additional context**
 Add any other context about the problem here.
+
+- [ ] This issue is for Windows and I have read the [Windows Developer Guide](https://wails.app/guides/windows/)

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/latest-pre.yml

@@ -0,0 +1,34 @@
+name: latest pre-release
+on:
+  push:
+    branches:
+      - develop
+    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

.github/workflows/runtime.yml

@@ -0,0 +1,30 @@
+name: Runtime
+on:
+  push:
+    branches:
+      - v2-alpha
+    paths:
+      - 'v2/internal/frontend/runtime/**'
+jobs:
+  rebuild-runtime:
+    name: Rebuild the runtime
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 14.17.6
+          cache: 'npm'
+          cache-dependency-path: v2/internal/frontend/runtime/package-lock.json
+      - run: npm install
+        working-directory: v2/internal/frontend/runtime
+      - run: npm run build
+        working-directory: v2/internal/frontend/runtime
+
+      - name: Commit changes
+        uses: devops-infra/action-commit-push@master
+        with:
+          github_token: "${{ secrets.GITHUB_TOKEN }}"
+          add_timestamp: true
+          commit_prefix: "[AUTO]"
+          commit_message: "The runtime was rebuilt"

.gitignore

@@ -16,4 +16,18 @@ examples/**/example*
 cmd/wails/wails
 .DS_Store
 tmp
-node_modules/
+node_modules/
+package.json.md5
+v2/test/**/frontend/dist
+v2/test/**/build/
+v2/test/frameless/icon.png
+v2/test/hidden/icon.png
+v2/test/kitchensink/frontend/public/bundle.*
+v2/pkg/parser/testproject/frontend/wails
+v2/test/kitchensink/frontend/public
+v2/test/kitchensink/build/darwin/desktop/kitchensink
+v2/test/kitchensink/frontend/package.json.md5
+/v2/internal/ffenestri/windows/test/cmake-build-debug/
+!v2/internal/ffenestri/windows/x64/webview2.dll
+!v2/internal/ffenestri/windows/x64/WebView2Loader.dll
+.idea/

.vscode/settings.json

@@ -1,4 +1,8 @@
 {
   "go.formatTool": "goimports",
-  "eslint.alwaysShowStatus": true
+  "eslint.alwaysShowStatus": true,
+  "files.associations": {
+    "__locale": "c",
+    "ios": "c"
+  }
 }

CONTRIBUTORS.md

@@ -2,21 +2,43 @@
 
 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)
-* [Qais Patankar](https://github.com/qaisjp)
-* [Anthony Lee](https://github.com/alee792)
-* [Adrian Lanzafame](https://github.com/lanzafame)
-* [Mattn](https://github.com/mattn)
-* [0xflotus](https://github.com/0xflotus)
-* [Michael D Henderson](https://github.com/mdhender)
-* [fred2104](https://github.com/fishfishfish2104)
-* [intelwalk](https://github.com/intelwalk)
-* [Mark Stenglein](https://github.com/ocelotsloth)
-* [admin_3.exe](https://github.com/bh90210)
-* [iceleo-com](https://github.com/iceleo-com)
-* [fallendusk](https://github.com/fallendusk)
-* [Florian Didran](https://github.com/fdidron)
-* [Nikolai Zimmermann](https://github.com/Chronophylos)
-* [Toyam Cox](https://github.com/Vaelatern)
-* [Robin Eklind](https://github.com/mewmew)
-* [Kris Raney](https://github.com/kraney)
+  * [Dustin Krysak](https://wiki.ubuntu.com/bashfulrobot)
+  * [Qais Patankar](https://github.com/qaisjp)
+  * [Anthony Lee](https://github.com/alee792)
+  * [Adrian Lanzafame](https://github.com/lanzafame)
+  * [Mattn](https://github.com/mattn)
+  * [0xflotus](https://github.com/0xflotus)
+  * [Michael D Henderson](https://github.com/mdhender)
+  * [fred2104](https://github.com/fishfishfish2104)
+  * [intelwalk](https://github.com/intelwalk)
+  * [Mark Stenglein](https://github.com/ocelotsloth)
+  * [admin_3.exe](https://github.com/bh90210)
+  * [iceleo-com](https://github.com/iceleo-com)
+  * [fallendusk](https://github.com/fallendusk)
+  * [Nikolai Zimmermann](https://github.com/Chronophylos)
+  * [Toyam Cox](https://github.com/Vaelatern)
+  * [Robin Eklind](https://github.com/mewmew)
+  * [Kris Raney](https://github.com/kraney)
+  * [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)
+  * [Arthur Wiebe](https://github.com/artooro)
+  * [Ilgıt Yıldırım](https://github.com/ilgityildirim)
+  * [Altynbek](https://github.com/gelleson)
+  * [Kyle](https://github.com/kmuchmore)
+  * [Balakrishna Prasad Ganne](https://github.com/aayush420)
+  * [Charaf Rezrazi](https://github.com/Rezrazi)
+  * [misitebao](https://github.com/misitebao)
+  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Amaury Tobias Quiroz](https://github.com/amaury-tobias)

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,13 @@
    <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>
 </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 +30,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 +54,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 +93,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 +125,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.
-  * [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.
+  * [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.
 
 This project was mainly coded to the following albums:
 
@@ -148,3 +146,16 @@ 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 Thanks
+
+<p align="center" style="text-align: center">
+   A *huge* thanks to <a href="https://pace.dev"><img src="pace.jpeg"/> Pace</a> for sponsoring the project and helping the efforts to get Wails ported to Apple Silicon!<br/><br/>
+   If you are looking for a Project Management tool that's powerful but quick and easy to use, check them out!<br/><br/>
+</p>
+
+<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,9 +1,7 @@
 package wails
 
 import (
-	"fmt"
 	"os"
-	"runtime"
 	"syscall"
 
 	"github.com/syossan27/tebata"
@@ -14,6 +12,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 +20,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 +54,7 @@ func CreateApp(optionalConfig ...*AppConfig) *App {
 	}
 
 	result := &App{
-		logLevel:       "info",
+		logLevel:       "debug",
 		renderer:       renderer.NewWebView(),
 		ipc:            ipc.NewManager(),
 		bindingManager: binding.NewManager(),
@@ -67,28 +76,12 @@ func CreateApp(optionalConfig ...*AppConfig) *App {
 		result.config.DisableInspector = true
 	}
 
-	// If running windows, do a hidpi fix
-	if runtime.GOOS == "windows" {
-		err := SetProcessDPIAware()
-		if err != nil {
-			result.log.Fatalf(err.Error())
-		}
-	}
+	// Platform specific init
+	platformInit()
 
 	return result
 }
 
-// SetProcessDPIAware via user32.dll
-// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setprocessdpiaware
-// Also, thanks Jack Mordaynt! 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 +107,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
@@ -137,7 +130,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,16 +5,21 @@ 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"
 )
 
+const xgoVersion = "1.0.1"
+
 var fs = NewFSHelper()
 
 // ValidateFrontendConfig checks if the frontend config is valid
@@ -36,34 +41,169 @@ func ValidateFrontendConfig(projectOptions *ProjectOptions) error {
 }
 
 // InstallGoDependencies will run go get in the current directory
-func InstallGoDependencies() error {
-	depSpinner := spinner.New("Ensuring Dependencies are up to date...")
-	depSpinner.SetSpinSpeed(50)
-	depSpinner.Start()
-	err := NewProgramHelper().RunCommand("go get")
+func InstallGoDependencies(verbose bool) error {
+	var depSpinner *spinner.Spinner
+	if !verbose {
+		depSpinner = spinner.New("Ensuring Dependencies are up to date...")
+		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
-func BuildApplication(binaryName string, forceRebuild bool, buildMode string, packageApp bool, projectOptions *ProjectOptions) error {
+// EmbedAssets will embed the built frontend assets via mewn.
+func EmbedAssets() ([]string, error) {
+	mewnFiles := lib.GetMewnFiles([]string{}, false)
 
-	// Generate Windows assets if needed
-	if runtime.GOOS == "windows" {
-		cleanUp := !packageApp
-		err := NewPackageHelper().PackageWindows(projectOptions, cleanUp)
-		if err != nil {
-			return err
-		}
+	referencedAssets, err := lib.GetReferencedAssets(mewnFiles)
+	if err != nil {
+		return []string{}, err
 	}
 
-	// Check Mewn is installed
-	err := CheckMewn()
+	targetFiles := []string{}
+
+	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
+	msg := fmt.Sprintf("Pulling wailsapp/xgo:%s docker image... (may take a while)", xgoVersion)
+	if !verbose {
+		packSpinner = spinner.New(msg)
+		packSpinner.SetSpinSpeed(50)
+		packSpinner.Start()
+	} else {
+		println(msg)
+	}
+
+	err := NewProgramHelper(verbose).RunCommandArray([]string{"docker",
+		"pull", fmt.Sprintf("wailsapp/xgo:%s", xgoVersion)})
+
 	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:<xgoVersion> 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_TAGS=%s", projectOptions.Tags),
+		"-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/%s", projectOptions.Platform, projectOptions.Architecture),
+		"-e", "GOPROXY=",
+		"-e", "GO111MODULE=on",
+	} {
+		buildCommand.Add(arg)
+	}
+
+	if projectOptions.GoPath != "" {
+		buildCommand.Add("-v")
+		buildCommand.Add(fmt.Sprintf("%s:/go", projectOptions.GoPath))
+	}
+
+	buildCommand.Add(fmt.Sprintf("wailsapp/xgo:%s", xgoVersion))
+	buildCommand.Add(".")
+
+	compileMessage := fmt.Sprintf(
+		"Packing + Compiling project for %s/%s using docker image wailsapp/xgo:%s",
+		projectOptions.Platform, projectOptions.Architecture, xgoVersion)
+
+	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 +213,23 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 		compileMessage += " (Debug Mode)"
 	}
 
-	packSpinner := spinner.New(compileMessage + "...")
-	packSpinner.SetSpinSpeed(50)
-	packSpinner.Start()
+	var packSpinner *spinner.Spinner
+	if !projectOptions.Verbose {
+		packSpinner = spinner.New(compileMessage + "...")
+		packSpinner.SetSpinSpeed(50)
+		packSpinner.Start()
+	} else {
+		println(compileMessage)
+	}
 
 	buildCommand := slicer.String()
-	buildCommand.Add("mewn")
-
-	if buildMode == BuildModeBridge {
-		// Ignore errors
-		buildCommand.Add("-i")
-	}
+	buildCommand.Add("go")
 
 	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 +239,7 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 				binaryName = strings.TrimSuffix(binaryName, ".exe")
 			}
 		}
-		buildCommand.Add("-o")
-		buildCommand.Add(binaryName)
+		buildCommand.Add("-o", filepath.Join("build", binaryName))
 	}
 
 	// If we are forcing a rebuild
@@ -108,28 +247,78 @@ func BuildApplication(binaryName string, forceRebuild bool, buildMode string, pa
 		buildCommand.Add("-a")
 	}
 
-	// Setup ld flags
-	ldflags := "-w -s "
-	if buildMode == BuildModeDebug {
-		ldflags = ""
+	buildCommand.AddSlice([]string{"-ldflags", ldFlags(projectOptions, buildMode)})
+
+	if projectOptions.Tags != "" {
+		buildCommand.AddSlice([]string{"--tags", projectOptions.Tags})
 	}
 
-	// Add windows flags
-	if runtime.GOOS == "windows" && buildMode == BuildModeProd {
-		ldflags += "-H windowsgui "
+	if projectOptions.Verbose {
+		fmt.Printf("Command: %v\n", buildCommand.AsSlice())
 	}
 
-	ldflags += "-X github.com/wailsapp/wails.BuildMode=" + buildMode
-
-	buildCommand.AddSlice([]string{"-ldflags", ldflags})
-	err = NewProgramHelper().RunCommandArray(buildCommand.AsSlice())
+	err := NewProgramHelper(projectOptions.Verbose).RunCommandArray(buildCommand.AsSlice())
+	if err != nil {
+		if packSpinner != nil {
+			packSpinner.Error()
+		}
+		return err
+	}
+	if packSpinner != nil {
+		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 +331,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
-	message := "Generating .app"
-	if runtime.GOOS == "windows" {
-		err := CheckWindres()
-		if err != nil {
-			return err
-		}
-		message = "Generating resource bundle"
+	var packageSpinner *spinner.Spinner
+	if projectOptions.Verbose {
+		packageSpinner = spinner.New("Packaging application...")
+		packageSpinner.SetSpinSpeed(50)
+		packageSpinner.Start()
 	}
-	packageSpinner := spinner.New(message)
-	packageSpinner.SetSpinSpeed(50)
-	packageSpinner.Start()
-	err := NewPackageHelper().Package(projectOptions)
+
+	err := NewPackageHelper(projectOptions.Platform).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 {
-	buildFESpinner := spinner.New("Building frontend...")
-	buildFESpinner.SetSpinSpeed(50)
-	buildFESpinner.Start()
-	err := NewProgramHelper().RunCommand(buildCommand)
+func BuildFrontend(projectOptions *ProjectOptions) error {
+	var buildFESpinner *spinner.Spinner
+	if !projectOptions.Verbose {
+		buildFESpinner = spinner.New("Building frontend...")
+		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) {
-	programHelper := NewProgramHelper()
+func CheckMewn(verbose bool) (err error) {
+	programHelper := NewProgramHelper(verbose)
 	if !programHelper.IsInstalled("mewn") {
-		buildSpinner := spinner.New()
-		buildSpinner.SetSpinSpeed(50)
-		buildSpinner.Start("Installing Mewn asset packer...")
+		var buildSpinner *spinner.Spinner
+		if !verbose {
+			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 +410,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 +429,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)")
-	feSpinner.SetSpinSpeed(50)
-	feSpinner.Start()
+	var feSpinner *spinner.Spinner
+	if !projectOptions.Verbose {
+		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 +468,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 +481,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 +503,7 @@ func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forc
 	}
 
 	// Build frontend
-	err = BuildFrontend(projectOptions.FrontEnd.Build)
+	err = BuildFrontend(projectOptions)
 	if err != nil {
 		return err
 	}
@@ -314,9 +540,12 @@ func InstallProdRuntime(projectDir string, projectOptions *ProjectOptions) error
 func ServeProject(projectOptions *ProjectOptions, logger *Logger) error {
 	go func() {
 		time.Sleep(2 * time.Second)
+		if projectOptions.Platform == "windows" {
+			logger.Yellow("*** Please note: Windows builds use mshtml which is only compatible with IE11. We strongly recommend only using IE11 when running 'wails serve'! For more information, please read https://wails.app/guides/windows/ ***")
+		}
 		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 +561,37 @@ 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 "
+	}
+
+	if po.UseFirebug {
+		ldflags += "-X github.com/wailsapp/wails/lib/renderer.UseFirebug=true "
+	}
+
+	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,30 @@ 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
+	// EndeavourOS linux distribution
+	EndeavourOS
 )
 
 // DistroInfo contains all the information relating to a linux distribution
@@ -93,13 +115,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 +131,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 +155,26 @@ 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
+	case "endeavouros":
+		result.Distribution = EndeavourOS
 	default:
 		result.Distribution = Unknown
 	}
@@ -166,6 +211,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 +293,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,42 @@ 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   
+  endeavouros:
+    id: endeavouros
+    releases:
+      default:
+        version: default
+        name: EndeavourOS
+        gccversioncommand: *gccdumpversion
+        programs: *archdefaultprograms
+        libraries: *archdefaultlibraries             
   manjaro:
     id: manjaro
     releases:
@@ -167,6 +221,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 +248,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
-	log    *Logger
-	system *SystemHelper
+	platform string
+	fs       *FSHelper
+	log      *Logger
+	system   *SystemHelper
 }
 
 // NewPackageHelper creates a new PackageHelper!
-func NewPackageHelper() *PackageHelper {
+func NewPackageHelper(platform string) *PackageHelper {
 	return &PackageHelper{
-		fs:     NewFSHelper(),
-		log:    NewLogger(),
-		system: NewSystemHelper(),
+		platform: platform,
+		fs:       NewFSHelper(),
+		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)
-	if !b.fs.FileExists(source) {
-		// We need to build!
-		return fmt.Errorf("Target '%s' not available. Has it been compiled yet?", exe)
+	source := path.Join(build, exe)
+	if po.CrossCompile == true {
+		file, err := b.fs.FindFile(build, "darwin")
+		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
-	var tpl bytes.Buffer
-	err = tmpl.Execute(&tpl, plistData)
-	if err != nil {
-		return err
-	}
-	filename := path.Join(b.fs.Cwd(), appname, "Contents", "Info.plist")
-	err = ioutil.WriteFile(filename, tpl.Bytes(), 0644)
-	if err != nil {
-		return err
+	// Do we have a custom plist in the project directory?
+	if !fs.FileExists(customPlist) {
+
+		// No - create a new plist from our defaults
+		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
+		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
-	tgtIconFile := filepath.Join(b.fs.Cwd(), basename+".ico")
-	if !b.fs.FileExists(tgtIconFile) {
-		srcIconfile := filepath.Join(b.getPackageFileBaseDir(), "wails.ico")
-		err := b.fs.CopyFile(srcIconfile, tgtIconFile)
-		if err != nil {
-			return err
-		}
+	// Copy default icon if needed
+	icon, err := b.copyIcon()
+	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(".")
-	if err != nil {
-		return err
-	}
+	// cross-compile
+	if b.platform != runtime.GOOS {
+		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")
-	windresCommand := []string{windresBatFile, sysofile, tgtRCFile}
-	err = NewProgramHelper().RunCommandArray(windresCommand)
-	if err != nil {
-		return err
-	}
-
-	// clean up
-	if cleanUp {
-		filesToDelete := []string{tgtIconFile, tgtManifestFile, tgtRCFile, sysofile}
-		err := b.fs.RemoveFiles(filesToDelete)
+		windresBatFile := filepath.Join(batfile.fullPath, "windres.bat")
+		windresCommand := []string{windresBatFile, sysofile, tgtRCFile}
+		err = NewProgramHelper().RunCommandArray(windresCommand)
 		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 {
-	return &ProgramHelper{
+func NewProgramHelper(verbose ...bool) *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"`
-	Path string `json:"path"`
+	Name    string `json:"name"`
+	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,
-		Path: path,
+		Name:    programName,
+		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
-	cmd.Stdout = &stdo
-	cmd.Stderr = &stde
-	err = cmd.Run()
-	stdout = string(stdo.Bytes())
-	stderr = string(stde.Bytes())
+	if !p.verbose {
+		var stdo, stde bytes.Buffer
+		cmd.Stdout = &stdo
+		cmd.Stderr = &stde
+		err = cmd.Run()
+		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

@@ -142,21 +142,47 @@ func (ph *ProjectHelper) NewProjectOptions() *ProjectOptions {
 
 // ProjectOptions holds all the options available for a project
 type ProjectOptions struct {
-	Name             string    `json:"name"`
-	Description      string    `json:"description"`
-	Author           *author   `json:"author,omitempty"`
-	Version          string    `json:"version"`
-	OutputDirectory  string    `json:"-"`
-	UseDefaults      bool      `json:"-"`
-	Template         string    `json:"-"`
-	BinaryName       string    `json:"binaryname"`
-	FrontEnd         *frontend `json:"frontend,omitempty"`
-	NPMProjectName   string    `json:"-"`
-	system           *SystemHelper
-	log              *Logger
-	templates        *TemplateHelper
-	selectedTemplate *TemplateDetails
-	WailsVersion     string
+	Name                   string    `json:"name"`
+	Description            string    `json:"description"`
+	Author                 *author   `json:"author,omitempty"`
+	Version                string    `json:"version"`
+	OutputDirectory        string    `json:"-"`
+	UseDefaults            bool      `json:"-"`
+	Template               string    `json:"-"`
+	BinaryName             string    `json:"binaryname"`
+	FrontEnd               *frontend `json:"frontend,omitempty"`
+	Tags                   string    `json:"tags"`
+	NPMProjectName         string    `json:"-"`
+	system                 *SystemHelper
+	log                    *Logger
+	templates              *TemplateHelper
+	selectedTemplate       *TemplateDetails
+	WailsVersion           string
+	typescriptDefsFilename string
+	Verbose                bool `json:"-"`
+	CrossCompile           bool
+	Platform               string
+	Architecture           string
+	LdFlags                string
+	GoPath                 string
+	UseFirebug             bool
+
+	// Supported platforms
+	Platforms []string `json:"platforms,omitempty"`
+}
+
+// PlatformSupported returns true if the template is supported
+// on the current platform
+func (po *ProjectOptions) PlatformSupported() bool {
+
+	// Default is all platforms supported
+	if len(po.Platforms) == 0 {
+		return true
+	}
+
+	// Check that the platform is in the list
+	platformsSupported := slicer.String(po.Platforms)
+	return platformsSupported.Contains(runtime.GOOS)
 }
 
 // Defaults sets the default project template
@@ -165,6 +191,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 {
@@ -222,13 +253,16 @@ func (po *ProjectOptions) PromptForInputs() error {
 		for _, k := range keys {
 			templateDetail := templateDetails[k]
 			templateList.Add(templateDetail)
+			if !templateDetail.Metadata.PlatformSupported() {
+				templateDetail.Metadata.Name = "* " + templateDetail.Metadata.Name
+			}
 			options.Add(fmt.Sprintf("%s - %s", templateDetail.Metadata.Name, templateDetail.Metadata.ShortDescription))
 		}
 
 		templateIndex := 0
 
 		if len(options.AsSlice()) > 1 {
-			templateIndex = PromptSelection("Please select a template", options.AsSlice(), 0)
+			templateIndex = PromptSelection("Please select a template (* means unsupported on current platform)", options.AsSlice(), 0)
 		}
 
 		if len(templateList.AsSlice()) == 0 {
@@ -239,6 +273,10 @@ func (po *ProjectOptions) PromptForInputs() error {
 		po.selectedTemplate = templateList.AsSlice()[templateIndex].(*TemplateDetails)
 	}
 
+	po.selectedTemplate.Metadata.Name = strings.TrimPrefix(po.selectedTemplate.Metadata.Name, "* ")
+	if !po.selectedTemplate.Metadata.PlatformSupported() {
+		println("WARNING: This template is unsupported on this platform!")
+	}
 	fmt.Println("Template: " + po.selectedTemplate.Metadata.Name)
 
 	// Setup NPM Project name
@@ -326,11 +364,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)
 }
@@ -366,5 +399,9 @@ func processTemplateMetadata(templateMetadata *TemplateMetadata, po *ProjectOpti
 		}
 		po.FrontEnd.Serve = templateMetadata.Serve
 	}
+
+	// Save platforms
+	po.Platforms = templateMetadata.Platforms
+
 	return nil
 }

cmd/semver.go

@@ -24,11 +24,19 @@ func NewSemanticVersion(version string) (*SemanticVersion, error) {
 
 // IsRelease returns true if it's a release version
 func (s *SemanticVersion) IsRelease() bool {
+	// Limit to v1
+	if s.Version.Major() != 1 {
+		return false
+	}
 	return len(s.Version.Prerelease()) == 0 && len(s.Version.Metadata()) == 0
 }
 
 // IsPreRelease returns true if it's a prerelease version
 func (s *SemanticVersion) IsPreRelease() bool {
+	// Limit to v1
+	if s.Version.Major() != 1 {
+		return false
+	}
 	return len(s.Version.Prerelease()) > 0
 }
 

cmd/semver_test.go

@@ -0,0 +1,65 @@
+package cmd
+
+import (
+	"testing"
+)
+
+func TestSemanticVersion_IsPreRelease(t *testing.T) {
+	tests := []struct {
+		name    string
+		version string
+		want    bool
+	}{
+		{"v1.6.7-pre0", "v1.6.7-pre0", true},
+		{"v2.6.7+pre0", "v2.6.7+pre0", false},
+		{"v2.6.7", "v2.6.7", false},
+		{"v2.0.0+alpha.1", "v2.0.0+alpha.1", false},
+		{"v2.0.0-alpha.1", "v2.0.0-alpha.1", false},
+		{"v1.6.7", "v1.6.7", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			semanticversion, err := NewSemanticVersion(tt.version)
+			if err != nil {
+				t.Errorf("Invalid semantic version: %s", semanticversion)
+				return
+			}
+			s := &SemanticVersion{
+				Version: semanticversion.Version,
+			}
+			if got := s.IsPreRelease(); got != tt.want {
+				t.Errorf("IsPreRelease() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSemanticVersion_IsRelease(t *testing.T) {
+	tests := []struct {
+		name    string
+		version string
+		want    bool
+	}{
+		{"v1.6.7", "v1.6.7", true},
+		{"v2.6.7-pre0", "v2.6.7-pre0", false},
+		{"v2.6.7", "v2.6.7", false},
+		{"v2.6.7+release", "v2.6.7+release", false},
+		{"v2.0.0-alpha.1", "v2.0.0-alpha.1", false},
+		{"v1.6.7-pre0", "v1.6.7-pre0", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			semanticversion, err := NewSemanticVersion(tt.version)
+			if err != nil {
+				t.Errorf("Invalid semantic version: %s", semanticversion)
+				return
+			}
+			s := &SemanticVersion{
+				Version: semanticversion.Version,
+			}
+			if got := s.IsRelease(); got != tt.want {
+				t.Errorf("IsRelease() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

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
-	cmd.Stdout = &stdo
-	cmd.Stderr = &stde
-	err = cmd.Run()
-	stdout = string(stdo.Bytes())
-	stderr = string(stde.Bytes())
+	if !sh.verbose {
+		var stdo, stde bytes.Buffer
+		cmd.Stdout = &stdo
+		cmd.Stderr = &stde
+		err = cmd.Run()
+		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
-	cmd.Stdout = &stdo
-	cmd.Stderr = &stde
-	err = cmd.Run()
-	stdout = string(stdo.Bytes())
-	stderr = string(stde.Bytes())
+	if !sh.verbose {
+		var stdo, stde bytes.Buffer
+		cmd.Stdout = &stdo
+		cmd.Stderr = &stde
+		err = cmd.Run()
+		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, EndeavourOS:
 			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.go

@@ -7,6 +7,7 @@ import (
 	"io/ioutil"
 	"log"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"text/template"
 
@@ -29,6 +30,26 @@ type TemplateMetadata struct {
 	Bridge               string                `json:"bridge"`
 	WailsDir             string                `json:"wailsdir"`
 	TemplateDependencies []*TemplateDependency `json:"dependencies,omitempty"`
+
+	// List of platforms that this template is supported on.
+	// No value means all platforms. A platform name is the same string
+	// as `runtime.GOOS` will return, eg: "darwin". NOTE: This is
+	// case sensitive.
+	Platforms []string `json:"platforms,omitempty"`
+}
+
+// PlatformSupported returns true if this template supports the
+// currently running platform
+func (m *TemplateMetadata) PlatformSupported() bool {
+
+	// Default is all platforms supported
+	if len(m.Platforms) == 0 {
+		return true
+	}
+
+	// Check that the platform is in the list
+	platformsSupported := slicer.String(m.Platforms)
+	return platformsSupported.Contains(runtime.GOOS)
 }
 
 // TemplateDependency defines a binary dependency for the template
@@ -128,11 +149,11 @@ func (t *TemplateHelper) GetTemplateDetails() (map[string]*TemplateDetails, erro
 		result[name] = &TemplateDetails{
 			Path: dir,
 		}
-		_ = &TemplateMetadata{}
 		metadata, err := t.LoadMetadata(dir)
 		if err != nil {
 			return nil, err
 		}
+
 		result[name].Metadata = metadata
 		if metadata.Name != "" {
 			result[name].Name = metadata.Name

cmd/templates/angular-template/frontend/browserslist

@@ -9,4 +9,4 @@
 last 2 versions
 Firefox ESR
 not dead
-not 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",
@@ -22,6 +22,7 @@
     "@angular/platform-browser-dynamic": "~8.0.1",
     "@angular/router": "~8.0.1",
     "@wailsapp/runtime": "^1.0.0",
+    "core-js": "^3.4.4",
     "ngx-build-plus": "^8.0.3",
     "rxjs": "~6.4.0",
     "tslib": "^1.9.0",

cmd/templates/angular-template/frontend/src/app/app-routing.module.ts

@@ -5,7 +5,7 @@ const routes: Routes = [];
 
 @NgModule({
   imports: [
-    RouterModule.forRoot(routes)
+    RouterModule.forRoot(routes,{useHash:true})
   ],
   exports: [RouterModule]
 })

cmd/templates/angular-template/frontend/src/main.ts

@@ -1,3 +1,4 @@
+import 'core-js/stable';
 import { enableProdMode } from '@angular/core';
 import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
 

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

@@ -11,7 +11,7 @@
     "module": "esnext",
     "moduleResolution": "node",
     "importHelpers": true,
-    "target": "es2015",
+    "target": "es5",
     "typeRoots": [
       "node_modules/@types"
     ],
@@ -20,4 +20,4 @@
       "dom"
     ]
   }
-}
+}

cmd/templates/angular-template/main.go.template

@@ -11,7 +11,7 @@ func basic() string {
 
 func main() {
 
-	js := mewn.String("./frontend/dist/my-app/main-es2015.js")
+	js := mewn.String("./frontend/dist/my-app/main.js")
 	css := mewn.String("./frontend/dist/my-app/styles.css")
 
 	app := wails.CreateApp(&wails.AppConfig{

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",
-    "react": "^16.8.6",
-    "react-dom": "^16.8.6",
+    "core-js": "^3.6.4",
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1",
     "wails-react-scripts": "3.0.1-2",
-    "react-modal": "3.8.1",
-    "@wailsapp/runtime": "^1.0.0"
+    "react-modal": "3.11.2",
+    "@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>
-  <body>
+</head>
+
+<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>
-</html>
+</body>
+
+</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 {
-  constructor(props, context) {
-    super();
-    this.state = {
-      showModal: false
-    };
+function HelloWorld() {
+	const [showModal, setShowModal] = useState(false);
+	const [result, setResult] = useState(null);
 
-    this.handleOpenModal = this.handleOpenModal.bind(this);
-    this.handleCloseModal = this.handleCloseModal.bind(this);
-  }
+	const handleOpenModal = () => {
+		setShowModal(true);
 
-  handleOpenModal () {
-    this.setState({ showModal: true });
+		window.backend.basic().then((result) => setResult(result));
+	};
 
-    window.backend.basic().then(result =>
-      this.setState({
-        result
-      })
-    );
-  }
+	const handleCloseModal = () => {
+		setShowModal(false);
+	};
 
-  handleCloseModal () {
-    this.setState({ showModal: false });
-  }
-
-  render() {
-    const { result } = this.state;
-    return (
-      <div className="App">
-        <button onClick={this.handleOpenModal} type="button">
-          Hello
-        </button>
-        <Modal
-          isOpen={this.state.showModal}
-          contentLabel="Minimal Modal Example"
-        >
-        <p>{result}</p>
-        <button onClick={this.handleCloseModal}>Close Modal</button>
-        </Modal>
-      </div>
-    );
-  }
+	return (
+		<div className="App">
+			<button onClick={() => handleOpenModal()} type="button">
+				Hello
+      </button>
+			<Modal
+				appElement={document.getElementById("app")}
+				isOpen={showModal}
+				contentLabel="Minimal Modal Example"
+			>
+				<p>{result}</p>
+				<button onClick={() => 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",
-  "description": "Create React App v3 standar tooling",
+  "shortdescription": "Create React App v4 template",
+  "description": "Create React App v4 standard tooling",
   "install": "npm install",
   "build": "npm run build",
   "author": "bh90210 <ktc@pm.me>",

cmd/templates/svelte/frontend/.gitignore

@@ -0,0 +1,4 @@
+/node_modules/
+/public/build/
+
+.DS_Store

cmd/templates/svelte/frontend/README.md

@@ -0,0 +1,90 @@
+*Looking for a shareable component template? Go here --> [sveltejs/component-template](https://github.com/sveltejs/component-template)*
+
+---
+
+# svelte app
+
+This is a project template for [Svelte](https://svelte.dev) apps. It lives at https://github.com/sveltejs/template.
+
+To create a new project based on this template using [degit](https://github.com/Rich-Harris/degit):
+
+```bash
+npx degit sveltejs/template svelte-app
+cd svelte-app
+```
+
+*Note that you will need to have [Node.js](https://nodejs.org) installed.*
+
+
+## Get started
+
+Install the dependencies...
+
+```bash
+cd svelte-app
+npm install
+```
+
+...then start [Rollup](https://rollupjs.org):
+
+```bash
+npm run dev
+```
+
+Navigate to [localhost:5000](http://localhost:5000). You should see your app running. Edit a component file in `src`, save it, and reload the page to see your changes.
+
+By default, the server will only respond to requests from localhost. To allow connections from other computers, edit the `sirv` commands in package.json to include the option `--host 0.0.0.0`.
+
+
+## Building and running in production mode
+
+To create an optimised version of the app:
+
+```bash
+npm run build
+```
+
+You can run the newly built app with `npm run start`. This uses [sirv](https://github.com/lukeed/sirv), which is included in your package.json's `dependencies` so that the app will work when you deploy to platforms like [Heroku](https://heroku.com).
+
+
+## Single-page app mode
+
+By default, sirv will only respond to requests that match files in `public`. This is to maximise compatibility with static fileservers, allowing you to deploy your app anywhere.
+
+If you're building a single-page app (SPA) with multiple routes, sirv needs to be able to respond to requests for *any* path. You can make it so by editing the `"start"` command in package.json:
+
+```js
+"start": "sirv public --single"
+```
+
+## Deploying to the web
+
+### With [Vercel](https://vercel.com)
+
+Install `vercel` if you haven't already:
+
+```bash
+npm install -g vercel
+```
+
+Then, from within your project folder:
+
+```bash
+cd public
+vercel deploy --name my-project
+```
+
+### With [surge](https://surge.sh/)
+
+Install `surge` if you haven't already:
+
+```bash
+npm install -g surge
+```
+
+Then, from within your project folder:
+
+```bash
+npm run build
+surge public my-project.surge.sh
+```

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

@@ -0,0 +1,31 @@
+{
+  "name": "{{.NPMProjectName}}",
+  "author": "{{.Author.Name}}<{{.Author.Email}}>",
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "start": "sirv public"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.11.6",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.11.5",
+    "@babel/preset-env": "^7.11.5",
+    "@rollup/plugin-commonjs": "^14.0.0",
+    "@rollup/plugin-image": "^2.0.5",
+    "@rollup/plugin-node-resolve": "^8.0.0",
+    "core-js": "^3.6.5",
+    "rollup": "^2.3.4",
+    "rollup-plugin-babel": "^4.4.0",
+    "rollup-plugin-livereload": "^2.0.0",
+    "rollup-plugin-polyfill": "^3.0.0",
+    "rollup-plugin-svelte": "^6.0.0",
+    "rollup-plugin-terser": "^7.0.0",
+    "svelte": "^3.0.0"
+  },
+  "dependencies": {
+    "sirv-cli": "^1.0.0",
+	  "@wailsapp/runtime": "^1.0.10",
+	  "svelte-simple-modal": "^0.6.0"
+  }
+}

cmd/templates/svelte/frontend/public/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset='utf-8'>
+	<meta name='viewport' content='width=device-width,initial-scale=1'>
+
+	<title>Svelte app</title>
+
+	<link rel='icon' type='image/png' href='/favicon.png'>
+	<link rel='stylesheet' href='/build/bundle.css'>
+
+	<script defer src='/build/bundle.js'></script>
+</head>
+
+<body>
+</body>
+</html>

cmd/templates/svelte/frontend/rollup.config.js

@@ -0,0 +1,110 @@
+import svelte from 'rollup-plugin-svelte';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import livereload from 'rollup-plugin-livereload';
+import { terser } from 'rollup-plugin-terser';
+import image from '@rollup/plugin-image';
+import babel from 'rollup-plugin-babel';
+import polyfill from 'rollup-plugin-polyfill';
+
+const production = !process.env.ROLLUP_WATCH;
+
+function serve() {
+	let server;
+	
+	function toExit() {
+		if (server) server.kill(0);
+	}
+
+	return {
+		writeBundle() {
+			if (server) return;
+			server = require('child_process').spawn('npm', ['run', 'start', '--', '--dev'], {
+				stdio: ['ignore', 'inherit', 'inherit'],
+				shell: true
+			});
+
+			process.on('SIGTERM', toExit);
+			process.on('exit', toExit);
+		}
+	};
+}
+
+export default {
+	input: 'src/main.js',
+	output: {
+		sourcemap: true,
+		format: 'iife',
+		name: 'app',
+		file: 'public/build/bundle.js'
+	},
+	plugins: [
+		image(),
+		svelte({
+			// enable run-time checks when not in production
+			dev: !production,
+			// we'll extract any component CSS out into
+			// a separate file - better for performance
+			css: css => {
+				css.write('bundle.css');
+			}
+		}),
+
+		// If you have external dependencies installed from
+		// npm, you'll most likely need these plugins. In
+		// some cases you'll need additional configuration -
+		// consult the documentation for details:
+		// https://github.com/rollup/plugins/tree/master/packages/commonjs
+		resolve({
+			browser: true,
+			dedupe: ['svelte', 'svelte/transition', 'svelte/internal']
+		}),
+		commonjs(),
+
+		// In dev mode, call `npm run start` once
+		// the bundle has been generated
+		!production && serve(),
+
+		// Watch the `public` directory and refresh the
+		// browser on changes when not in production
+		!production && livereload('public'),
+
+		// Credit: https://blog.az.sg/posts/svelte-and-ie11/
+		babel({
+			extensions: [ '.js', '.jsx', '.es6', '.es', '.mjs', '.svelte', '.html' ],
+			runtimeHelpers: true,
+			exclude: [ 'node_modules/@babel/**', 'node_modules/core-js/**' ],
+			presets: [
+			  [
+				'@babel/preset-env',
+				{
+				  targets: '> 0.25%, not dead, IE 11',
+				  modules: false,
+				  spec: true, 
+				  useBuiltIns: 'usage',
+				  forceAllTransforms: true,
+				  corejs: 3,
+				},
+
+			  ]
+			],
+			plugins: [
+			  '@babel/plugin-syntax-dynamic-import',
+			  [
+				'@babel/plugin-transform-runtime',
+				{
+				  useESModules: true
+				}
+			  ]
+			]
+		  }),
+		  polyfill(['@webcomponents/webcomponentsjs']),
+
+		// If we're building for production (npm run build
+		// instead of npm run dev), minify
+		production && terser()
+	],
+	watch: {
+		clearScreen: false
+	}
+};

cmd/templates/svelte/frontend/src/App.svelte

@@ -0,0 +1,69 @@
+
+
+<script>
+	import Modal from 'svelte-simple-modal';
+	import HelloWorld from './components/HelloWorld.svelte'
+	import logo from './logo.png';
+</script>
+
+<main>
+	<div class="App">
+		<header class="App-header">
+			<Modal>
+				<img src={logo} class="App-logo" alt="logo" />
+				<p>Welcome to your new <code>wails/svelte</code> project.</p>
+				<HelloWorld/>
+			</Modal>
+		</header>
+	</div>
+</main>
+
+<style>
+	:global(body) {
+		margin: 0;
+		font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen",
+			"Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
+			sans-serif;
+		-webkit-font-smoothing: antialiased;
+		-moz-osx-font-smoothing: grayscale;
+	}
+
+	code {
+		font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+	}
+
+	.App {
+		text-align: center;
+	}
+
+	.App-logo {
+		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;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		font-size: calc(10px + 2vmin);
+		color: white;
+	}
+
+	@keyframes App-logo-spin {
+		from {
+			transform: rotate(0deg);
+		}
+		to {
+			transform: rotate(360deg);
+		}
+	}
+</style>

cmd/templates/svelte/frontend/src/components/HelloWorld.svelte

@@ -0,0 +1,18 @@
+<script>
+	import { getContext } from 'svelte';
+	import ModalContent from './ModalContent.svelte'
+	
+	const { open } = getContext('simple-modal');
+
+	const handleOpenModal = () => {
+		window.backend.basic().then((result) => {
+			open(ModalContent, { message: result });
+		});
+	};
+</script>
+
+<main>
+	<p><button on:click={handleOpenModal}>Hello</button></p>
+</main>
+
+<style></style>

cmd/templates/svelte/frontend/src/components/ModalContent.svelte

@@ -0,0 +1,7 @@
+<script>
+	export let message;
+</script> 
+   
+<p>
+	{message}
+</p>

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

@@ -0,0 +1,13 @@
+import App from './App.svelte';
+
+import * as Wails from '@wailsapp/runtime';
+
+let app;
+
+Wails.Init(() => {
+	app = new App({
+		target: document.body,
+	});
+}); 
+
+export default app;

cmd/templates/svelte/go.mod.template

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

cmd/templates/svelte/main.go.template

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"github.com/leaanthony/mewn"
+	"github.com/wailsapp/wails"
+)
+
+func basic() string {
+	return "World!"
+}
+
+func main() {
+	js := mewn.String("./frontend/public/build/bundle.js")
+	css := mewn.String("./frontend/public/build/bundle.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/svelte/template.json

@@ -0,0 +1,14 @@
+{
+  "name": "Svelte",
+  "version": "1.0.0",
+  "shortdescription": "A basic Svelte template",
+  "description": "A basic Svelte template",
+  "install": "npm install",
+  "build": "npm run build",
+  "author": "Tim Kipp <timkipp.22.developer@gmail.com>",
+  "created": "2020-09-06 13:06:10.469848 -0700 PDT m=+213.578828559",
+  "frontenddir": "frontend",
+  "serve": "npm run dev",
+  "bridge": "src",
+  "wailsdir": ""
+}

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 = runtime.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( function(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/vue3-full/frontend/.browserslistrc

@@ -0,0 +1,3 @@
+> 1%
+last 2 versions
+not dead

cmd/templates/vue3-full/frontend/.eslintrc.js

@@ -0,0 +1,29 @@
+module.exports = {
+  root: true,
+  env: {
+    node: true
+  },
+  'extends': [
+    'plugin:vue/vue3-essential',
+    'eslint:recommended',
+    '@vue/typescript/recommended'
+  ],
+  parserOptions: {
+    ecmaVersion: 2020
+  },
+  rules: {
+    'no-console': process.env.NODE_ENV === 'production' ? 'warn' : 'off',
+    'no-debugger': process.env.NODE_ENV === 'production' ? 'warn' : 'off'
+  },
+  overrides: [
+    {
+      files: [
+        '**/__tests__/*.{j,t}s?(x)',
+        '**/tests/unit/**/*.spec.{j,t}s?(x)'
+      ],
+      env: {
+        mocha: true
+      }
+    }
+  ]
+}

cmd/templates/vue3-full/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/vue3-full/frontend/README.md

@@ -0,0 +1,35 @@
+# vue basic
+
+## Project setup
+
+```
+npm install
+```
+
+### Compiles and hot-reloads for development
+
+```
+npm run serve
+```
+
+### Compiles and minifies for production
+
+```
+npm run build
+```
+
+### Run your tests
+
+```
+npm run test
+```
+
+### Lints and fixes files
+
+```
+npm run lint
+```
+
+### Customize configuration
+
+See [Configuration Reference](https://cli.vuejs.org/config/).

cmd/templates/vue3-full/frontend/package.json.template

@@ -0,0 +1,37 @@
+{
+  "name": "{{.NPMProjectName}}",
+  "author": "{{.Author.Name}}<{{.Author.Email}}>",
+  "private": true,
+  "scripts": {
+    "serve": "vue-cli-service serve",
+    "build": "vue-cli-service build",
+    "test:unit": "vue-cli-service test:unit",
+    "lint": "vue-cli-service lint"
+  },
+  "dependencies": {
+    "vue": "^3.0.0-0",
+    "vue-router": "^4.0.0-0",
+    "regenerator-runtime": "^0.13.7",
+    "@wailsapp/runtime": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.12",
+    "@types/mocha": "^8.0.3",
+    "@typescript-eslint/eslint-plugin": "^4.3.0",
+    "@typescript-eslint/parser": "^4.3.0",
+    "@vue/cli-plugin-eslint": "~4.5.9",
+    "@vue/cli-plugin-router": "~4.5.9",
+    "@vue/cli-plugin-typescript": "~4.5.9",
+    "@vue/cli-plugin-unit-mocha": "~4.5.9",
+    "@vue/cli-service": "~4.5.9",
+    "@vue/compiler-sfc": "^3.0.0",
+    "@vue/eslint-config-typescript": "^7.0.0",
+    "@vue/test-utils": "^2.0.0-0",
+    "chai": "^4.2.0",
+    "eslint": "<7.0.0",
+    "eslint-plugin-vue": "^7.0.0",
+    "node-sass": "^4.14.1",
+    "sass-loader": "^10.0.2",
+    "typescript": "~4.0.3"
+  }
+}

cmd/templates/vue3-full/frontend/src/App.vue

@@ -0,0 +1,32 @@
+<template>
+  <div id=app>
+    <div id="nav">
+      <router-link to="/">Home</router-link> |
+      <router-link to="/about">About</router-link>
+    </div>
+    <router-view/>
+  </div>
+</template>
+
+<style lang="scss">
+#app {
+  font-family: Avenir, Helvetica, Arial, sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-align: center;
+  color: #2c3e50;
+}
+
+#nav {
+  padding: 30px;
+
+  a {
+    font-weight: bold;
+    color: #2c3e50;
+
+    &.router-link-exact-active {
+      color: #42b983;
+    }
+  }
+}
+</style>

cmd/templates/vue3-full/frontend/src/components/HelloWorld.vue

@@ -0,0 +1,34 @@
+<template>
+  <div class="hello">
+    <h1>{{ msg }}</h1>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  name: 'HelloWorld',
+  props: {
+    msg: String,
+  },
+});
+</script>
+
+<!-- Add "scoped" attribute to limit CSS to this component only -->
+<style scoped lang="scss">
+h3 {
+  margin: 40px 0 0;
+}
+ul {
+  list-style-type: none;
+  padding: 0;
+}
+li {
+  display: inline-block;
+  margin: 0 10px;
+}
+a {
+  color: #42b983;
+}
+</style>

cmd/templates/vue3-full/frontend/src/main.ts

@@ -0,0 +1,8 @@
+import { createApp } from 'vue';
+import App from './App.vue';
+import router from './router';
+import * as Wails from '@wailsapp/runtime';
+
+Wails.Init(() => {
+    createApp(App).use(router).mount('#app');
+});

cmd/templates/vue3-full/frontend/src/router/index.ts

@@ -0,0 +1,27 @@
+import { createRouter, createMemoryHistory, RouteRecordRaw } from 'vue-router'
+import Home from '../views/Home.vue'
+import About from '../views/About.vue'
+
+const routes: Array<RouteRecordRaw> = [
+  {
+    path: '/',
+    name: 'Home',
+    component: Home
+  },
+  {
+    path: '/about',
+    name: 'About',
+    // route level code-splitting
+    // this generates a separate chunk (about.[hash].js) for this route
+    // which is lazy-loaded when the route is visited.
+    // component: () => import(/* webpackChunkName: "about" */ '../views/About.vue')
+    component: About
+  }
+]
+
+const router = createRouter({
+  history: createMemoryHistory(),
+  routes
+})
+
+export default router

cmd/templates/vue3-full/frontend/src/shims-vue.d.ts

@@ -0,0 +1,5 @@
+declare module '*.vue' {
+  import { defineComponent } from 'vue'
+  const component: ReturnType<typeof defineComponent>
+  export default component
+}

cmd/templates/vue3-full/frontend/src/views/About.vue

@@ -0,0 +1,5 @@
+<template>
+  <div class="about">
+    <h1>This is an about page</h1>
+  </div>
+</template>

cmd/templates/vue3-full/frontend/src/views/Home.vue

@@ -0,0 +1,40 @@
+<template>
+  <div class="home">
+    <img @click="getMessage" alt="Vue logo" src="../assets/appicon.png" :style="{ height: '400px' }"/>
+    <HelloWorld :msg="message" />
+  </div>
+</template>
+
+<script lang="ts">
+import { ref, defineComponent } from "vue";
+import HelloWorld from "@/components/HelloWorld.vue"; // @ is an alias to /src
+
+interface Backend {
+  basic(): Promise<string>;
+}
+
+declare global {
+  interface Window {
+    backend: Backend;
+  }
+}
+
+export default defineComponent({
+  name: "Home",
+  components: {
+    HelloWorld,
+  },
+  setup() {
+    
+    const message = ref("Click the Icon");
+
+    const getMessage = () => {
+      window.backend.basic().then(result => {
+        message.value = result;
+      });
+    }
+
+    return { message: message, getMessage: getMessage };
+  },
+});
+</script>

cmd/templates/vue3-full/frontend/tests/unit/example.spec.ts

@@ -0,0 +1,14 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { shallowMount } from '@vue/test-utils';
+import HelloWorld from '@/components/HelloWorld.vue';
+
+describe('HelloWorld.vue', () => {
+	it('renders props.msg when passed', () => {
+		const msg = 'new message';
+		const wrapper = shallowMount(HelloWorld, {
+			props: { msg }
+		});
+		expect(wrapper.text()).to.include(msg);
+	});
+});

cmd/templates/vue3-full/frontend/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "esnext",
+    "strict": true,
+    "jsx": "preserve",
+    "importHelpers": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "types": [
+      "webpack-env",
+      "mocha",
+      "chai"
+    ],
+    "paths": {
+      "@/*": [
+        "src/*"
+      ]
+    },
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "scripthost"
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.vue",
+    "tests/**/*.ts",
+    "tests/**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

cmd/templates/vue3-full/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/vue3-full/go.mod.template

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

cmd/templates/vue3-full/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/vue3-full/template.json

@@ -0,0 +1,15 @@
+{
+  "name": "Vue3 Full",
+  "version": "1.0.0",
+  "shortdescription": "Vue 3, Vuex, Vue-router, and Webpack4",
+  "description": "Vue3.0.0 Vuex, Vue-router, and Webpack 4",
+  "install": "npm install",
+  "build": "npm run build",
+  "author": "Kyle Muchmore <kmuchmor@gmail.com>",
+  "created": "2020-09-24 21:18:55.09417 +0000 UTC m=+90.125590001",
+  "frontenddir": "frontend",
+  "serve": "npm run serve",
+  "bridge": "src",
+  "wailsdir": "",
+  "platforms": ["linux", "darwin"]
+}

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",
-    "vue": "^2.5.22",
-    "@wailsapp/runtime": "^1.0.0"
+    "core-js": "^3.6.4",
+    "regenerator-runtime": "^0.13.3",
+    "vue": "^2.6.11",
+    "@wailsapp/runtime": "^1.0.10"
   },
   "devDependencies": {
-    "@vue/cli-plugin-babel": "^3.4.0",
-    "@vue/cli-plugin-eslint": "^3.4.0",
-    "@vue/cli-service": "^3.4.0",
-    "babel-eslint": "^10.0.1",
-    "eslint": "^5.8.0",
-    "eslint-plugin-vue": "^5.0.0",
+    "@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.5.21",
-    "webpack-hot-middleware": "^2.24.3"
+    "vue-template-compiler": "^2.6.11",
+    "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,
-    host: "localhost"
+		disableHostCheck: true
   }
 };

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": {
-    "babel-polyfill": "^6.26.0",
-    "core-js": "^2.6.4",
+"dependencies": {
+    "core-js": "^3.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-eslint": "^3.4.0",
-    "@vue/cli-service": "^3.4.0",
-    "babel-eslint": "^10.0.1",
-    "eslint": "^5.8.0",
-    "eslint-plugin-vue": "^5.0.0",
+    "@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.5.21",
-    "webpack-hot-middleware": "^2.24.3"
+    "vue-template-compiler": "^2.6.11",
+    "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