Misc fixes for module build

Support both icon & text in tray

.gitignore

@@ -17,8 +17,13 @@ cmd/wails/wails
 .DS_Store
 tmp
 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/internal/ffenestri/runtime.c
-v2/internal/runtime/assets/desktop.js
 v2/test/kitchensink/build/darwin/desktop/kitchensink
 v2/test/kitchensink/frontend/package.json.md5

.vscode/settings.json

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

README.md

@@ -147,7 +147,12 @@ This project was mainly coded to the following albums:
 
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fwailsapp%2Fwails.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fwailsapp%2Fwails?ref=badge_large)
 
-## Special Thank You
+## 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/>

go.mod

@@ -22,7 +22,7 @@ require (
 	github.com/syossan27/tebata v0.0.0-20180602121909-b283fe4bc5ba
 	golang.org/x/image v0.0.0-20200430140353-33d19683fad8
 	golang.org/x/net v0.0.0-20200625001655-4c5254603344 // indirect
-	golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd
+	golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c
 	golang.org/x/text v0.3.0
 	gopkg.in/AlecAivazis/survey.v1 v1.8.4
 	gopkg.in/yaml.v3 v3.0.0-20190709130402-674ba3eaed22

go.sum

@@ -81,6 +81,8 @@ golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c h1:UIcGWL6/wpCfyGuJnRFJRurA+yj8RrW7Q6x2YMCXt6c=
+golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/AlecAivazis/survey.v1 v1.8.4 h1:10xXXN3wgIhPheb5NI58zFgZv32Ana7P3Tl4shW+0Qc=

v2/.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+    "files.associations": {
+        "ios": "c",
+        "typeinfo": "c",
+        "sstream": "c",
+        "__functional_03": "c",
+        "functional": "c",
+        "__locale": "c",
+        "locale": "c",
+        "chrono": "c",
+        "system_error": "c"
+    }
+}

v2/NOTES.md

@@ -0,0 +1,40 @@
+
+# Packing linux
+
+  * create app, app.desktop, app.png (512x512)
+  * chmod +x app!
+  * ./linuxdeploy-x86_64.AppImage --appdir AppDir -i react.png -d react.desktop  -e react --output appimage
+
+
+# Wails Doctor
+
+Tested on:
+
+  * Debian 8
+  * Ubuntu 20.04
+  * Ubuntu 19.10
+  * Solus 4.1
+  * Centos 8
+  * Gentoo
+  * OpenSUSE/leap
+  * Fedora 31
+
+### Development
+
+Add a new package manager processor here: `v2/internal/system/packagemanager/`. IsAvailable should work even if the package is installed.
+Add your new package manager to the list of package managers in `v2/internal/system/packagemanager/packagemanager.go`:
+
+```
+var db = map[string]PackageManager{
+	"eopkg":  NewEopkg(),
+	"apt":    NewApt(),
+	"yum":    NewYum(),
+	"pacman": NewPacman(),
+	"emerge": NewEmerge(),
+	"zypper": NewZypper(),
+}
+```
+
+## Gentoo
+
+  * Setup docker image using: emerge-webrsync -x -v

v2/README.md

@@ -0,0 +1,5 @@
+# Wails v2 ALPHA
+
+This branch contains WORK IN PROGRESS! There are no guarantees. Use at your peril! 
+
+This document will be updated as progress is made.

v2/cmd/wails/internal/commands/build/build.go

@@ -0,0 +1,119 @@
+package build
+
+import (
+	"fmt"
+	"io"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/leaanthony/clir"
+	"github.com/leaanthony/slicer"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/commands/build"
+)
+
+// AddBuildSubcommand adds the `build` command for the Wails application
+func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
+
+	outputType := "desktop"
+
+	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
+
+	command := app.NewSubCommand("build", "Builds the application")
+
+	// Setup target type flag
+	description := "Type of application to build. Valid types: " + validTargetTypes.Join(",")
+	command.StringFlag("t", description, &outputType)
+
+	// Setup production flag
+	production := false
+	command.BoolFlag("production", "Build in production mode", &production)
+
+	// Setup pack flag
+	pack := false
+	command.BoolFlag("package", "Create a platform specific package", &pack)
+
+	compilerCommand := "go"
+	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
+
+	// Setup Platform flag
+	platform := runtime.GOOS
+	command.StringFlag("platform", "Platform to target", &platform)
+
+	// Quiet Build
+	quiet := false
+	command.BoolFlag("q", "Suppress output to console", &quiet)
+
+	// ldflags to pass to `go`
+	ldflags := ""
+	command.StringFlag("ldflags", "optional ldflags", &ldflags)
+
+	// Log to file
+	logFile := ""
+	command.StringFlag("l", "Log to file", &logFile)
+
+	// Retain assets
+	keepAssets := false
+	command.BoolFlag("k", "Keep generated assets", &keepAssets)
+
+	command.Action(func() error {
+
+		// Create logger
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
+
+		// Validate output type
+		if !validTargetTypes.Contains(outputType) {
+			return fmt.Errorf("output type '%s' is not valid", outputType)
+		}
+
+		if !quiet {
+			app.PrintBanner()
+		}
+
+		task := fmt.Sprintf("Building %s Application", strings.Title(outputType))
+		logger.Println(task)
+		logger.Println(strings.Repeat("-", len(task)))
+
+		// Setup mode
+		mode := build.Debug
+		if production {
+			mode = build.Production
+		}
+
+		// Create BuildOptions
+		buildOptions := &build.Options{
+			Logger:     logger,
+			OutputType: outputType,
+			Mode:       mode,
+			Pack:       pack,
+			Platform:   platform,
+			LDFlags:    ldflags,
+			Compiler:   compilerCommand,
+			KeepAssets: keepAssets,
+		}
+
+		return doBuild(buildOptions)
+	})
+}
+
+// doBuild is our main build command
+func doBuild(buildOptions *build.Options) error {
+
+	// Start Time
+	start := time.Now()
+
+	outputFilename, err := build.Build(buildOptions)
+	if err != nil {
+		return err
+	}
+
+	// Output stats
+	elapsed := time.Since(start)
+	buildOptions.Logger.Println("")
+	buildOptions.Logger.Println(fmt.Sprintf("Built '%s' in %s.", outputFilename, elapsed.Round(time.Millisecond).String()))
+	buildOptions.Logger.Println("")
+
+	return nil
+}

v2/cmd/wails/internal/commands/dev/dev.go

@@ -0,0 +1,261 @@
+package dev
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/leaanthony/clir"
+	"github.com/leaanthony/slicer"
+	"github.com/wailsapp/wails/v2/internal/fs"
+	"github.com/wailsapp/wails/v2/internal/process"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/commands/build"
+)
+
+// AddSubcommand adds the `dev` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	command := app.NewSubCommand("dev", "Development mode")
+
+	outputType := "desktop"
+
+	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
+
+	// Setup target type flag
+	description := "Type of application to develop. Valid types: " + validTargetTypes.Join(",")
+	command.StringFlag("t", description, &outputType)
+
+	// Passthrough ldflags
+	ldflags := ""
+	command.StringFlag("ldflags", "optional ldflags", &ldflags)
+
+	// compiler command
+	compilerCommand := "go"
+	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
+
+	// extensions to trigger rebuilds
+	extensions := "go"
+	command.StringFlag("m", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+
+	command.Action(func() error {
+
+		// Validate inputs
+		if !validTargetTypes.Contains(outputType) {
+			return fmt.Errorf("output type '%s' is not valid", outputType)
+		}
+
+		// Create logger
+		logger := clilogger.New(w)
+		app.PrintBanner()
+
+		// TODO: Check you are in a project directory
+
+		watcher, err := fsnotify.NewWatcher()
+		if err != nil {
+			return err
+		}
+		defer watcher.Close()
+
+		var debugBinaryProcess *process.Process = nil
+		var buildFrontend bool = true
+		var extensionsThatTriggerARebuild = strings.Split(extensions, ",")
+
+		// Setup signal handler
+		quitChannel := make(chan os.Signal, 1)
+		signal.Notify(quitChannel, os.Interrupt, os.Kill, syscall.SIGTERM)
+
+		debounceQuit := make(chan bool, 1)
+
+		// Do initial build
+		logger.Println("Building application for development...")
+		debugBinaryProcess = restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
+
+		go debounce(100*time.Millisecond, watcher.Events, debounceQuit, func(event fsnotify.Event) {
+			// logger.Println("event: %+v", event)
+
+			// Check for new directories
+			if event.Op&fsnotify.Create == fsnotify.Create {
+				// If this is a folder, add it to our watch list
+				if fs.DirExists(event.Name) {
+					if !strings.Contains(event.Name, "node_modules") {
+						watcher.Add(event.Name)
+						logger.Println("Watching directory: %s", event.Name)
+					}
+				}
+				return
+			}
+
+			// Check for file writes
+			if event.Op&fsnotify.Write == fsnotify.Write {
+
+				// logger.Println("modified file: %s", event.Name)
+				var rebuild bool = false
+
+				// Iterate all file patterns
+				for _, pattern := range extensionsThatTriggerARebuild {
+					rebuild = strings.HasSuffix(event.Name, pattern)
+					if err != nil {
+						logger.Fatal(err.Error())
+					}
+					if rebuild {
+						// Only build frontend when the file isn't a Go file
+						buildFrontend = !strings.HasSuffix(event.Name, "go")
+						break
+					}
+				}
+
+				if !rebuild {
+					logger.Println("Filename change: %s did not match extension list %s", event.Name, extensions)
+					return
+				}
+
+				if buildFrontend {
+					logger.Println("Full rebuild triggered: %s updated", event.Name)
+				} else {
+					logger.Println("Partial build triggered: %s updated", event.Name)
+				}
+
+				// Do a rebuild
+
+				// Try and build the app
+				newBinaryProcess := restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
+
+				// If we have a new process, save it
+				if newBinaryProcess != nil {
+					debugBinaryProcess = newBinaryProcess
+				}
+
+			}
+		})
+
+		// Get project dir
+		dir, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+
+		// Get all subdirectories
+		dirs, err := fs.GetSubdirectories(dir)
+		if err != nil {
+			return err
+		}
+
+		// Setup a watcher for non-node_modules directories
+		dirs.Each(func(dir string) {
+			if strings.Contains(dir, "node_modules") {
+				return
+			}
+			logger.Println("Watching directory: %s", dir)
+			err = watcher.Add(dir)
+			if err != nil {
+				logger.Fatal(err.Error())
+			}
+		})
+
+		// Wait until we get a quit signal
+		quit := false
+		for quit == false {
+			select {
+			case <-quitChannel:
+				println()
+				// Notify debouncer to quit
+				debounceQuit <- true
+				quit = true
+			}
+		}
+
+		// Kill the current program if running
+		if debugBinaryProcess != nil {
+			debugBinaryProcess.Kill()
+		}
+
+		logger.Println("Development mode exited")
+
+		return nil
+	})
+
+	return nil
+}
+
+// Credit: https://drailing.net/2018/01/debounce-function-for-golang/
+func debounce(interval time.Duration, input chan fsnotify.Event, quitChannel chan bool, cb func(arg fsnotify.Event)) {
+	var item fsnotify.Event
+	timer := time.NewTimer(interval)
+exit:
+	for {
+		select {
+		case item = <-input:
+			timer.Reset(interval)
+		case <-timer.C:
+			if item.Name != "" {
+				cb(item)
+			}
+		case <-quitChannel:
+			break exit
+		}
+	}
+}
+
+func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool, debugBinaryProcess *process.Process) *process.Process {
+
+	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand, buildFrontend)
+	println()
+	if err != nil {
+		logger.Println("[ERROR] Build Failed: %s", err.Error())
+		return nil
+	}
+	logger.Println("Build new binary: %s", appBinary)
+
+	// Kill existing binary if need be
+	if debugBinaryProcess != nil {
+		killError := debugBinaryProcess.Kill()
+
+		if killError != nil {
+			logger.Fatal("Unable to kill debug binary (PID: %d)!", debugBinaryProcess.PID())
+		}
+
+		debugBinaryProcess = nil
+	}
+
+	// TODO: Generate `backend.js`
+
+	// Start up new binary
+	newProcess := process.NewProcess(logger, appBinary)
+	err = newProcess.Start()
+	if err != nil {
+		// Remove binary
+		fs.DeleteFile(appBinary)
+		logger.Fatal("Unable to start application: %s", err.Error())
+	}
+
+	return newProcess
+}
+
+func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool) (string, error) {
+
+	// Create random output file
+	outputFile := fmt.Sprintf("debug-%d", time.Now().Unix())
+
+	// Create BuildOptions
+	buildOptions := &build.Options{
+		Logger:         logger,
+		OutputType:     outputType,
+		Mode:           build.Debug,
+		Pack:           false,
+		Platform:       runtime.GOOS,
+		LDFlags:        ldflags,
+		Compiler:       compilerCommand,
+		OutputFile:     outputFile,
+		IgnoreFrontend: !buildFrontend,
+	}
+
+	return build.Build(buildOptions)
+
+}

v2/cmd/wails/internal/commands/doctor/doctor.go

@@ -0,0 +1,154 @@
+package doctor
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"runtime"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/internal/system"
+	"github.com/wailsapp/wails/v2/internal/system/packagemanager"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+)
+
+// AddSubcommand adds the `doctor` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	command := app.NewSubCommand("doctor", "Diagnose your environment")
+
+	command.Action(func() error {
+
+		logger := clilogger.New(w)
+
+		app.PrintBanner()
+		logger.Print("Scanning system - please wait...")
+
+		// Get system info
+		info, err := system.GetInfo()
+		if err != nil {
+			return err
+		}
+		logger.Println("Done.")
+
+		// Start a new tabwriter
+		w := new(tabwriter.Writer)
+		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
+
+		// Write out the system information
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "System\n")
+		fmt.Fprintf(w, "------\n")
+		fmt.Fprintf(w, "%s\t%s\n", "OS:", info.OS.Name)
+		fmt.Fprintf(w, "%s\t%s\n", "Version: ", info.OS.Version)
+		fmt.Fprintf(w, "%s\t%s\n", "ID:", info.OS.ID)
+
+		// Exit early if PM not found
+		if info.PM == nil {
+			fmt.Fprintf(w, "\n%s\t%s", "Package Manager:", "Not Found")
+			w.Flush()
+			println()
+			return nil
+		}
+		fmt.Fprintf(w, "%s\t%s\n", "Package Manager: ", info.PM.Name())
+
+		// Output Go Information
+		fmt.Fprintf(w, "%s\t%s\n", "Go Version:", runtime.Version())
+		fmt.Fprintf(w, "%s\t%s\n", "Platform:", runtime.GOOS)
+		fmt.Fprintf(w, "%s\t%s\n", "Architecture:", runtime.GOARCH)
+
+		// Output Dependencies Status
+		var dependenciesMissing = []string{}
+		var externalPackages = []*packagemanager.Dependancy{}
+		var dependenciesAvailableRequired = 0
+		var dependenciesAvailableOptional = 0
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "Dependency\tPackage Name\tStatus\tVersion\n")
+		fmt.Fprintf(w, "----------\t------------\t------\t-------\n")
+
+		// Loop over dependencies
+		for _, dependency := range info.Dependencies {
+
+			name := dependency.Name
+			if dependency.Optional {
+				name += "*"
+			}
+			packageName := "Unknown"
+			status := "Not Found"
+
+			// If we found the package
+			if dependency.PackageName != "" {
+
+				packageName = dependency.PackageName
+
+				// If it's installed, update the status
+				if dependency.Installed {
+					status = "Installed"
+				} else {
+					// Generate meaningful status text
+					status = "Available"
+
+					if dependency.Optional {
+						dependenciesAvailableOptional++
+					} else {
+						dependenciesAvailableRequired++
+					}
+				}
+			} else {
+				if !dependency.Optional {
+					dependenciesMissing = append(dependenciesMissing, dependency.Name)
+				}
+
+				if dependency.External {
+					externalPackages = append(externalPackages, dependency)
+				}
+			}
+
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", name, packageName, status, dependency.Version)
+		}
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "* - Optional Dependency\n")
+		w.Flush()
+		logger.Println("")
+		logger.Println("Diagnosis")
+		logger.Println("---------\n")
+
+		// Generate an appropriate diagnosis
+
+		if len(dependenciesMissing) == 0 && dependenciesAvailableRequired == 0 {
+			logger.Println("Your system is ready for Wails development!")
+		}
+
+		if dependenciesAvailableRequired != 0 {
+			log.Println("Install required packages using: " + info.Dependencies.InstallAllRequiredCommand())
+		}
+
+		if dependenciesAvailableOptional != 0 {
+			log.Println("Install optional packages using: " + info.Dependencies.InstallAllOptionalCommand())
+		}
+
+		if len(externalPackages) > 0 {
+			for _, p := range externalPackages {
+				if p.Optional {
+					print("[Optional] ")
+				}
+				log.Println("Install " + p.Name + ": " + p.InstallCommand)
+			}
+		}
+
+		if len(dependenciesMissing) != 0 {
+			// TODO: Check if apps are available locally and if so, adjust the diagnosis
+			log.Println("Fatal:")
+			log.Println("Required dependencies missing: " + strings.Join(dependenciesMissing, " "))
+			log.Println("Please read this article on how to resolve this: https://wails.app/guides/resolving-missing-packages")
+		}
+
+		log.Println("")
+		return nil
+	})
+
+	return nil
+}

v2/cmd/wails/internal/commands/generate/generate.go

@@ -0,0 +1,91 @@
+package generate
+
+import (
+	"io"
+	"time"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/parser"
+)
+
+// AddSubcommand adds the `dev` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	command := app.NewSubCommand("generate", "Code Generation Tools")
+
+	// Backend API
+	backendAPI := command.NewSubCommand("module", "Generates a JS module for the frontend to interface with the backend")
+
+	// Quiet Init
+	quiet := false
+	backendAPI.BoolFlag("q", "Supress output to console", &quiet)
+
+	backendAPI.Action(func() error {
+
+		// Create logger
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
+
+		app.PrintBanner()
+
+		logger.Print("Generating Javascript module for Go code...")
+
+		// Start Time
+		start := time.Now()
+
+		p, err := parser.GenerateWailsFrontendPackage()
+		if err != nil {
+			return err
+		}
+
+		logger.Println("done.")
+		logger.Println("")
+
+		elapsed := time.Since(start)
+		packages := p.Packages
+
+		// Print report
+		for _, pkg := range p.Packages {
+			if pkg.ShouldGenerate() {
+				logPackage(pkg, logger)
+			}
+
+		}
+
+		logger.Println("%d packages parsed in %s.", len(packages), elapsed)
+
+		return nil
+
+	})
+	return nil
+}
+
+func logPackage(pkg *parser.Package, logger *clilogger.CLILogger) {
+
+	logger.Println("Processed Go package '" + pkg.Gopackage.Name + "' as '" + pkg.Name + "'")
+	for _, strct := range pkg.Structs() {
+		logger.Println("")
+		logger.Println("  Processed struct '" + strct.Name + "'")
+		if strct.IsBound {
+			for _, method := range strct.Methods {
+				logger.Println("    Bound method '" + method.Name + "'")
+			}
+		}
+		if strct.IsUsedAsData {
+			for _, field := range strct.Fields {
+				if !field.Ignored {
+					logger.Print("    Processed ")
+					if field.IsOptional {
+						logger.Print("optional ")
+					}
+					logger.Println("field '" + field.Name + "' as '" + field.JSName() + "'")
+				}
+			}
+		}
+	}
+	logger.Println("")
+
+	// logger.Println("  Original Go Package Path:", pkg.Gopackage.PkgPath)
+	// logger.Println("  Original Go Package Path:", pkg.Gopackage.PkgPath)
+}

v2/cmd/wails/internal/commands/initialise/initialise.go

@@ -0,0 +1,182 @@
+package initialise
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"github.com/leaanthony/clir"
+	"github.com/pkg/errors"
+	"github.com/wailsapp/wails/v2/internal/templates"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/git"
+)
+
+// AddSubcommand adds the `init` command for the Wails application
+func AddSubcommand(app *clir.Cli, w io.Writer) error {
+
+	// Load the template shortnames
+	validShortNames, err := templates.TemplateShortNames()
+	if err != nil {
+		return err
+	}
+
+	command := app.NewSubCommand("init", "Initialise a new Wails project")
+
+	// Setup template name flag
+	templateName := "vanilla"
+	description := "Name of template to use. Valid tempates: " + validShortNames.Join(" ")
+	command.StringFlag("t", description, &templateName)
+
+	// Setup project name
+	projectName := ""
+	command.StringFlag("n", "Name of project", &projectName)
+
+	// Setup project directory
+	projectDirectory := ""
+	command.StringFlag("d", "Project directory", &projectDirectory)
+
+	// Quiet Init
+	quiet := false
+	command.BoolFlag("q", "Supress output to console", &quiet)
+
+	initGit := false
+	gitInstalled := git.IsInstalled()
+	if gitInstalled {
+		// Git Init
+		command.BoolFlag("g", "Initialise git repository", &initGit)
+	}
+
+	// VSCode project files
+	vscode := false
+	command.BoolFlag("vscode", "Generate VSCode project files", &vscode)
+
+	// List templates
+	list := false
+	command.BoolFlag("l", "List templates", &list)
+
+	command.Action(func() error {
+
+		// Create logger
+		logger := clilogger.New(w)
+		logger.Mute(quiet)
+
+		// Are we listing templates?
+		if list {
+			app.PrintBanner()
+			err := templates.OutputList(logger)
+			logger.Println("")
+			return err
+		}
+
+		// Validate output type
+		if !validShortNames.Contains(templateName) {
+			logger.Print(fmt.Sprintf("[ERROR] Template '%s' is not valid", templateName))
+			logger.Println("")
+			command.PrintHelp()
+			return nil
+		}
+
+		// Validate name
+		if len(projectName) == 0 {
+			logger.Println("ERROR: Project name required")
+			logger.Println("")
+			command.PrintHelp()
+			return nil
+		}
+
+		if !quiet {
+			app.PrintBanner()
+		}
+
+		task := fmt.Sprintf("Initialising Project %s", strings.Title(projectName))
+		logger.Println(task)
+		logger.Println(strings.Repeat("-", len(task)))
+
+		// Create Template Options
+		options := &templates.Options{
+			ProjectName:    projectName,
+			TargetDir:      projectDirectory,
+			TemplateName:   templateName,
+			Logger:         logger,
+			GenerateVSCode: vscode,
+			InitGit:        initGit,
+		}
+
+		// Try to discover author details from git config
+		err := findAuthorDetails(options)
+		if err != nil {
+			return err
+		}
+
+		return initProject(options)
+	})
+
+	return nil
+}
+
+// initProject is our main init command
+func initProject(options *templates.Options) error {
+
+	// Start Time
+	start := time.Now()
+
+	// Install the template
+	err := templates.Install(options)
+	if err != nil {
+		return err
+	}
+
+	if options.InitGit {
+		err = initGit(options)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Output stats
+	elapsed := time.Since(start)
+	options.Logger.Println("")
+	options.Logger.Println("Project Name:      " + options.ProjectName)
+	options.Logger.Println("Project Directory: " + options.TargetDir)
+	options.Logger.Println("Project Template:  " + options.TemplateName)
+	if options.GenerateVSCode {
+		options.Logger.Println("VSCode config files generated.")
+	}
+	if options.InitGit {
+		options.Logger.Println("Git repository initialised.")
+	}
+	options.Logger.Println("")
+	options.Logger.Println(fmt.Sprintf("Initialised project '%s' in %s.", options.ProjectName, elapsed.Round(time.Millisecond).String()))
+	options.Logger.Println("")
+
+	return nil
+}
+
+func initGit(options *templates.Options) error {
+	err := git.InitRepo(options.TargetDir)
+	if err != nil {
+		return errors.Wrap(err, "Unable to initialise git repository:")
+	}
+
+	return nil
+}
+
+func findAuthorDetails(options *templates.Options) error {
+	if git.IsInstalled() {
+		name, err := git.Name()
+		if err != nil {
+			return err
+		}
+		options.AuthorName = strings.TrimSpace(name)
+
+		email, err := git.Email()
+		if err != nil {
+			return err
+		}
+		options.AuthorEmail = strings.TrimSpace(email)
+	}
+
+	return nil
+}

v2/cmd/wails/main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"os"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/build"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/dev"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/doctor"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/generate"
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/initialise"
+)
+
+func fatal(message string) {
+	println(message)
+	os.Exit(1)
+}
+
+func main() {
+
+	var err error
+	version := "v2.0.0-alpha"
+
+	app := clir.NewCli("Wails", "Go/HTML Application Framework", version)
+
+	build.AddBuildSubcommand(app, os.Stdout)
+	err = initialise.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+	err = doctor.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+
+	err = dev.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+
+	err = generate.AddSubcommand(app, os.Stdout)
+	if err != nil {
+		fatal(err.Error())
+	}
+
+	err = app.Run()
+	if err != nil {
+		println("\n\nERROR: " + err.Error())
+	}
+}

v2/go.mod

@@ -0,0 +1,28 @@
+module github.com/wailsapp/wails/v2
+
+go 1.13
+
+require (
+	github.com/davecgh/go-spew v1.1.1
+	github.com/fatih/structtag v1.2.0
+	github.com/fsnotify/fsnotify v1.4.9
+	github.com/imdario/mergo v0.3.11
+	github.com/jackmordaunt/icns v1.0.0
+	github.com/leaanthony/clir v1.0.4
+	github.com/leaanthony/gosod v0.0.4
+	github.com/leaanthony/slicer v1.5.0
+	github.com/matryer/is v1.4.0
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/olekukonko/tablewriter v0.0.4
+	github.com/pkg/errors v0.9.1
+	github.com/tdewolff/minify v2.3.6+incompatible
+	github.com/tdewolff/parse v2.3.4+incompatible // indirect
+	github.com/tdewolff/test v1.0.6 // indirect
+	github.com/xyproto/xpm v1.2.1
+	golang.org/x/net v0.0.0-20200822124328-c89045814202
+	golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c
+	golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82
+	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
+	nhooyr.io/websocket v1.8.6
+)

v2/go.sum

@@ -0,0 +1,134 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
+github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14=
+github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
+github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
+github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
+github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
+github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
+github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5 h1:F768QJ1E9tib+q5Sc8MkdJi1RxLTbRcTf8LJV56aRls=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
+github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
+github.com/jackmordaunt/icns v1.0.0 h1:RYSxplerf/l/DUd09AHtITwckkv/mqjVv4DjYdPmAMQ=
+github.com/jackmordaunt/icns v1.0.0/go.mod h1:7TTQVEuGzVVfOPPlLNHJIkzA6CoV7aH1Dv9dW351oOo=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/klauspost/compress v1.10.3 h1:OP96hzwJVBIHYU52pVTI6CczrxPvrGfgqF9N5eTO0Q8=
+github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/leaanthony/clir v1.0.4 h1:Dov2y9zWJmZr7CjaCe86lKa4b5CSxskGAt2yBkoDyiU=
+github.com/leaanthony/clir v1.0.4/go.mod h1:k/RBkdkFl18xkkACMCLt09bhiZnrGORoxmomeMvDpE0=
+github.com/leaanthony/gosod v0.0.4 h1:v4hepo4IyL8E8c9qzDsvYcA0KGh7Npf8As74K5ibQpI=
+github.com/leaanthony/gosod v0.0.4/go.mod h1:nGMCb1PJfXwBDbOAike78jEYlpqge+xUKFf0iBKjKxU=
+github.com/leaanthony/slicer v1.5.0 h1:aHYTN8xbCCLxJmkNKiLB6tgcMARl4eWmH9/F+S/0HtY=
+github.com/leaanthony/slicer v1.5.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
+github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/olekukonko/tablewriter v0.0.4 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8=
+github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/tdewolff/minify v2.3.6+incompatible h1:2hw5/9ZvxhWLvBUnHE06gElGYz+Jv9R4Eys0XUzItYo=
+github.com/tdewolff/minify v2.3.6+incompatible/go.mod h1:9Ov578KJUmAWpS6NeZwRZyT56Uf6o3Mcz9CEsg8USYs=
+github.com/tdewolff/parse v2.3.4+incompatible h1:x05/cnGwIMf4ceLuDMBOdQ1qGniMoxpP46ghf0Qzh38=
+github.com/tdewolff/parse v2.3.4+incompatible/go.mod h1:8oBwCsVmUkgHO8M5iCzSIDtpzXOT0WXX9cWhz+bIzJQ=
+github.com/tdewolff/test v1.0.6 h1:76mzYJQ83Op284kMT+63iCNCI7NEERsIN8dLM+RiKr4=
+github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/xyproto/xpm v1.2.1 h1:trdvGjjWBsOOKzBBUPT6JvaIQM3acJEEYfbxN7M96wg=
+github.com/xyproto/xpm v1.2.1/go.mod h1:cMnesLsD0PBXLgjDfTDEaKr8XyTFsnP1QycSqRw7BiY=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200822124328-c89045814202 h1:VvcQYSHwXgi7W+TpUR6A9g6Up98WAHf3f/ulnJ62IyA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9 h1:L2auWcuQIvxz9xSEqzESnV/QN/gNRXNApHi3fYwl2w0=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c h1:UIcGWL6/wpCfyGuJnRFJRurA+yj8RrW7Q6x2YMCXt6c=
+golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e h1:FDhOuMEY4JVRztM/gsbk+IKUQ8kj74bxZrgw87eMMVc=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82 h1:shxDsb9Dz27xzk3A0DxP0JuJnZMpKrdg8+E14eiUAX4=
+golang.org/x/tools v0.0.0-20200902012652-d1954cc86c82/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k=
+nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0=

v2/internal/app/debug.go

@@ -0,0 +1,12 @@
+// +build debug
+
+package app
+
+// Init initialises the application for a debug environment
+func (a *App) Init() error {
+	// Indicate debug mode
+	a.debug = true
+	// Enable dev tools
+	a.options.DevTools = true
+	return nil
+}

v2/internal/app/default.go

@@ -0,0 +1,44 @@
+// +build !desktop,!hybrid,!server
+
+package app
+
+// This is the default application that will get run if the user compiles using `go build`.
+// The reason we want to prevent that is that the `wails build` command does a lot of behind
+// the scenes work such as asset compilation. If we allow `go build`, the state of these assets
+// will be unknown and the application will not work as expected.
+
+import (
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"os"
+
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// App defines a Wails application structure
+type App struct {
+	Title     string
+	Width     int
+	Height    int
+	Resizable bool
+
+	// Indicates if the app is running in debug mode
+	debug bool
+
+	logger *logger.Logger
+}
+
+// CreateApp returns a null application
+func CreateApp(_ *options.App) (*App, error) {
+	return &App{}, nil
+}
+
+// Run the application
+func (a *App) Run() error {
+	println(`FATAL: This application was built using "go build". This is unsupported. Please compile using "wails build".`)
+	os.Exit(1)
+	return nil
+}
+
+// Bind the dummy interface
+func (a *App) Bind(_ interface{}) {
+}

v2/internal/app/desktop.go

@@ -0,0 +1,233 @@
+// +build desktop,!server
+
+package app
+
+import (
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/ffenestri"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/runtime"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/internal/signal"
+	"github.com/wailsapp/wails/v2/internal/subsystem"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// App defines a Wails application structure
+type App struct {
+	window     *ffenestri.Application
+	servicebus *servicebus.ServiceBus
+	logger     *logger.Logger
+	signal     *signal.Manager
+	options    *options.App
+
+	// Subsystems
+	log          *subsystem.Log
+	runtime      *subsystem.Runtime
+	event        *subsystem.Event
+	binding      *subsystem.Binding
+	call         *subsystem.Call
+	menu         *subsystem.Menu
+	tray         *subsystem.Tray
+	contextmenus *subsystem.ContextMenus
+	dispatcher   *messagedispatcher.Dispatcher
+
+	// Indicates if the app is in debug mode
+	debug bool
+
+	// This is our binding DB
+	bindings *binding.Bindings
+
+	// Application Stores
+	loglevelStore  *runtime.Store
+	appconfigStore *runtime.Store
+}
+
+// Create App
+func CreateApp(appoptions *options.App) (*App, error) {
+
+	// Merge default options
+	options.MergeDefaults(appoptions)
+
+	// Set up logger
+	myLogger := logger.New(appoptions.Logger)
+	myLogger.SetLogLevel(appoptions.LogLevel)
+
+	window := ffenestri.NewApplicationWithConfig(appoptions, myLogger)
+
+	result := &App{
+		window:     window,
+		servicebus: servicebus.New(myLogger),
+		logger:     myLogger,
+		bindings:   binding.NewBindings(myLogger),
+	}
+
+	result.options = appoptions
+
+	// Initialise the app
+	err := result.Init()
+
+	return result, err
+
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	var err error
+
+	// Setup signal handler
+	signalsubsystem, err := signal.NewManager(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.signal = signalsubsystem
+	a.signal.Start()
+
+	// Start the service bus
+	a.servicebus.Debug()
+	err = a.servicebus.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the runtime
+	applicationMenu := options.GetApplicationMenu(a.options)
+	trayMenu := options.GetTray(a.options)
+	contextMenus := options.GetContextMenus(a.options)
+
+	runtimesubsystem, err := subsystem.NewRuntime(a.servicebus, a.logger, applicationMenu, trayMenu, contextMenus)
+	if err != nil {
+		return err
+	}
+	a.runtime = runtimesubsystem
+	err = a.runtime.Start()
+	if err != nil {
+		return err
+	}
+
+	// Application Stores
+	a.loglevelStore = a.runtime.GoRuntime().Store.New("wails:loglevel", a.options.LogLevel)
+	a.appconfigStore = a.runtime.GoRuntime().Store.New("wails:appconfig", a.options)
+
+	// Start the binding subsystem
+	bindingsubsystem, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, a.runtime.GoRuntime())
+	if err != nil {
+		return err
+	}
+	a.binding = bindingsubsystem
+	err = a.binding.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the logging subsystem
+	log, err := subsystem.NewLog(a.servicebus, a.logger, a.loglevelStore)
+	if err != nil {
+		return err
+	}
+	a.log = log
+	err = a.log.Start()
+	if err != nil {
+		return err
+	}
+
+	// create the dispatcher
+	dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.dispatcher = dispatcher
+	err = dispatcher.Start()
+	if err != nil {
+		return err
+	}
+
+	// Start the eventing subsystem
+	event, err := subsystem.NewEvent(a.servicebus, a.logger)
+	if err != nil {
+		return err
+	}
+	a.event = event
+	err = a.event.Start()
+	if err != nil {
+		return err
+	}
+
+	// Optionally start the menu subsystem
+	if applicationMenu != nil {
+		menusubsystem, err := subsystem.NewMenu(applicationMenu, a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.menu = menusubsystem
+		err = a.menu.Start()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Optionally start the tray subsystem
+	if trayMenu != nil {
+		traysubsystem, err := subsystem.NewTray(trayMenu, a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.tray = traysubsystem
+		err = a.tray.Start()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Optionally start the context menu subsystem
+	if contextMenus != nil {
+		contextmenussubsystem, err := subsystem.NewContextMenus(contextMenus, a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.contextmenus = contextmenussubsystem
+		err = a.contextmenus.Start()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Start the call subsystem
+	call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB(), a.runtime.GoRuntime())
+	if err != nil {
+		return err
+	}
+	a.call = call
+	err = a.call.Start()
+	if err != nil {
+		return err
+	}
+
+	// Dump bindings as a debug
+	bindingDump, err := a.bindings.ToJSON()
+	if err != nil {
+		return err
+	}
+
+	result := a.window.Run(dispatcher, bindingDump, a.debug)
+	a.logger.Trace("Ffenestri.Run() exited")
+	err = a.servicebus.Stop()
+	if err != nil {
+		return err
+	}
+
+	return result
+}
+
+// Bind a struct to the application by passing in
+// a pointer to it
+func (a *App) Bind(structPtr interface{}) {
+
+	// Add the struct to the bindings
+	err := a.bindings.Add(structPtr)
+	if err != nil {
+		a.logger.Fatal("Error during binding: " + err.Error())
+	}
+}

v2/internal/app/hybrid.go

@@ -0,0 +1,205 @@
+// +build !server,!desktop,hybrid
+
+package app
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/ffenestri"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/internal/subsystem"
+	"github.com/wailsapp/wails/v2/internal/webserver"
+)
+
+// Config defines the Application's configuration
+type Config struct {
+	Title         string // Title is the value to be displayed in the title bar
+	Width         int    // Width is the desired window width
+	Height        int    // Height is the desired window height
+	DevTools      bool   // DevTools enables or disables the browser development tools
+	Resizable     bool   // Resizable when False prevents window resizing
+	ServerEnabled bool   // ServerEnabled when True allows remote connections
+}
+
+// App defines a Wails application structure
+type App struct {
+	config    Config
+	window    *ffenestri.Application
+	webserver *webserver.WebServer
+	binding   *subsystem.Binding
+	call      *subsystem.Call
+	event     *subsystem.Event
+	log       *subsystem.Log
+	runtime   *subsystem.Runtime
+
+	bindings   *binding.Bindings
+	logger     *logger.Logger
+	dispatcher *messagedispatcher.Dispatcher
+	servicebus *servicebus.ServiceBus
+
+	debug bool
+}
+
+// Create App
+func CreateApp(options *Options) *App {
+
+	// Merge default options
+	options.mergeDefaults()
+
+	// Set up logger
+	myLogger := logger.New(os.Stdout)
+	myLogger.SetLogLevel(logger.INFO)
+
+	window := ffenestri.NewApplicationWithConfig(&ffenestri.Config{
+		Title:       options.Title,
+		Width:       options.Width,
+		Height:      options.Height,
+		MinWidth:    options.MinWidth,
+		MinHeight:   options.MinHeight,
+		MaxWidth:    options.MaxWidth,
+		MaxHeight:   options.MaxHeight,
+		StartHidden: options.StartHidden,
+		DevTools:    options.DevTools,
+
+		Resizable:  !options.DisableResize,
+		Fullscreen: options.Fullscreen,
+	}, myLogger)
+
+	app := &App{
+		window:     window,
+		webserver:  webserver.NewWebServer(myLogger),
+		servicebus: servicebus.New(myLogger),
+		logger:     myLogger,
+		bindings:   binding.NewBindings(myLogger),
+	}
+
+	// Initialise the app
+	app.Init()
+
+	return app
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	// Default app options
+	var port = 8080
+	var ip = "localhost"
+	var suppressLogging = false
+
+	// Create CLI
+	cli := clir.NewCli(filepath.Base(os.Args[0]), "Desktop/Server Build", "")
+
+	// Setup flags
+	cli.IntFlag("p", "Port to serve on", &port)
+	cli.StringFlag("i", "IP to serve on", &ip)
+	cli.BoolFlag("q", "Suppress logging", &suppressLogging)
+
+	// Setup main action
+	cli.Action(func() error {
+
+		// Set IP + Port
+		a.webserver.SetPort(port)
+		a.webserver.SetIP(ip)
+		a.webserver.SetBindings(a.bindings)
+		// Log information (if we aren't suppressing it)
+		if !suppressLogging {
+			cli.PrintBanner()
+			a.logger.Info("Running server at %s", a.webserver.URL())
+		}
+
+		a.servicebus.Start()
+		log, err := subsystem.NewLog(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.log = log
+		a.log.Start()
+		dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.dispatcher = dispatcher
+		a.dispatcher.Start()
+
+		// Start the runtime
+		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.runtime = runtime
+		a.runtime.Start()
+
+		// Start the binding subsystem
+		binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, runtime.GoRuntime())
+		if err != nil {
+			return err
+		}
+		a.binding = binding
+		a.binding.Start()
+
+		// Start the eventing subsystem
+		event, err := subsystem.NewEvent(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.event = event
+		a.event.Start()
+
+		// Start the call subsystem
+		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+		if err != nil {
+			return err
+		}
+		a.call = call
+		a.call.Start()
+
+		// Required so that the WailsInit functions are fired!
+		runtime.GoRuntime().Events.Emit("wails:loaded")
+
+		// Set IP + Port
+		a.webserver.SetPort(port)
+		a.webserver.SetIP(ip)
+
+		// Log information (if we aren't suppressing it)
+		if !suppressLogging {
+			cli.PrintBanner()
+			println("Running server at " + a.webserver.URL())
+		}
+
+		// Dump bindings as a debug
+		bindingDump, err := a.bindings.ToJSON()
+		if err != nil {
+			return err
+		}
+
+		go func() {
+			if err := a.webserver.Start(dispatcher, event); err != nil {
+				a.logger.Error("Webserver failed to start %s", err)
+			}
+		}()
+
+		result := a.window.Run(dispatcher, bindingDump)
+		a.servicebus.Stop()
+
+		return result
+	})
+
+	return cli.Run()
+}
+
+// Bind a struct to the application by passing in
+// a pointer to it
+func (a *App) Bind(structPtr interface{}) {
+
+	// Add the struct to the bindings
+	err := a.bindings.Add(structPtr)
+	if err != nil {
+		a.logger.Fatal("Error during binding: " + err.Error())
+	}
+}

v2/internal/app/production.go

@@ -0,0 +1,11 @@
+// +build !debug
+
+package app
+
+import "github.com/wailsapp/wails/v2/pkg/logger"
+
+// Init initialises the application for a production environment
+func (a *App) Init() error {
+	a.logger.SetLogLevel(logger.ERROR)
+	return nil
+}

v2/internal/app/server.go

@@ -0,0 +1,160 @@
+// +build server,!desktop
+
+package app
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/internal/binding"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/internal/subsystem"
+	"github.com/wailsapp/wails/v2/internal/webserver"
+)
+
+// App defines a Wails application structure
+type App struct {
+	binding *subsystem.Binding
+	call    *subsystem.Call
+	event   *subsystem.Event
+	log     *subsystem.Log
+	runtime *subsystem.Runtime
+
+	bindings   *binding.Bindings
+	logger     *logger.Logger
+	dispatcher *messagedispatcher.Dispatcher
+	servicebus *servicebus.ServiceBus
+	webserver  *webserver.WebServer
+
+	debug bool
+}
+
+// Create App
+func CreateApp(options *Options) *App {
+	options.mergeDefaults()
+	// We ignore the inputs (for now)
+
+	// TODO: Allow logger output override on CLI
+	myLogger := logger.New(os.Stdout)
+	myLogger.SetLogLevel(logger.TRACE)
+
+	result := &App{
+		bindings:   binding.NewBindings(myLogger),
+		logger:     myLogger,
+		servicebus: servicebus.New(myLogger),
+		webserver:  webserver.NewWebServer(myLogger),
+	}
+
+	// Initialise app
+	result.Init()
+
+	return result
+}
+
+// Run the application
+func (a *App) Run() error {
+
+	// Default app options
+	var port = 8080
+	var ip = "localhost"
+	var supressLogging = false
+	var debugMode = false
+
+	// Create CLI
+	cli := clir.NewCli(filepath.Base(os.Args[0]), "Server Build", "")
+
+	// Setup flags
+	cli.IntFlag("p", "Port to serve on", &port)
+	cli.StringFlag("i", "IP to serve on", &ip)
+	cli.BoolFlag("d", "Debug mode", &debugMode)
+	cli.BoolFlag("q", "Supress logging", &supressLogging)
+
+	// Setup main action
+	cli.Action(func() error {
+
+		// Set IP + Port
+		a.webserver.SetPort(port)
+		a.webserver.SetIP(ip)
+		a.webserver.SetBindings(a.bindings)
+		// Log information (if we aren't supressing it)
+		if !supressLogging {
+			cli.PrintBanner()
+			a.logger.Info("Running server at %s", a.webserver.URL())
+		}
+
+		if debugMode {
+			a.servicebus.Debug()
+		}
+		a.servicebus.Start()
+		log, err := subsystem.NewLog(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.log = log
+		a.log.Start()
+		dispatcher, err := messagedispatcher.New(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.dispatcher = dispatcher
+		a.dispatcher.Start()
+
+		// Start the runtime
+		runtime, err := subsystem.NewRuntime(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.runtime = runtime
+		a.runtime.Start()
+
+		// Start the binding subsystem
+		binding, err := subsystem.NewBinding(a.servicebus, a.logger, a.bindings, runtime.GoRuntime())
+		if err != nil {
+			return err
+		}
+		a.binding = binding
+		a.binding.Start()
+
+		// Start the eventing subsystem
+		event, err := subsystem.NewEvent(a.servicebus, a.logger)
+		if err != nil {
+			return err
+		}
+		a.event = event
+		a.event.Start()
+
+		// Start the call subsystem
+		call, err := subsystem.NewCall(a.servicebus, a.logger, a.bindings.DB())
+		if err != nil {
+			return err
+		}
+		a.call = call
+		a.call.Start()
+
+		// Required so that the WailsInit functions are fired!
+		runtime.GoRuntime().Events.Emit("wails:loaded")
+
+		if err := a.webserver.Start(dispatcher, event); err != nil {
+			a.logger.Error("Webserver failed to start %s", err)
+			return err
+		}
+
+		return nil
+	})
+
+	return cli.Run()
+}
+
+// Bind a struct to the application by passing in
+// a pointer to it
+func (a *App) Bind(structPtr interface{}) {
+
+	// Add the struct to the bindings
+	err := a.bindings.Add(structPtr)
+	if err != nil {
+		a.logger.Fatal("Error during binding: " + err.Error())
+	}
+}

v2/internal/assetdb/assetdb.go

@@ -0,0 +1,112 @@
+package assetdb
+
+import (
+	"fmt"
+	"strings"
+	"unsafe"
+)
+
+// AssetDB is a database for assets encoded as byte slices
+type AssetDB struct {
+	db map[string][]byte
+}
+
+// NewAssetDB creates a new AssetDB and initialises a blank db
+func NewAssetDB() *AssetDB {
+	return &AssetDB{
+		db: make(map[string][]byte),
+	}
+}
+
+// AddAsset saves the given byte slice under the given name
+func (a *AssetDB) AddAsset(name string, data []byte) {
+	a.db[name] = data
+}
+
+// Remove removes the named asset
+func (a *AssetDB) Remove(name string) {
+	delete(a.db, name)
+}
+
+// Asset retrieves the byte slice for the given name
+func (a *AssetDB) Read(name string) ([]byte, error) {
+	result := a.db[name]
+	if result == nil {
+		return nil, fmt.Errorf("asset '%s' not found", name)
+	}
+	return result, nil
+}
+
+// AssetAsString returns the asset as a string.
+// It also returns a boolean indicating whether the asset existed or not.
+func (a *AssetDB) String(name string) (string, error) {
+	asset, err := a.Read(name)
+	if err != nil {
+		return "", err
+	}
+	return *(*string)(unsafe.Pointer(&asset)), nil
+}
+
+func (a *AssetDB) Dump() {
+	fmt.Printf("Assets:\n")
+	for k, _ := range a.db {
+		fmt.Println(k)
+	}
+}
+
+// Serialize converts the entire database to a file that when compiled will
+// reconstruct the AssetDB during init()
+// name: name of the asset.AssetDB instance
+// pkg:  package name placed at the top of the file
+func (a *AssetDB) Serialize(name, pkg string) string {
+	var cdata strings.Builder
+	// Set buffer size to 4k
+	cdata.Grow(4096)
+
+	// Write header
+	header := `// DO NOT EDIT - Generated automatically
+package %s
+
+import "github.com/wailsapp/wails/v2/internal/assetdb"
+
+var (
+	%s *assetdb.AssetDB = assetdb.NewAssetDB()
+)
+
+// AssetsDB is a clean interface to the assetdb.AssetDB struct
+type AssetsDB interface {
+	Read(string) ([]byte, error)
+	String(string) (string, error)
+}
+
+// Assets returns the asset database
+func Assets() AssetsDB {
+	return %s
+}
+
+func init() {
+`
+	cdata.WriteString(fmt.Sprintf(header, pkg, name, name))
+
+	for aname, bytes := range a.db {
+		cdata.WriteString(fmt.Sprintf("\t%s.AddAsset(\"%s\", []byte{",
+			name,
+			aname))
+
+		l := len(bytes)
+		if l == 0 {
+			cdata.WriteString("0x00})\n")
+			continue
+		}
+
+		// Convert each byte to hex
+		for _, b := range bytes[:l-1] {
+			cdata.WriteString(fmt.Sprintf("0x%x, ", b))
+		}
+		cdata.WriteString(fmt.Sprintf("0x%x})\n", bytes[l-1]))
+	}
+
+	cdata.WriteString(`}`)
+
+	return cdata.String()
+}

v2/internal/assetdb/assetdb_test.go

@@ -0,0 +1,70 @@
+package assetdb
+
+import "testing"
+import "github.com/matryer/is"
+
+func TestExistsAsBytes(t *testing.T) {
+
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("hello", helloworld)
+
+	result, err := db.Read("hello")
+
+	is.True(err == nil)
+	is.Equal(result, helloworld)
+}
+
+func TestNotExistsAsBytes(t *testing.T) {
+
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("hello4", helloworld)
+
+	result, err := db.Read("hello")
+
+	is.True(err != nil)
+	is.True(result == nil)
+}
+
+func TestExistsAsString(t *testing.T) {
+
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("hello", helloworld)
+
+	result, err := db.String("hello")
+
+	// Ensure it exists
+	is.True(err == nil)
+
+	// Ensure the string is the same as the byte slice
+	is.Equal(result, "Hello, World!")
+}
+
+func TestNotExistsAsString(t *testing.T) {
+
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("hello", helloworld)
+
+	result, err := db.String("help")
+
+	// Ensure it doesn't exist
+	is.True(err != nil)
+
+	// Ensure the string is blank
+	is.Equal(result, "")
+}

v2/internal/assetdb/filesystem.go

@@ -0,0 +1,176 @@
+// +build !desktop
+package assetdb
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"sort"
+	"strings"
+	"time"
+)
+
+var errWhence = errors.New("Seek: invalid whence")
+var errOffset = errors.New("Seek: invalid offset")
+
+// Open implements the http.FileSystem interface for the AssetDB
+func (a *AssetDB) Open(name string) (http.File, error) {
+	if name == "/" || name == "" {
+		return &Entry{name: "/", dir: true, db: a}, nil
+	}
+
+	if data, ok := a.db[name]; ok {
+		return &Entry{name: name, data: data, size: len(data)}, nil
+	} else {
+		for n, _ := range a.db {
+			if strings.HasPrefix(n, name+"/") {
+				return &Entry{name: name, db: a, dir: true}, nil
+			}
+		}
+	}
+	return &Entry{}, os.ErrNotExist
+}
+
+// readdir returns the directory entries for the requested directory
+func (a *AssetDB) readdir(name string) ([]os.FileInfo, error) {
+	dir := name
+	var ents []string
+
+	fim := make(map[string]os.FileInfo)
+	for fn, data := range a.db {
+		if strings.HasPrefix(fn, dir) {
+			pieces := strings.Split(fn[len(dir)+1:], "/")
+			if len(pieces) == 1 {
+				fim[pieces[0]] = FI{name: pieces[0], dir: false, size: len(data)}
+				ents = append(ents, pieces[0])
+			} else {
+				fim[pieces[0]] = FI{name: pieces[0], dir: true, size: -1}
+				ents = append(ents, pieces[0])
+			}
+		}
+	}
+
+	if len(ents) == 0 {
+		return nil, os.ErrNotExist
+	}
+
+	sort.Strings(ents)
+	var list []os.FileInfo
+	for _, dir := range ents {
+		list = append(list, fim[dir])
+	}
+	return list, nil
+}
+
+// Entry implements the http.File interface to allow for
+// use in the http.FileSystem implementation of AssetDB
+type Entry struct {
+	name string
+	data []byte
+	dir  bool
+	size int
+	db   *AssetDB
+	off  int
+}
+
+// Close is a noop
+func (e Entry) Close() error {
+	return nil
+}
+
+// Read fills the slice provided returning how many bytes were written
+// and any errors encountered
+func (e *Entry) Read(p []byte) (n int, err error) {
+	if e.off >= e.size {
+		return 0, io.EOF
+	}
+	numout := len(p)
+	if numout > e.size {
+		numout = e.size
+	}
+	for i := 0; i < numout; i++ {
+		p[i] = e.data[e.off+i]
+	}
+	e.off += numout
+	n = int(numout)
+	err = nil
+	return
+}
+
+// Seek seeks to the specified offset from the location specified by whence
+func (e *Entry) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	default:
+		return 0, errWhence
+	case io.SeekStart:
+		offset += 0
+	case io.SeekCurrent:
+		offset += int64(e.off)
+	case io.SeekEnd:
+		offset += int64(e.size)
+	}
+
+	if offset < 0 {
+		return 0, errOffset
+	}
+	e.off = int(offset)
+	return offset, nil
+}
+
+// Readdir returns the directory entries inside this entry if it is a directory
+func (e Entry) Readdir(count int) ([]os.FileInfo, error) {
+	ents := []os.FileInfo{}
+	if !e.dir {
+		return ents, errors.New("Not a directory")
+	}
+	return e.db.readdir(e.name)
+}
+
+// Stat returns information about this directory entry
+func (e Entry) Stat() (os.FileInfo, error) {
+	return FI{e.name, e.size, e.dir}, nil
+}
+
+// FI is the AssetDB implementation of os.FileInfo.
+type FI struct {
+	name string
+	size int
+	dir  bool
+}
+
+// IsDir returns true if this is a directory
+func (fi FI) IsDir() bool {
+	return fi.dir
+}
+
+// ModTime always returns now
+func (fi FI) ModTime() time.Time {
+	return time.Time{}
+}
+
+// Mode returns the file as readonly and directories
+// as world writeable and executable
+func (fi FI) Mode() os.FileMode {
+	if fi.IsDir() {
+		return 0755 | os.ModeDir
+	}
+	return 0444
+}
+
+// Name returns the name of this object without
+// any leading slashes
+func (fi FI) Name() string {
+	return path.Base(fi.name)
+}
+
+// Size returns the size of this item
+func (fi FI) Size() int64 {
+	return int64(fi.size)
+}
+
+// Sys returns nil
+func (fi FI) Sys() interface{} {
+	return nil
+}

v2/internal/assetdb/filesystem_test.go

@@ -0,0 +1,108 @@
+package assetdb
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/matryer/is"
+)
+
+func TestOpenLeadingSlash(t *testing.T) {
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("/hello", helloworld)
+
+	file, err := db.Open("/hello")
+	// Ensure it does exist
+	is.True(err == nil)
+
+	buff := make([]byte, len(helloworld))
+	n, err := file.Read(buff)
+	fmt.Printf("Error %v\n", err)
+	is.True(err == nil)
+	is.Equal(n, len(helloworld))
+	result := string(buff)
+
+	// Ensure the string is blank
+	is.Equal(result, string(helloworld))
+}
+
+func TestOpen(t *testing.T) {
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("/hello", helloworld)
+
+	file, err := db.Open("/hello")
+
+	// Ensure it does exist
+	is.True(err == nil)
+
+	buff := make([]byte, len(helloworld))
+	n, err := file.Read(buff)
+	is.True(err == nil)
+	is.Equal(n, len(helloworld))
+	result := string(buff)
+
+	// Ensure the string is blank
+	is.Equal(result, string(helloworld))
+}
+
+func TestReaddir(t *testing.T) {
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("/hello", helloworld)
+	db.AddAsset("/directory/hello", helloworld)
+	db.AddAsset("/directory/subdirectory/hello", helloworld)
+
+	dir, err := db.Open("/doesntexist")
+	is.True(err == os.ErrNotExist)
+	ents, err := dir.Readdir(-1)
+	is.Equal([]os.FileInfo{}, ents)
+
+	dir, err = db.Open("/")
+	is.True(dir != nil)
+	is.True(err == nil)
+	ents, err = dir.Readdir(-1)
+	is.True(err == nil)
+	is.Equal(3, len(ents))
+}
+
+func TestReaddirSubdirectory(t *testing.T) {
+	is := is.New(t)
+
+	var helloworld = []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
+
+	db := NewAssetDB()
+	db.AddAsset("/hello", helloworld)
+	db.AddAsset("/directory/hello", helloworld)
+	db.AddAsset("/directory/subdirectory/hello", helloworld)
+
+	expected := []os.FileInfo{
+		FI{name: "hello", dir: false, size: len(helloworld)},
+		FI{name: "subdirectory", dir: true, size: -1},
+	}
+
+	dir, err := db.Open("/directory")
+	is.True(dir != nil)
+	is.True(err == nil)
+	ents, err := dir.Readdir(-1)
+	is.Equal(expected, ents)
+
+	// Check sub-subdirectory
+	dir, err = db.Open("/directory/subdirectory")
+	is.True(dir != nil)
+	is.True(err == nil)
+	ents, err = dir.Readdir(-1)
+	is.True(err == nil)
+	is.Equal([]os.FileInfo{FI{name: "hello", size: len(helloworld)}}, ents)
+}

v2/internal/bind/bind.go

@@ -0,0 +1,9 @@
+package bind
+
+func IsStructPointer(value interface{}) bool {
+	switch t := value.(type) {
+	default:
+		println(t)
+	}
+	return false
+}

v2/internal/binding/binding.go

@@ -0,0 +1,70 @@
+package binding
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/wailsapp/wails/v2/internal/logger"
+)
+
+type Bindings struct {
+	db     *DB
+	logger logger.CustomLogger
+}
+
+// NewBindings returns a new Bindings object
+func NewBindings(logger *logger.Logger) *Bindings {
+	return &Bindings{
+		db:     newDB(),
+		logger: logger.CustomLogger("Bindings"),
+	}
+}
+
+// Add the given struct methods to the Bindings
+func (b *Bindings) Add(structPtr interface{}) error {
+
+	methods, err := getMethods(structPtr)
+	if err != nil {
+		return fmt.Errorf("cannot bind value to app: %s", err.Error())
+	}
+
+	for _, method := range methods {
+		splitName := strings.Split(method.Name, ".")
+		packageName := splitName[0]
+		structName := splitName[1]
+		methodName := splitName[2]
+
+		// Is this WailsInit?
+		if method.IsWailsInit() {
+			err := b.db.AddWailsInit(method)
+			if err != nil {
+				return err
+			}
+			b.logger.Trace("Registered WailsInit method: %s", method.Name)
+			continue
+		}
+
+		// Is this WailsShutdown?
+		if method.IsWailsShutdown() {
+			err := b.db.AddWailsShutdown(method)
+			if err != nil {
+				return err
+			}
+			b.logger.Trace("Registered WailsShutdown method: %s", method.Name)
+			continue
+		}
+
+		// Add it as a regular method
+		b.db.AddMethod(packageName, structName, methodName, method)
+
+	}
+	return nil
+}
+
+func (b *Bindings) DB() *DB {
+	return b.db
+}
+
+func (b *Bindings) ToJSON() (string, error) {
+	return b.db.ToJSON()
+}

v2/internal/binding/boundMethod.go

@@ -0,0 +1,150 @@
+package binding
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// BoundMethod defines all the data related to a Go method that is
+// bound to the Wails application
+type BoundMethod struct {
+	Name     string        `json:"name"`
+	Inputs   []*Parameter  `json:"inputs,omitempty"`
+	Outputs  []*Parameter  `json:"outputs,omitempty"`
+	Comments string        `json:"comments,omitempty"`
+	Method   reflect.Value `json:"-"`
+}
+
+// IsWailsInit returns true if the method name is "WailsInit"
+func (b *BoundMethod) IsWailsInit() bool {
+	return strings.HasSuffix(b.Name, "WailsInit")
+}
+
+// IsWailsShutdown returns true if the method name is "WailsShutdown"
+func (b *BoundMethod) IsWailsShutdown() bool {
+	return strings.HasSuffix(b.Name, "WailsShutdown")
+}
+
+// VerifyWailsInit checks if the WailsInit signature is correct
+func (b *BoundMethod) VerifyWailsInit() error {
+	// Must only have 1 input
+	if b.InputCount() != 1 {
+		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
+	}
+
+	// Check input type
+	if !b.Inputs[0].IsType("*runtime.Runtime") {
+		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
+	}
+
+	// Must only have 1 output
+	if b.OutputCount() != 1 {
+		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
+	}
+
+	// Check output type
+	if !b.Outputs[0].IsError() {
+		return fmt.Errorf("invalid method signature for %s: expected `WailsInit(*wails.Runtime) error`", b.Name)
+	}
+
+	// Input must be of type Runtime
+	return nil
+}
+
+// VerifyWailsShutdown checks if the WailsShutdown signature is correct
+func (b *BoundMethod) VerifyWailsShutdown() error {
+	// Must have no inputs
+	if b.InputCount() != 0 {
+		return fmt.Errorf("invalid method signature for WailsShutdown: expected `WailsShutdown()`")
+	}
+
+	// Must have no outputs
+	if b.OutputCount() != 0 {
+		return fmt.Errorf("invalid method signature for WailsShutdown: expected `WailsShutdown()`")
+	}
+
+	// Input must be of type Runtime
+	return nil
+}
+
+// InputCount returns the number of inputs this bound method has
+func (b *BoundMethod) InputCount() int {
+	return len(b.Inputs)
+}
+
+// OutputCount returns the number of outputs this bound method has
+func (b *BoundMethod) OutputCount() int {
+	return len(b.Outputs)
+}
+
+// ParseArgs method converts the input json into the types expected by the method
+func (b *BoundMethod) ParseArgs(args []json.RawMessage) ([]interface{}, error) {
+
+	result := make([]interface{}, b.InputCount())
+	for index, arg := range args {
+		typ := b.Inputs[index].reflectType
+		inputValue := reflect.New(typ).Interface()
+		err := json.Unmarshal(arg, inputValue)
+		if err != nil {
+			return nil, err
+		}
+		if inputValue == nil {
+			result[index] = reflect.Zero(typ).Interface()
+		} else {
+			result[index] = reflect.ValueOf(inputValue).Elem().Interface()
+		}
+	}
+	return result, nil
+}
+
+// Call will attempt to call this bound method with the given args
+func (b *BoundMethod) Call(args []interface{}) (interface{}, error) {
+	// Check inputs
+	expectedInputLength := len(b.Inputs)
+	actualInputLength := len(args)
+	if expectedInputLength != actualInputLength {
+		return nil, fmt.Errorf("%s takes %d inputs. Received %d", b.Name, expectedInputLength, actualInputLength)
+	}
+
+	/** Convert inputs to reflect values **/
+
+	// Create slice for the input arguments to the method call
+	callArgs := make([]reflect.Value, expectedInputLength)
+
+	// Iterate over given arguments
+	for index, arg := range args {
+		// Save the converted argument
+		callArgs[index] = reflect.ValueOf(arg)
+	}
+
+	// Do the call
+	callResults := b.Method.Call(callArgs)
+
+	//** Check results **//
+	var returnValue interface{}
+	var err error
+
+	switch b.OutputCount() {
+	case 1:
+		// Loop over results and determine if the result
+		// is an error or not
+		for _, result := range callResults {
+			interfac := result.Interface()
+			temp, ok := interfac.(error)
+			if ok {
+				err = temp
+			} else {
+				returnValue = interfac
+			}
+		}
+	case 2:
+		returnValue = callResults[0].Interface()
+		if temp, ok := callResults[1].Interface().(error); ok {
+			err = temp
+		}
+	}
+
+	return returnValue, err
+}

v2/internal/binding/db.go

@@ -0,0 +1,150 @@
+package binding
+
+import (
+	"encoding/json"
+	"sync"
+	"unsafe"
+)
+
+// DB is our database of method bindings
+type DB struct {
+	//  map[packagename] -> map[structname] -> map[methodname]*method
+	store map[string]map[string]map[string]*BoundMethod
+
+	// This uses fully qualified method names as a shortcut for store traversal.
+	// It used for performance gains at runtime
+	methodMap map[string]*BoundMethod
+
+	// These are slices of methods registered using WailsInit and WailsShutdown
+	wailsInitMethods     []*BoundMethod
+	wailsShutdownMethods []*BoundMethod
+
+	// Lock to ensure sync access to the data
+	lock sync.RWMutex
+}
+
+func newDB() *DB {
+	return &DB{
+		store:     make(map[string]map[string]map[string]*BoundMethod),
+		methodMap: make(map[string]*BoundMethod),
+	}
+}
+
+// GetMethodFromStore returns the method for the given package/struct/method names
+// nil is returned if any one of those does not exist
+func (d *DB) GetMethodFromStore(packageName string, structName string, methodName string) *BoundMethod {
+
+	// Lock the db whilst processing and unlock on return
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+
+	structMap, exists := d.store[packageName]
+	if !exists {
+		return nil
+	}
+	methodMap, exists := structMap[structName]
+	if !exists {
+		return nil
+	}
+	return methodMap[methodName]
+}
+
+// GetMethod returns the method for the given qualified method name
+// qualifiedMethodName is "packagename.structname.methodname"
+func (d *DB) GetMethod(qualifiedMethodName string) *BoundMethod {
+
+	// Lock the db whilst processing and unlock on return
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+
+	return d.methodMap[qualifiedMethodName]
+}
+
+// AddMethod adds the given method definition to the db using the given qualified path: packageName.structName.methodName
+func (d *DB) AddMethod(packageName string, structName string, methodName string, methodDefinition *BoundMethod) {
+
+	// TODO: Validate inputs?
+
+	// Lock the db whilst processing and unlock on return
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	// Get the map associated with the package name
+	structMap, exists := d.store[packageName]
+	if !exists {
+		// Create a new map for this packagename
+		d.store[packageName] = make(map[string]map[string]*BoundMethod)
+		structMap = d.store[packageName]
+	}
+
+	// Get the map associated with the struct name
+	methodMap, exists := structMap[structName]
+	if !exists {
+		// Create a new map for this packagename
+		structMap[structName] = make(map[string]*BoundMethod)
+		methodMap = structMap[structName]
+	}
+
+	// Store the method definition
+	methodMap[methodName] = methodDefinition
+
+	// Store in the methodMap
+	key := packageName + "." + structName + "." + methodName
+	d.methodMap[key] = methodDefinition
+
+}
+
+// AddWailsInit checks the given method is a WailsInit method and if it
+// is, adds it to the list of WailsInit methods
+func (d *DB) AddWailsInit(method *BoundMethod) error {
+	err := method.VerifyWailsInit()
+	if err != nil {
+		return err
+	}
+
+	// Lock the db whilst processing and unlock on return
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	d.wailsInitMethods = append(d.wailsInitMethods, method)
+	return nil
+}
+
+// AddWailsShutdown checks the given method is a WailsInit method and if it
+// is, adds it to the list of WailsShutdown methods
+func (d *DB) AddWailsShutdown(method *BoundMethod) error {
+	err := method.VerifyWailsShutdown()
+	if err != nil {
+		return err
+	}
+
+	// Lock the db whilst processing and unlock on return
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	d.wailsShutdownMethods = append(d.wailsShutdownMethods, method)
+	return nil
+}
+
+// ToJSON converts the method map to JSON
+func (d *DB) ToJSON() (string, error) {
+
+	// Lock the db whilst processing and unlock on return
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+
+	bytes, err := json.Marshal(&d.store)
+
+	// Return zero copy string as this string will be read only
+	return *(*string)(unsafe.Pointer(&bytes)), err
+}
+
+// WailsInitMethods returns the list of registered WailsInit methods
+func (d *DB) WailsInitMethods() []*BoundMethod {
+	return d.wailsInitMethods
+}
+
+// WailsShutdownMethods returns the list of registered WailsInit methods
+func (d *DB) WailsShutdownMethods() []*BoundMethod {
+	return d.wailsShutdownMethods
+}

v2/internal/binding/parameter.go

@@ -0,0 +1,28 @@
+package binding
+
+import "reflect"
+
+// Parameter defines a Go method parameter
+type Parameter struct {
+	Name        string `json:"name,omitempty"`
+	TypeName    string `json:"type"`
+	reflectType reflect.Type
+}
+
+func newParameter(Name string, Type reflect.Type) *Parameter {
+	return &Parameter{
+		Name:        Name,
+		TypeName:    Type.String(),
+		reflectType: Type,
+	}
+}
+
+// IsType returns true if the given
+func (p *Parameter) IsType(typename string) bool {
+	return p.TypeName == typename
+}
+
+// IsError returns true if the parameter type is an error
+func (p *Parameter) IsError() bool {
+	return p.IsType("error")
+}

v2/internal/binding/reflect.go

@@ -0,0 +1,97 @@
+package binding
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+)
+
+// isStructPtr returns true if the value given is a
+// pointer to a struct
+func isStructPtr(value interface{}) bool {
+	return reflect.ValueOf(value).Kind() == reflect.Ptr &&
+		reflect.ValueOf(value).Elem().Kind() == reflect.Struct
+}
+
+// isFunction returns true if the given value is a function
+func isFunction(value interface{}) bool {
+	return reflect.ValueOf(value).Kind() == reflect.Func
+}
+
+// isStructPtr returns true if the value given is a struct
+func isStruct(value interface{}) bool {
+	return reflect.ValueOf(value).Kind() == reflect.Struct
+}
+
+func getMethods(value interface{}) ([]*BoundMethod, error) {
+
+	// Create result placeholder
+	var result []*BoundMethod
+
+	// Check type
+	if !isStructPtr(value) {
+
+		if isStruct(value) {
+			name := reflect.ValueOf(value).Type().Name()
+			return nil, fmt.Errorf("%s is a struct, not a pointer to a struct", name)
+		}
+
+		if isFunction(value) {
+			name := runtime.FuncForPC(reflect.ValueOf(value).Pointer()).Name()
+			return nil, fmt.Errorf("%s is a function, not a pointer to a struct. Wails v2 has deprecated the binding of functions. Please wrap your functions up in a struct and bind a pointer to that struct.", name)
+		}
+
+		return nil, fmt.Errorf("not a pointer to a struct.")
+	}
+
+	// Process Struct
+	structType := reflect.TypeOf(value)
+	structValue := reflect.ValueOf(value)
+	baseName := structType.String()[1:]
+
+	// Process Methods
+	for i := 0; i < structType.NumMethod(); i++ {
+		methodDef := structType.Method(i)
+		methodName := methodDef.Name
+		fullMethodName := baseName + "." + methodName
+		method := structValue.MethodByName(methodName)
+
+		// Create new method
+		boundMethod := &BoundMethod{
+			Name:     fullMethodName,
+			Inputs:   nil,
+			Outputs:  nil,
+			Comments: "",
+			Method:   method,
+		}
+
+		// Iterate inputs
+		methodType := method.Type()
+		inputParamCount := methodType.NumIn()
+		var inputs []*Parameter
+		for inputIndex := 0; inputIndex < inputParamCount; inputIndex++ {
+			input := methodType.In(inputIndex)
+			thisParam := newParameter("", input)
+			inputs = append(inputs, thisParam)
+		}
+
+		boundMethod.Inputs = inputs
+
+		// Iterate outputs
+		// TODO: Determine what to do about limiting return types
+		//       especially around errors.
+		outputParamCount := methodType.NumOut()
+		var outputs []*Parameter
+		for outputIndex := 0; outputIndex < outputParamCount; outputIndex++ {
+			output := methodType.Out(outputIndex)
+			thisParam := newParameter("", output)
+			outputs = append(outputs, thisParam)
+		}
+		boundMethod.Outputs = outputs
+
+		// Save method in result
+		result = append(result, boundMethod)
+
+	}
+	return result, nil
+}

v2/internal/crypto/crypto.go

@@ -0,0 +1,17 @@
+package crypto
+
+import (
+	"crypto/rand"
+	"fmt"
+	"log"
+)
+
+// RandomID returns a random ID as a string
+func RandomID() string {
+	b := make([]byte, 16)
+	_, err := rand.Read(b)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return fmt.Sprintf("%x", b)
+}

v2/internal/ffenestri/LICENCES.md

@@ -0,0 +1,13 @@
+# 3rd Party Licenses
+
+## vec
+Homepage: https://github.com/rxi/vec
+License: https://github.com/rxi/vec/blob/master/LICENSE
+
+## json
+Homepage: http://git.ozlabs.org/?p=ccan;a=tree;f=ccan/json;hb=HEAD
+License: http://git.ozlabs.org/?p=ccan;a=blob;f=licenses/BSD-MIT;h=89de354795ec7a7cdab07c091029653d3618540d;hb=HEAD
+
+## hashmap
+Homepage: https://github.com/sheredom/hashmap.h
+License: https://github.com/sheredom/hashmap.h/blob/master/LICENSE

v2/internal/ffenestri/ffenestri.go

@@ -0,0 +1,177 @@
+package ffenestri
+
+import (
+	"runtime"
+	"strings"
+	"unsafe"
+
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+/*
+
+#cgo linux CFLAGS: -DFFENESTRI_LINUX=1
+#cgo linux pkg-config: gtk+-3.0 webkit2gtk-4.0
+
+#cgo darwin CFLAGS: -DFFENESTRI_DARWIN=1
+#cgo darwin LDFLAGS: -framework WebKit -lobjc
+
+#include <stdlib.h>
+#include "ffenestri.h"
+
+
+*/
+import "C"
+
+// Application is our main application object
+type Application struct {
+	config *options.App
+	memory []unsafe.Pointer
+
+	// This is the main app pointer
+	app unsafe.Pointer
+
+	// Logger
+	logger logger.CustomLogger
+}
+
+func (a *Application) saveMemoryReference(mem unsafe.Pointer) {
+	a.memory = append(a.memory, mem)
+}
+
+func (a *Application) string2CString(str string) *C.char {
+	result := C.CString(str)
+	a.saveMemoryReference(unsafe.Pointer(result))
+	return result
+}
+
+func init() {
+	runtime.LockOSThread()
+}
+
+// NewApplicationWithConfig creates a new application based on the given config
+func NewApplicationWithConfig(config *options.App, logger *logger.Logger) *Application {
+	return &Application{
+		config: config,
+		logger: logger.CustomLogger("Ffenestri"),
+	}
+}
+
+// NewApplication creates a new Application with the default config
+func NewApplication(logger *logger.Logger) *Application {
+	return &Application{
+		config: options.Default,
+		logger: logger.CustomLogger("Ffenestri"),
+	}
+}
+
+func (a *Application) freeMemory() {
+	for _, mem := range a.memory {
+		// fmt.Printf("Freeing memory: %+v\n", mem)
+		C.free(mem)
+	}
+}
+
+// bool2Cint converts a Go boolean to a C integer
+func (a *Application) bool2Cint(value bool) C.int {
+	if value {
+		return C.int(1)
+	}
+	return C.int(0)
+}
+
+// dispatcher is the interface to send messages to
+var dispatcher *messagedispatcher.DispatchClient
+
+// Dispatcher is what we register out client with
+type Dispatcher interface {
+	RegisterClient(client messagedispatcher.Client) *messagedispatcher.DispatchClient
+}
+
+// DispatchClient is the means for passing messages to the backend
+type DispatchClient interface {
+	SendMessage(string)
+}
+
+func intToColour(colour int) (C.int, C.int, C.int, C.int) {
+	var alpha = C.int(colour & 0xFF)
+	var blue = C.int((colour >> 8) & 0xFF)
+	var green = C.int((colour >> 16) & 0xFF)
+	var red = C.int((colour >> 24) & 0xFF)
+	return red, green, blue, alpha
+}
+
+// Run the application
+func (a *Application) Run(incomingDispatcher Dispatcher, bindings string, debug bool) error {
+	title := a.string2CString(a.config.Title)
+	width := C.int(a.config.Width)
+	height := C.int(a.config.Height)
+	resizable := a.bool2Cint(!a.config.DisableResize)
+	devtools := a.bool2Cint(a.config.DevTools)
+	fullscreen := a.bool2Cint(a.config.Fullscreen)
+	startHidden := a.bool2Cint(a.config.StartHidden)
+	logLevel := C.int(a.config.LogLevel)
+	app := C.NewApplication(title, width, height, resizable, devtools, fullscreen, startHidden, logLevel)
+
+	// Save app reference
+	a.app = unsafe.Pointer(app)
+
+	// Set Min Window Size
+	minWidth := C.int(a.config.MinWidth)
+	minHeight := C.int(a.config.MinHeight)
+	C.SetMinWindowSize(a.app, minWidth, minHeight)
+
+	// Set Max Window Size
+	maxWidth := C.int(a.config.MaxWidth)
+	maxHeight := C.int(a.config.MaxHeight)
+	C.SetMaxWindowSize(a.app, maxWidth, maxHeight)
+
+	// Set debug if needed
+	C.SetDebug(app, a.bool2Cint(debug))
+
+	// TODO: Move frameless to Linux options
+	// if a.config.Frameless {
+	// 	C.DisableFrame(a.app)
+	// }
+
+	if a.config.RGBA != 0 {
+		r, g, b, alpha := intToColour(a.config.RGBA)
+		C.SetColour(a.app, r, g, b, alpha)
+	}
+
+	// Escape bindings so C doesn't freak out
+	bindings = strings.ReplaceAll(bindings, `"`, `\"`)
+
+	// Set bindings
+	C.SetBindings(app, a.string2CString(bindings))
+
+	// save the dispatcher in a package variable so that the C callbacks
+	// can access it
+	dispatcher = incomingDispatcher.RegisterClient(newClient(a))
+
+	// Process platform settings
+	a.processPlatformSettings()
+
+	// Check we could initialise the application
+	if app != nil {
+		// Yes - Save memory reference and run app, cleaning up afterwards
+		a.saveMemoryReference(unsafe.Pointer(app))
+		C.Run(app, 0, nil)
+	} else {
+		// Oh no! We couldn't initialise the application
+		a.logger.Fatal("Cannot initialise Application.")
+	}
+
+	a.freeMemory()
+	return nil
+}
+
+// messageFromWindowCallback is called by any messages sent in
+// webkit to window.external.invoke. It relays the message on to
+// the dispatcher.
+//export messageFromWindowCallback
+func messageFromWindowCallback(data *C.char) {
+	dispatcher.DispatchMessage(C.GoString(data))
+}

v2/internal/ffenestri/ffenestri.h

@@ -0,0 +1,42 @@
+#ifndef __FFENESTRI_H__
+#define __FFENESTRI_H__
+
+#include <stdio.h>
+
+extern void *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden, int logLevel);
+extern void SetMinWindowSize(void *app, int minWidth, int minHeight);
+extern void SetMaxWindowSize(void *app, int maxWidth, int maxHeight);
+extern void Run(void *app, int argc, char **argv);
+extern void DestroyApplication(void *app);
+extern void SetDebug(void *app, int flag);
+extern void SetBindings(void *app, const char *bindings);
+extern void ExecJS(void *app, const char *script);
+extern void Hide(void *app);
+extern void Show(void *app);
+extern void Center(void *app);
+extern void Maximise(void *app);
+extern void Unmaximise(void *app);
+extern void ToggleMaximise(void *app);
+extern void Minimise(void *app);
+extern void Unminimise(void *app);
+extern void ToggleMinimise(void *app);
+extern void SetColour(void *app, int red, int green, int blue, int alpha);
+extern void SetSize(void *app, int width, int height);
+extern void SetPosition(void *app, int x, int y);
+extern void Quit(void *app);
+extern void SetTitle(void *app, const char *title);
+extern void Fullscreen(void *app);
+extern void UnFullscreen(void *app);
+extern void ToggleFullscreen(void *app);
+extern void DisableFrame(void *app);
+extern void OpenDialog(void *appPointer, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int allowFiles, int allowDirs, int allowMultiple, int showHiddenFiles, int canCreateDirectories, int resolvesAliases, int treatPackagesAsDirectories);
+extern void SaveDialog(void *appPointer, char *callbackID, char *title, char *filters, char *defaultFilename, char *defaultDir, int showHiddenFiles, int canCreateDirectories, int treatPackagesAsDirectories);
+extern void MessageDialog(void *appPointer, char *callbackID, char *type, char *title, char *message, char *icon, char *button1, char *button2, char *button3, char *button4, char *defaultButton, char *cancelButton);
+extern void DarkModeEnabled(void *appPointer, char *callbackID);
+extern void UpdateMenu(void *app, char *menuAsJSON);
+extern void UpdateTray(void *app, char *menuAsJSON);
+extern void UpdateContextMenus(void *app, char *contextMenusAsJSON);
+extern void UpdateTrayLabel(void *app, const char *label);
+extern void UpdateTrayIcon(void *app, const char *label);
+
+#endif

v2/internal/ffenestri/ffenestri_client.go

@@ -0,0 +1,242 @@
+package ffenestri
+
+/*
+
+#cgo linux CFLAGS: -DFFENESTRI_LINUX=1
+#cgo linux pkg-config: gtk+-3.0 webkit2gtk-4.0
+
+#include <stdlib.h>
+#include "ffenestri.h"
+
+*/
+import "C"
+
+import (
+	"encoding/json"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"strconv"
+
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// Client is our implentation of messageDispatcher.Client
+type Client struct {
+	app    *Application
+	logger logger.CustomLogger
+}
+
+func newClient(app *Application) *Client {
+	return &Client{
+		app:    app,
+		logger: app.logger,
+	}
+}
+
+// Quit the application
+func (c *Client) Quit() {
+	c.app.logger.Trace("Got shutdown message")
+	C.Quit(c.app.app)
+}
+
+// NotifyEvent will pass on the event message to the frontend
+func (c *Client) NotifyEvent(message string) {
+	eventMessage := `window.wails._.Notify(` + strconv.Quote(message) + `);`
+	c.app.logger.Trace("eventMessage = %+v", eventMessage)
+	C.ExecJS(c.app.app, c.app.string2CString(eventMessage))
+}
+
+// CallResult contains the result of the call from JS
+func (c *Client) CallResult(message string) {
+	callbackMessage := `window.wails._.Callback(` + strconv.Quote(message) + `);`
+	c.app.logger.Trace("callbackMessage = %+v", callbackMessage)
+	C.ExecJS(c.app.app, c.app.string2CString(callbackMessage))
+}
+
+// WindowSetTitle sets the window title to the given string
+func (c *Client) WindowSetTitle(title string) {
+	C.SetTitle(c.app.app, c.app.string2CString(title))
+}
+
+// WindowFullscreen will set the window to be fullscreen
+func (c *Client) WindowFullscreen() {
+	C.Fullscreen(c.app.app)
+}
+
+// WindowUnFullscreen will unfullscreen the window
+func (c *Client) WindowUnFullscreen() {
+	C.UnFullscreen(c.app.app)
+}
+
+// WindowShow will show the window
+func (c *Client) WindowShow() {
+	C.Show(c.app.app)
+}
+
+// WindowHide will hide the window
+func (c *Client) WindowHide() {
+	C.Hide(c.app.app)
+}
+
+// WindowCenter will hide the window
+func (c *Client) WindowCenter() {
+	C.Center(c.app.app)
+}
+
+// WindowMaximise will maximise the window
+func (c *Client) WindowMaximise() {
+	C.Maximise(c.app.app)
+}
+
+// WindowMinimise will minimise the window
+func (c *Client) WindowMinimise() {
+	C.Minimise(c.app.app)
+}
+
+// WindowUnmaximise will unmaximise the window
+func (c *Client) WindowUnmaximise() {
+	C.Unmaximise(c.app.app)
+}
+
+// WindowUnminimise will unminimise the window
+func (c *Client) WindowUnminimise() {
+	C.Unminimise(c.app.app)
+}
+
+// WindowPosition will position the window to x,y on the
+// monitor that the window is mostly on
+func (c *Client) WindowPosition(x int, y int) {
+	C.SetPosition(c.app.app, C.int(x), C.int(y))
+}
+
+// WindowSize will resize the window to the given
+// width and height
+func (c *Client) WindowSize(width int, height int) {
+	C.SetSize(c.app.app, C.int(width), C.int(height))
+}
+
+// WindowSetColour sets the window colour
+func (c *Client) WindowSetColour(colour int) {
+	r, g, b, a := intToColour(colour)
+	C.SetColour(c.app.app, r, g, b, a)
+}
+
+// OpenDialog will open a dialog with the given title and filter
+func (c *Client) OpenDialog(dialogOptions *options.OpenDialog, callbackID string) {
+	C.OpenDialog(c.app.app,
+		c.app.string2CString(callbackID),
+		c.app.string2CString(dialogOptions.Title),
+		c.app.string2CString(dialogOptions.Filters),
+		c.app.string2CString(dialogOptions.DefaultFilename),
+		c.app.string2CString(dialogOptions.DefaultDirectory),
+		c.app.bool2Cint(dialogOptions.AllowFiles),
+		c.app.bool2Cint(dialogOptions.AllowDirectories),
+		c.app.bool2Cint(dialogOptions.AllowMultiple),
+		c.app.bool2Cint(dialogOptions.ShowHiddenFiles),
+		c.app.bool2Cint(dialogOptions.CanCreateDirectories),
+		c.app.bool2Cint(dialogOptions.ResolvesAliases),
+		c.app.bool2Cint(dialogOptions.TreatPackagesAsDirectories),
+	)
+}
+
+// SaveDialog will open a dialog with the given title and filter
+func (c *Client) SaveDialog(dialogOptions *options.SaveDialog, callbackID string) {
+	C.SaveDialog(c.app.app,
+		c.app.string2CString(callbackID),
+		c.app.string2CString(dialogOptions.Title),
+		c.app.string2CString(dialogOptions.Filters),
+		c.app.string2CString(dialogOptions.DefaultFilename),
+		c.app.string2CString(dialogOptions.DefaultDirectory),
+		c.app.bool2Cint(dialogOptions.ShowHiddenFiles),
+		c.app.bool2Cint(dialogOptions.CanCreateDirectories),
+		c.app.bool2Cint(dialogOptions.TreatPackagesAsDirectories),
+	)
+}
+
+// MessageDialog will open a message dialog with the given options
+func (c *Client) MessageDialog(dialogOptions *options.MessageDialog, callbackID string) {
+
+	// Sanity check button length
+	if len(dialogOptions.Buttons) > 4 {
+		c.app.logger.Error("Given %d message dialog buttons. Maximum is 4", len(dialogOptions.Buttons))
+		return
+	}
+
+	// Process buttons
+	buttons := []string{"", "", "", ""}
+	for i, button := range dialogOptions.Buttons {
+		buttons[i] = button
+	}
+
+	C.MessageDialog(c.app.app,
+		c.app.string2CString(callbackID),
+		c.app.string2CString(string(dialogOptions.Type)),
+		c.app.string2CString(dialogOptions.Title),
+		c.app.string2CString(dialogOptions.Message),
+		c.app.string2CString(dialogOptions.Icon),
+		c.app.string2CString(buttons[0]),
+		c.app.string2CString(buttons[1]),
+		c.app.string2CString(buttons[2]),
+		c.app.string2CString(buttons[3]),
+		c.app.string2CString(dialogOptions.DefaultButton),
+		c.app.string2CString(dialogOptions.CancelButton))
+}
+
+func (c *Client) DarkModeEnabled(callbackID string) {
+	C.DarkModeEnabled(c.app.app, c.app.string2CString(callbackID))
+}
+
+func (c *Client) UpdateMenu(menu *menu.Menu) {
+
+	// Guard against nil menus
+	if menu == nil {
+		return
+	}
+	// Process the menu
+	processedMenu := NewProcessedMenu(menu)
+	menuJSON, err := json.Marshal(processedMenu)
+	if err != nil {
+		c.app.logger.Error("Error processing updated Menu: %s", err.Error())
+		return
+	}
+	C.UpdateMenu(c.app.app, c.app.string2CString(string(menuJSON)))
+}
+
+func (c *Client) UpdateTray(menu *menu.Menu) {
+
+	// Guard against nil menus
+	if menu == nil {
+		return
+	}
+	// Process the menu
+	processedMenu := NewProcessedMenu(menu)
+	trayMenuJSON, err := json.Marshal(processedMenu)
+	if err != nil {
+		c.app.logger.Error("Error processing updated Tray: %s", err.Error())
+		return
+	}
+	C.UpdateTray(c.app.app, c.app.string2CString(string(trayMenuJSON)))
+}
+
+func (c *Client) UpdateTrayLabel(label string) {
+	C.UpdateTrayLabel(c.app.app, c.app.string2CString(label))
+}
+
+func (c *Client) UpdateTrayIcon(name string) {
+	C.UpdateTrayIcon(c.app.app, c.app.string2CString(name))
+}
+
+func (c *Client) UpdateContextMenus(contextMenus *menu.ContextMenus) {
+
+	// Guard against nil contextMenus
+	if contextMenus == nil {
+		return
+	}
+	// Process the menu
+	contextMenusJSON, err := json.Marshal(contextMenus)
+	if err != nil {
+		c.app.logger.Error("Error processing updated Context Menus: %s", err.Error())
+		return
+	}
+	C.UpdateContextMenus(c.app.app, c.app.string2CString(string(contextMenusJSON)))
+}

v2/internal/ffenestri/ffenestri_darwin.go

@@ -0,0 +1,117 @@
+package ffenestri
+
+/*
+#cgo darwin CFLAGS: -DFFENESTRI_DARWIN=1
+#cgo darwin LDFLAGS: -framework WebKit -lobjc
+
+#include "ffenestri_darwin.h"
+
+*/
+import "C"
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+func (a *Application) processPlatformSettings() error {
+
+	mac := a.config.Mac
+	titlebar := mac.TitleBar
+
+	// HideTitle
+	if titlebar.HideTitle {
+		C.HideTitle(a.app)
+	}
+
+	// HideTitleBar
+	if titlebar.HideTitleBar {
+		C.HideTitleBar(a.app)
+	}
+
+	// Full Size Content
+	if titlebar.FullSizeContent {
+		C.FullSizeContent(a.app)
+	}
+
+	// Toolbar
+	if titlebar.UseToolbar {
+		C.UseToolbar(a.app)
+	}
+
+	if titlebar.HideToolbarSeparator {
+		C.HideToolbarSeparator(a.app)
+	}
+
+	if titlebar.TitlebarAppearsTransparent {
+		C.TitlebarAppearsTransparent(a.app)
+	}
+
+	// Process window Appearance
+	if mac.Appearance != "" {
+		C.SetAppearance(a.app, a.string2CString(string(mac.Appearance)))
+	}
+
+	// Check if the webview should be transparent
+	if mac.WebviewIsTransparent {
+		C.WebviewIsTransparent(a.app)
+	}
+
+	// Check if window should be translucent
+	if mac.WindowBackgroundIsTranslucent {
+		C.WindowBackgroundIsTranslucent(a.app)
+	}
+
+	// Process menu
+	applicationMenu := options.GetApplicationMenu(a.config)
+	if applicationMenu != nil {
+
+		/*
+			As radio groups need to be manually managed on OSX,
+			we preprocess the menu to determine the radio groups.
+			This is defined as any adjacent menu item of type "RadioType".
+			We keep a record of every radio group member we discover by saving
+			a list of all members of the group and the number of members
+			in the group (this last one is for optimisation at the C layer).
+		*/
+		processedMenu := NewProcessedMenu(applicationMenu)
+		applicationMenuJSON, err := json.Marshal(processedMenu)
+		if err != nil {
+			return err
+		}
+		C.SetMenu(a.app, a.string2CString(string(applicationMenuJSON)))
+	}
+
+	// Process tray
+	tray := options.GetTray(a.config)
+	if tray != nil {
+
+		/*
+			As radio groups need to be manually managed on OSX,
+			we preprocess the menu to determine the radio groups.
+			This is defined as any adjacent menu item of type "RadioType".
+			We keep a record of every radio group member we discover by saving
+			a list of all members of the group and the number of members
+			in the group (this last one is for optimisation at the C layer).
+		*/
+		processedMenu := NewProcessedMenu(tray.Menu)
+		trayMenuJSON, err := json.Marshal(processedMenu)
+		if err != nil {
+			return err
+		}
+		C.SetTray(a.app, a.string2CString(string(trayMenuJSON)), a.string2CString(tray.Label), a.string2CString(tray.Icon))
+	}
+
+	// Process context menus
+	contextMenus := options.GetContextMenus(a.config)
+	if contextMenus != nil {
+		contextMenusJSON, err := json.Marshal(contextMenus)
+		fmt.Printf("\n\nCONTEXT MENUS:\n %+v\n\n", string(contextMenusJSON))
+		if err != nil {
+			return err
+		}
+		C.SetContextMenus(a.app, a.string2CString(string(contextMenusJSON)))
+	}
+
+	return nil
+}

v2/internal/ffenestri/ffenestri_darwin.h

@@ -0,0 +1,19 @@
+
+#ifndef FFENESTRI_DARWIN_H
+#define FFENESTRI_DARWIN_H
+
+extern void TitlebarAppearsTransparent(void *);
+extern void HideTitle(void *);
+extern void HideTitleBar(void *);
+extern void FullSizeContent(void *);
+extern void UseToolbar(void *);
+extern void HideToolbarSeparator(void *);
+extern void DisableFrame(void *);
+extern void SetAppearance(void *, const char *);
+extern void WebviewIsTransparent(void *);
+extern void WindowBackgroundIsTranslucent(void *);
+extern void SetMenu(void *, const char *);
+extern void SetTray(void *, const char *, const char *, const char *);
+extern void SetContextMenus(void *, const char *);
+
+#endif

v2/internal/ffenestri/ffenestri_linux.c

@@ -0,0 +1,984 @@
+
+#ifndef __FFENESTRI_LINUX_H__
+#define __FFENESTRI_LINUX_H__
+
+#include "gtk/gtk.h"
+#include "webkit2/webkit2.h"
+#include <time.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+// References to assets
+extern const unsigned char *assets[];
+extern const unsigned char runtime;
+extern const char *icon[];
+
+// Constants
+#define PRIMARY_MOUSE_BUTTON 1
+#define MIDDLE_MOUSE_BUTTON 2
+#define SECONDARY_MOUSE_BUTTON 3
+
+// MAIN DEBUG FLAG
+int debug;
+
+// Credit: https://stackoverflow.com/a/8465083
+char *concat(const char *s1, const char *s2)
+{
+    const size_t len1 = strlen(s1);
+    const size_t len2 = strlen(s2);
+    char *result = malloc(len1 + len2 + 1);
+    memcpy(result, s1, len1);
+    memcpy(result + len1, s2, len2 + 1);
+    return result;
+}
+
+// Debug works like sprintf but mutes if the global debug flag is true
+// Credit: https://stackoverflow.com/a/20639708
+void Debug(char *message, ...)
+{
+    if (debug)
+    {
+        char *temp = concat("TRACE | Ffenestri (C) | ", message);
+        message = concat(temp, "\n");
+        free(temp);
+        va_list args;
+        va_start(args, message);
+        vprintf(message, args);
+        free(message);
+        va_end(args);
+    }
+}
+
+extern void messageFromWindowCallback(const char *);
+typedef void (*ffenestriCallback)(const char *);
+
+struct Application
+{
+
+    // Gtk Data
+    GtkApplication *application;
+    GtkWindow *mainWindow;
+    GtkWidget *webView;
+    int signalInvoke;
+    int signalWindowDrag;
+    int signalButtonPressed;
+    int signalButtonReleased;
+    int signalLoadChanged;
+
+    // Saves the events for the drag mouse button
+    GdkEventButton *dragButtonEvent;
+
+    // The number of the default drag button
+    int dragButton;
+
+    // Window Data
+    const char *title;
+    char *id;
+    int width;
+    int height;
+    int resizable;
+    int devtools;
+    int startHidden;
+    int fullscreen;
+    int minWidth;
+    int minHeight;
+    int maxWidth;
+    int maxHeight;
+    int frame;
+
+    // User Data
+    char *HTML;
+
+    // Callback
+    ffenestriCallback sendMessageToBackend;
+
+    // Bindings
+    const char *bindings;
+
+    // Lock - used for sync operations (Should we be using g_mutex?)
+    int lock;
+};
+
+void *NewApplication(const char *title, int width, int height, int resizable, int devtools, int fullscreen, int startHidden)
+{
+    // Setup main application struct
+    struct Application *result = malloc(sizeof(struct Application));
+    result->title = title;
+    result->width = width;
+    result->height = height;
+    result->resizable = resizable;
+    result->devtools = devtools;
+    result->fullscreen = fullscreen;
+    result->minWidth = 0;
+    result->minHeight = 0;
+    result->maxWidth = 0;
+    result->maxHeight = 0;
+    result->frame = 1;
+    result->startHidden = startHidden;
+
+    // Default drag button is PRIMARY
+    result->dragButton = PRIMARY_MOUSE_BUTTON;
+
+    result->sendMessageToBackend = (ffenestriCallback)messageFromWindowCallback;
+
+    // Create a unique ID based on the current unix timestamp
+    char temp[11];
+    sprintf(&temp[0], "%d", (int)time(NULL));
+    result->id = concat("wails.app", &temp[0]);
+
+    // Create the main GTK application
+    GApplicationFlags flags = G_APPLICATION_FLAGS_NONE;
+    result->application = gtk_application_new(result->id, flags);
+
+    // Return the application struct
+    return (void *)result;
+}
+
+void DestroyApplication(struct Application *app)
+{
+    Debug("Destroying Application");
+
+    g_application_quit(G_APPLICATION(app->application));
+
+    // Release the GTK ID string
+    if (app->id != NULL)
+    {
+        free(app->id);
+        app->id = NULL;
+    }
+    else
+    {
+        Debug("Almost a double free for app->id");
+    }
+
+    // Free the bindings
+    if (app->bindings != NULL)
+    {
+        free((void *)app->bindings);
+        app->bindings = NULL;
+    }
+    else
+    {
+        Debug("Almost a double free for app->bindings");
+    }
+
+    // Disconnect signal handlers
+    WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager((WebKitWebView *)app->webView);
+    g_signal_handler_disconnect(manager, app->signalInvoke);
+    if( app->frame == 0) {
+        g_signal_handler_disconnect(manager, app->signalWindowDrag);
+        g_signal_handler_disconnect(app->webView, app->signalButtonPressed);
+        g_signal_handler_disconnect(app->webView, app->signalButtonReleased);
+    }
+    g_signal_handler_disconnect(app->webView, app->signalLoadChanged);
+
+    // Release the main GTK Application
+    if (app->application != NULL)
+    {
+        g_object_unref(app->application);
+        app->application = NULL;
+    }
+    else
+    {
+        Debug("Almost a double free for app->application");
+    }
+    Debug("Finished Destroying Application");
+}
+
+// Quit will stop the gtk application and free up all the memory
+// used by the application
+void Quit(struct Application *app)
+{
+    Debug("Quit Called");
+    gtk_window_close((GtkWindow *)app->mainWindow);
+    g_application_quit((GApplication *)app->application);
+    DestroyApplication(app);
+}
+
+// SetTitle sets the main window title to the given string
+void SetTitle(struct Application *app, const char *title)
+{
+    gtk_window_set_title(app->mainWindow, title);
+}
+
+// Fullscreen sets the main window to be fullscreen
+void Fullscreen(struct Application *app)
+{
+    gtk_window_fullscreen(app->mainWindow);
+}
+
+// UnFullscreen resets the main window after a fullscreen
+void UnFullscreen(struct Application *app)
+{
+    gtk_window_unfullscreen(app->mainWindow);
+}
+
+void setMinMaxSize(struct Application *app)
+{
+    GdkGeometry size;
+    size.min_width = size.min_height = size.max_width = size.max_height = 0;
+    int flags = 0;
+    if (app->maxHeight > 0 && app->maxWidth > 0)
+    {
+        size.max_height = app->maxHeight;
+        size.max_width = app->maxWidth;
+        flags |= GDK_HINT_MAX_SIZE;
+    }
+    if (app->minHeight > 0 && app->minWidth > 0)
+    {
+        size.min_height = app->minHeight;
+        size.min_width = app->minWidth;
+        flags |= GDK_HINT_MIN_SIZE;
+    }
+    gtk_window_set_geometry_hints(app->mainWindow, NULL, &size, flags);
+}
+
+char *fileDialogInternal(struct Application *app, GtkFileChooserAction chooserAction, char **args) {
+    GtkFileChooserNative *native;
+    GtkFileChooserAction action = chooserAction;
+    gint res;
+    char *filename;
+
+    char *title = args[0];
+    char *filter = args[1];
+
+    native = gtk_file_chooser_native_new(title,
+                                         app->mainWindow,
+                                         action,
+                                         "_Open",
+                                         "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+
+    // If we have filters, process them
+    if (filter[0] != '\0') {
+        GtkFileFilter *file_filter = gtk_file_filter_new();
+        gchar **filters  = g_strsplit(filter, ",", -1);
+        gint i;
+        for(i = 0; filters && filters[i]; i++) {
+            gtk_file_filter_add_pattern(file_filter, filters[i]);
+            // Debug("Adding filter pattern: %s\n", filters[i]);
+        }
+        gtk_file_filter_set_name(file_filter, filter);
+        gtk_file_chooser_add_filter(chooser, file_filter);
+        g_strfreev(filters);
+    }
+
+    res = gtk_native_dialog_run(GTK_NATIVE_DIALOG(native));
+    if (res == GTK_RESPONSE_ACCEPT)
+    {
+        filename = gtk_file_chooser_get_filename(chooser);
+    }
+
+    g_object_unref(native);
+
+    return filename;
+}
+
+// openFileDialogInternal opens a dialog to select a file
+// NOTE: The result is a string that will need to be freed!
+char *openFileDialogInternal(struct Application *app, char **args)
+{
+    return fileDialogInternal(app, GTK_FILE_CHOOSER_ACTION_OPEN, args);
+}
+
+// saveFileDialogInternal opens a dialog to select a file
+// NOTE: The result is a string that will need to be freed!
+char *saveFileDialogInternal(struct Application *app, char **args)
+{
+    return fileDialogInternal(app, GTK_FILE_CHOOSER_ACTION_SAVE, args);
+}
+
+
+// openDirectoryDialogInternal opens a dialog to select a directory
+// NOTE: The result is a string that will need to be freed!
+char *openDirectoryDialogInternal(struct Application *app, char **args)
+{
+    return fileDialogInternal(app, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, args);
+}
+
+void SetMinWindowSize(struct Application *app, int minWidth, int minHeight)
+{
+    app->minWidth = minWidth;
+    app->minHeight = minHeight;
+}
+
+void SetMaxWindowSize(struct Application *app, int maxWidth, int maxHeight)
+{
+    app->maxWidth = maxWidth;
+    app->maxHeight = maxHeight;
+}
+
+// SetColour sets the colour of the webview to the given colour string
+int SetColour(struct Application *app, const char *colourString)
+{
+    GdkRGBA rgba;
+    gboolean result = gdk_rgba_parse(&rgba, colourString);
+    if (result == FALSE)
+    {
+        return 0;
+    }
+    // Debug("Setting webview colour to: %s", colourString);
+    webkit_web_view_get_background_color((WebKitWebView *)(app->webView), &rgba);
+    return 1;
+}
+
+// DisableFrame disables the window frame
+void DisableFrame(struct Application *app)
+{
+    app->frame = 0;
+}
+
+void syncCallback(GObject *source_object,
+                  GAsyncResult *res,
+                  void *data)
+{
+    struct Application *app = (struct Application *)data;
+    app->lock = 0;
+}
+
+void syncEval(struct Application *app, const gchar *script)
+{
+
+    WebKitWebView *webView = (WebKitWebView *)(app->webView);
+
+    // wait for lock to free
+    while (app->lock == 1)
+    {
+        g_main_context_iteration(0, true);
+    }
+    // Set lock
+    app->lock = 1;
+
+    webkit_web_view_run_javascript(
+        webView,
+        script,
+        NULL, syncCallback, (void*)app);
+
+    while (app->lock == 1)
+    {
+        g_main_context_iteration(0, true);
+    }
+}
+
+void asyncEval(WebKitWebView *webView, const gchar *script)
+{
+    webkit_web_view_run_javascript(
+        webView,
+        script,
+        NULL, NULL, NULL);
+}
+
+typedef void (*dispatchMethod)(struct Application *app, void *);
+
+struct dispatchData
+{
+    struct Application *app;
+    dispatchMethod method;
+    void *args;
+};
+
+gboolean executeMethod(gpointer data)
+{
+    struct dispatchData *d = (struct dispatchData *)data;
+    (d->method)(d->app, d->args);
+    g_free(d);
+    return FALSE;
+}
+
+void ExecJS(struct Application *app, char *js)
+{
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)syncEval;
+    data->args = js;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);
+}
+
+typedef char *(*dialogMethod)(struct Application *app, void *);
+
+struct dialogCall
+{
+    struct Application *app;
+    dialogMethod method;
+    void *args;
+    void *filter;
+    char *result;
+    int done;
+};
+
+gboolean executeMethodWithReturn(gpointer data)
+{
+    struct dialogCall *d = (struct dialogCall *)data;
+
+    d->result = (d->method)(d->app, d->args);
+    d->done = 1;
+    return FALSE;
+}
+
+char *OpenFileDialog(struct Application *app, char *title, char *filter)
+{
+    struct dialogCall *data = (struct dialogCall *)g_new(struct dialogCall, 1);
+    data->result = NULL;
+    data->done = 0;
+    data->method = (dialogMethod)openFileDialogInternal;
+    const char* dialogArgs[]={ title, filter };
+    data->args = dialogArgs;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethodWithReturn, data);
+
+    while (data->done == 0)
+    {
+        usleep(100000);
+    }
+    g_free(data);
+    return data->result;
+}
+
+char *SaveFileDialog(struct Application *app, char *title, char *filter)
+{
+    struct dialogCall *data = (struct dialogCall *)g_new(struct dialogCall, 1);
+    data->result = NULL;
+    data->done = 0;
+    data->method = (dialogMethod)saveFileDialogInternal;
+    const char* dialogArgs[]={ title, filter };
+    data->args = dialogArgs;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethodWithReturn, data);
+
+    while (data->done == 0)
+    {
+        usleep(100000);
+    }
+    Debug("Dialog done");
+    Debug("Result = %s\n", data->result);
+
+    g_free(data);
+    // Fingers crossed this wasn't freed by g_free above
+    return data->result;
+}
+
+char *OpenDirectoryDialog(struct Application *app, char *title, char *filter)
+{
+    struct dialogCall *data = (struct dialogCall *)g_new(struct dialogCall, 1);
+    data->result = NULL;
+    data->done = 0;
+    data->method = (dialogMethod)openDirectoryDialogInternal;
+    const char* dialogArgs[]={ title, filter };
+    data->args = dialogArgs;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethodWithReturn, data);
+
+    while (data->done == 0)
+    {
+        usleep(100000);
+    }
+    Debug("Directory Dialog done");
+    Debug("Result = %s\n", data->result);
+    g_free(data);
+    // Fingers crossed this wasn't freed by g_free above
+    return data->result;
+}
+
+// Sets the icon to the XPM stored in icon
+void setIcon(struct Application *app)
+{
+    GdkPixbuf *appIcon = gdk_pixbuf_new_from_xpm_data((const char **)icon);
+    gtk_window_set_icon(app->mainWindow, appIcon);
+}
+
+static void load_finished_cb(WebKitWebView *webView,
+                             WebKitLoadEvent load_event,
+                             struct Application *app)
+{
+    switch (load_event)
+    {
+    // case WEBKIT_LOAD_STARTED:
+    //     /* New load, we have now a provisional URI */
+    //     // printf("Start downloading %s\n", webkit_web_view_get_uri(web_view));
+    //     /* Here we could start a spinner or update the
+    //      * location bar with the provisional URI */
+    //     break;
+    // case WEBKIT_LOAD_REDIRECTED:
+    //     // printf("Redirected to: %s\n", webkit_web_view_get_uri(web_view));
+    //     break;
+    // case WEBKIT_LOAD_COMMITTED:
+    //     /* The load is being performed. Current URI is
+    //      * the final one and it won't change unless a new
+    //      * load is requested or a navigation within the
+    //      * same page is performed */
+    //     // printf("Loading: %s\n", webkit_web_view_get_uri(web_view));
+    //     break;
+    case WEBKIT_LOAD_FINISHED:
+        /* Load finished, we can now stop the spinner */
+        // printf("Finished loading: %s\n", webkit_web_view_get_uri(web_view));
+
+        // Bindings
+        Debug("Binding Methods");
+        syncEval(app, app->bindings);
+
+        // Runtime
+        Debug("Setting up Wails runtime");
+        syncEval(app, &runtime);
+
+        // Loop over assets
+        int index = 1;
+        while (1)
+        {
+            // Get next asset pointer
+            const char *asset = assets[index];
+
+            // If we have no more assets, break
+            if (asset == 0x00)
+            {
+                break;
+            }
+
+            // sync eval the asset
+            syncEval(app, asset);
+            index++;
+        };
+
+        // Set the icon
+        setIcon(app);
+
+        // Setup fullscreen
+        if (app->fullscreen)
+        {
+            Debug("Going fullscreen");
+            Fullscreen(app);
+        }
+
+        // Setup resize
+        gtk_window_resize(GTK_WINDOW(app->mainWindow), app->width, app->height);
+
+        if (app->resizable)
+        {
+            gtk_window_set_default_size(GTK_WINDOW(app->mainWindow), app->width, app->height);
+        }
+        else
+        {
+            gtk_widget_set_size_request(GTK_WIDGET(app->mainWindow), app->width, app->height);
+            gtk_window_resize(GTK_WINDOW(app->mainWindow), app->width, app->height);
+            // Fix the min/max to the window size for good measure
+            app->minHeight = app->maxHeight = app->height;
+            app->minWidth = app->maxWidth = app->width;
+        }
+        gtk_window_set_resizable(GTK_WINDOW(app->mainWindow), app->resizable ? TRUE : FALSE);
+        setMinMaxSize(app);
+
+        // Centre by default
+        gtk_window_set_position(app->mainWindow, GTK_WIN_POS_CENTER);
+
+        // Show window and focus
+        if( app->startHidden == 0) {
+            gtk_widget_show_all(GTK_WIDGET(app->mainWindow));
+            gtk_widget_grab_focus(app->webView);
+        }
+        break;
+    }
+}
+
+static gboolean disable_context_menu_cb(
+    WebKitWebView *web_view,
+    WebKitContextMenu *context_menu,
+    GdkEvent *event,
+    WebKitHitTestResult *hit_test_result,
+    gpointer user_data)
+{
+    return TRUE;
+}
+
+static void printEvent(const char *message, GdkEventButton *event)
+{
+    Debug("%s: [button:%d] [x:%f] [y:%f] [time:%d]",
+          message,
+          event->button,
+          event->x_root,
+          event->y_root,
+          event->time);
+}
+
+
+static void dragWindow(WebKitUserContentManager *contentManager,
+                       WebKitJavascriptResult *result,
+                       struct Application *app)
+{
+    // If we get this message erroneously, ignore
+    if (app->dragButtonEvent == NULL)
+    {
+        return;
+    }
+
+    // Ignore non-toplevel widgets
+    GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(app->webView));
+    if (!GTK_IS_WINDOW(window))
+    {
+        return;
+    }
+
+    // Initiate the drag
+    printEvent("Starting drag with event", app->dragButtonEvent);
+
+    gtk_window_begin_move_drag(app->mainWindow,
+                               app->dragButton,
+                               app->dragButtonEvent->x_root,
+                               app->dragButtonEvent->y_root,
+                               app->dragButtonEvent->time);
+    // Clear the event
+    app->dragButtonEvent = NULL;
+
+    return;
+}
+
+gboolean buttonPress(GtkWidget *widget, GdkEventButton *event, struct Application *app)
+{
+    if (event->type == GDK_BUTTON_PRESS && event->button == app->dragButton)
+    {
+        app->dragButtonEvent = event;
+    }
+    return FALSE;
+}
+
+gboolean buttonRelease(GtkWidget *widget, GdkEventButton *event, struct Application *app)
+{
+    if (event->type == GDK_BUTTON_RELEASE && event->button == app->dragButton)
+    {
+        app->dragButtonEvent = NULL;
+    }
+    return FALSE;
+}
+
+static void sendMessageToBackend(WebKitUserContentManager *contentManager,
+                                 WebKitJavascriptResult *result,
+                                 struct Application *app)
+{
+#if WEBKIT_MAJOR_VERSION >= 2 && WEBKIT_MINOR_VERSION >= 22
+    JSCValue *value = webkit_javascript_result_get_js_value(result);
+    char *message = jsc_value_to_string(value);
+#else
+    JSGlobalContextRef context = webkit_javascript_result_get_global_context(result);
+    JSValueRef value = webkit_javascript_result_get_value(result);
+    JSStringRef js = JSValueToStringCopy(context, value, NULL);
+    size_t messageSize = JSStringGetMaximumUTF8CStringSize(js);
+    char *message = g_new(char, messageSize);
+    JSStringGetUTF8CString(js, message, messageSize);
+    JSStringRelease(js);
+#endif
+    app->sendMessageToBackend(message);
+    g_free(message);
+}
+
+void SetDebug(struct Application *app, int flag)
+{
+    debug = flag;
+}
+
+// getCurrentMonitorGeometry gets the geometry of the monitor
+// that the window is mostly on.
+GdkRectangle getCurrentMonitorGeometry(GtkWindow *window) {
+    // Get the monitor that the window is currently on
+    GdkDisplay *display = gtk_widget_get_display(GTK_WIDGET(window));
+    GdkWindow *gdk_window = gtk_widget_get_window(GTK_WIDGET(window));
+    GdkMonitor *monitor = gdk_display_get_monitor_at_window (display, gdk_window);
+
+    // Get the geometry of the monitor
+    GdkRectangle result;
+    gdk_monitor_get_geometry (monitor,&result);
+
+    return result;
+}
+
+/*******************
+ * Window Position *
+ *******************/
+
+// Position holds an x/y corrdinate
+struct Position {
+    int x;
+    int y;
+};
+
+// Internal call for setting the position of the window.
+void setPositionInternal(struct Application *app, struct Position *pos) {
+
+    // Get the monitor geometry
+    GdkRectangle m = getCurrentMonitorGeometry(app->mainWindow);
+
+    // Move the window relative to the monitor
+    gtk_window_move(app->mainWindow, m.x + pos->x, m.y + pos->y);
+    
+    // Free memory
+    free(pos);
+}
+
+// SetPosition sets the position of the window to the given x/y 
+// coordinates. The x/y values are relative to the monitor 
+// the window is mostly on.
+void SetPosition(struct Application *app, int x, int y) {
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)setPositionInternal;
+    struct Position *pos = malloc(sizeof(struct Position));
+    pos->x = x;
+    pos->y = y;
+    data->args = pos;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+/***************
+ * Window Size *
+ ***************/
+
+// Size holds a width/height
+struct Size {
+    int width;
+    int height;
+};
+
+// Internal call for setting the size of the window.
+void setSizeInternal(struct Application *app, struct Size *size) {
+    gtk_window_resize(app->mainWindow, size->width, size->height);
+    free(size);
+}
+
+// SetSize sets the size of the window to the given width/height
+void SetSize(struct Application *app, int width, int height) {
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)setSizeInternal;
+    struct Size *size = malloc(sizeof(struct Size));
+    size->width = width;
+    size->height = height;
+    data->args = size;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+// centerInternal will center the main window on the monitor it is mostly in
+void centerInternal(struct Application *app)
+{
+    // Get the geometry of the monitor
+    GdkRectangle m = getCurrentMonitorGeometry(app->mainWindow);
+
+    // Get the window width/height
+    int windowWidth, windowHeight;
+    gtk_window_get_size(app->mainWindow, &windowWidth, &windowHeight);
+
+    // Place the window at the center of the monitor
+    gtk_window_move(app->mainWindow, ((m.width - windowWidth) / 2) + m.x, ((m.height - windowHeight) / 2) + m.y);
+}
+
+// Center the window
+void Center(struct Application *app) {
+
+    // Setup a call to centerInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)centerInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// hideInternal hides the main window
+void hideInternal(struct Application *app) {
+    gtk_widget_hide (GTK_WIDGET(app->mainWindow));
+}
+
+// Hide places the hideInternal method onto the main thread for execution
+void Hide(struct Application *app) {
+
+    // Setup a call to hideInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)hideInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// showInternal shows the main window 
+void showInternal(struct Application *app) {
+    gtk_widget_show_all(GTK_WIDGET(app->mainWindow));
+    gtk_widget_grab_focus(app->webView);
+}
+
+// Show places the showInternal method onto the main thread for execution
+void Show(struct Application *app) {
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)showInternal;
+    data->app = app;
+
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+// maximiseInternal maximises the main window
+void maximiseInternal(struct Application *app) {
+    gtk_window_maximize(GTK_WIDGET(app->mainWindow));
+}
+
+// Maximise places the maximiseInternal method onto the main thread for execution
+void Maximise(struct Application *app) {
+
+    // Setup a call to maximiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)maximiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// unmaximiseInternal unmaximises the main window
+void unmaximiseInternal(struct Application *app) {
+    gtk_window_unmaximize(GTK_WIDGET(app->mainWindow));
+}
+
+// Unmaximise places the unmaximiseInternal method onto the main thread for execution
+void Unmaximise(struct Application *app) {
+
+    // Setup a call to unmaximiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)unmaximiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+// minimiseInternal minimises the main window
+void minimiseInternal(struct Application *app) {
+    gtk_window_iconify(app->mainWindow);
+}
+
+// Minimise places the minimiseInternal method onto the main thread for execution
+void Minimise(struct Application *app) {
+
+    // Setup a call to minimiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)minimiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+// unminimiseInternal unminimises the main window
+void unminimiseInternal(struct Application *app) {
+    gtk_window_present(app->mainWindow);
+}
+
+// Unminimise places the unminimiseInternal method onto the main thread for execution
+void Unminimise(struct Application *app) {
+
+    // Setup a call to unminimiseInternal on the main thread
+    struct dispatchData *data = (struct dispatchData *)g_new(struct dispatchData, 1);
+    data->method = (dispatchMethod)unminimiseInternal;
+    data->app = app;
+
+    // Add call to main thread
+    gdk_threads_add_idle(executeMethod, data);  
+}
+
+
+void SetBindings(struct Application *app, const char *bindings)
+{
+    const char *temp = concat("window.wailsbindings = \"", bindings);
+    const char *jscall = concat(temp, "\";");
+    free((void *)temp);
+    app->bindings = jscall;
+}
+
+// This is called when the close button on the window is pressed
+gboolean close_button_pressed(GtkWidget *widget,
+                              GdkEvent *event,
+                              struct Application *app)
+{
+    app->sendMessageToBackend("WC"); // Window Close
+    return TRUE;
+}
+
+static void setupWindow(struct Application *app)
+{
+
+    // Create the window
+    GtkWidget *mainWindow = gtk_application_window_new(app->application);
+    // Save reference
+    app->mainWindow = GTK_WINDOW(mainWindow);
+
+    // Setup frame
+    gtk_window_set_decorated((GtkWindow *)mainWindow, app->frame);
+
+    // Setup title
+    gtk_window_set_title(GTK_WINDOW(mainWindow), app->title);
+
+    // Setup script handler
+    WebKitUserContentManager *contentManager = webkit_user_content_manager_new();
+
+    // Setup the invoke handler
+    webkit_user_content_manager_register_script_message_handler(contentManager, "external");
+    app->signalInvoke = g_signal_connect(contentManager, "script-message-received::external", G_CALLBACK(sendMessageToBackend), app);
+
+    // Setup the window drag handler if this is a frameless app
+    if ( app->frame == 0 ) {
+        webkit_user_content_manager_register_script_message_handler(contentManager, "windowDrag");
+        app->signalWindowDrag = g_signal_connect(contentManager, "script-message-received::windowDrag", G_CALLBACK(dragWindow), app);
+        // Setup the mouse handlers
+        app->signalButtonPressed = g_signal_connect(app->webView, "button-press-event", G_CALLBACK(buttonPress), app);
+        app->signalButtonReleased = g_signal_connect(app->webView, "button-release-event", G_CALLBACK(buttonRelease), app);
+    }
+    GtkWidget *webView = webkit_web_view_new_with_user_content_manager(contentManager);
+
+    // Save reference
+    app->webView = webView;
+
+    // Add the webview to the window
+    gtk_container_add(GTK_CONTAINER(mainWindow), webView);
+
+
+    // Load default HTML
+    app->signalLoadChanged = g_signal_connect(G_OBJECT(webView), "load-changed", G_CALLBACK(load_finished_cb), app);
+
+    // Load the user's HTML
+    // assets[0] is the HTML because the asset array is bundled like that by convention
+    webkit_web_view_load_uri(WEBKIT_WEB_VIEW(webView), assets[0]);
+
+    // Check if we want to enable the dev tools
+    if (app->devtools)
+    {
+        WebKitSettings *settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView));
+        // webkit_settings_set_enable_write_console_messages_to_stdout(settings, true);
+        webkit_settings_set_enable_developer_extras(settings, true);
+    }
+    else
+    {
+        g_signal_connect(G_OBJECT(webView), "context-menu", G_CALLBACK(disable_context_menu_cb), app);
+    }
+
+    // Listen for close button signal
+    g_signal_connect(GTK_WIDGET(mainWindow), "delete-event", G_CALLBACK(close_button_pressed), app);
+}
+
+static void activate(GtkApplication* _, struct Application *app)
+{
+    setupWindow(app);
+}
+
+void Run(struct Application *app, int argc, char **argv)
+{
+    g_signal_connect(app->application, "activate", G_CALLBACK(activate), app);
+    g_application_run(G_APPLICATION(app->application), argc, argv);
+}
+
+#endif

v2/internal/ffenestri/hashmap.h

@@ -0,0 +1,518 @@
+/*
+   The latest version of this library is available on GitHub;
+   https://github.com/sheredom/hashmap.h
+*/
+
+/*
+   This is free and unencumbered software released into the public domain.
+
+   Anyone is free to copy, modify, publish, use, compile, sell, or
+   distribute this software, either in source code form or as a compiled
+   binary, for any purpose, commercial or non-commercial, and by any
+   means.
+
+   In jurisdictions that recognize copyright laws, the author or authors
+   of this software dedicate any and all copyright interest in the
+   software to the public domain. We make this dedication for the benefit
+   of the public at large and to the detriment of our heirs and
+   successors. We intend this dedication to be an overt act of
+   relinquishment in perpetuity of all present and future rights to this
+   software under copyright law.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+   OTHER DEALINGS IN THE SOFTWARE.
+
+   For more information, please refer to <http://unlicense.org/>
+*/
+#ifndef SHEREDOM_HASHMAP_H_INCLUDED
+#define SHEREDOM_HASHMAP_H_INCLUDED
+
+#if defined(_MSC_VER)
+// Workaround a bug in the MSVC runtime where it uses __cplusplus when not
+// defined.
+#pragma warning(push, 0)
+#pragma warning(disable : 4668)
+#endif
+#include <stdlib.h>
+#include <string.h>
+
+#if (defined(_MSC_VER) && defined(__AVX__)) ||                                 \
+    (!defined(_MSC_VER) && defined(__SSE4_2__))
+#define HASHMAP_SSE42
+#endif
+
+#if defined(HASHMAP_SSE42)
+#include <nmmintrin.h>
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+// Stop MSVC complaining about not inlining functions.
+#pragma warning(disable : 4710)
+// Stop MSVC complaining about inlining functions!
+#pragma warning(disable : 4711)
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+#if defined(_MSC_VER)
+#define HASHMAP_USED
+#elif defined(__GNUC__)
+#define HASHMAP_USED __attribute__((used))
+#else
+#define HASHMAP_USED
+#endif
+
+/* We need to keep keys and values. */
+struct hashmap_element_s {
+  const char *key;
+  unsigned key_len;
+  int in_use;
+  void *data;
+};
+
+/* A hashmap has some maximum size and current size, as well as the data to
+ * hold. */
+struct hashmap_s {
+  unsigned table_size;
+  unsigned size;
+  struct hashmap_element_s *data;
+};
+
+#define HASHMAP_MAX_CHAIN_LENGTH (8)
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/// @brief Create a hashmap.
+/// @param initial_size The initial size of the hashmap. Must be a power of two.
+/// @param out_hashmap The storage for the created hashmap.
+/// @return On success 0 is returned.
+///
+/// Note that the initial size of the hashmap must be a power of two, and
+/// creation of the hashmap will fail if this is not the case.
+static int hashmap_create(const unsigned initial_size,
+                          struct hashmap_s *const out_hashmap) HASHMAP_USED;
+
+/// @brief Put an element into the hashmap.
+/// @param hashmap The hashmap to insert into.
+/// @param key The string key to use.
+/// @param len The length of the string key.
+/// @param value The value to insert.
+/// @return On success 0 is returned.
+///
+/// The key string slice is not copied when creating the hashmap entry, and thus
+/// must remain a valid pointer until the hashmap entry is removed or the
+/// hashmap is destroyed.
+static int hashmap_put(struct hashmap_s *const hashmap, const char *const key,
+                       const unsigned len, void *const value) HASHMAP_USED;
+
+/// @brief Get an element from the hashmap.
+/// @param hashmap The hashmap to get from.
+/// @param key The string key to use.
+/// @param len The length of the string key.
+/// @return The previously set element, or NULL if none exists.
+static void *hashmap_get(const struct hashmap_s *const hashmap,
+                         const char *const key,
+                         const unsigned len) HASHMAP_USED;
+
+/// @brief Remove an element from the hashmap.
+/// @param hashmap The hashmap to remove from.
+/// @param key The string key to use.
+/// @param len The length of the string key.
+/// @return On success 0 is returned.
+static int hashmap_remove(struct hashmap_s *const hashmap,
+                          const char *const key,
+                          const unsigned len) HASHMAP_USED;
+
+/// @brief Iterate over all the elements in a hashmap.
+/// @param hashmap The hashmap to iterate over.
+/// @param f The function pointer to call on each element.
+/// @param context The context to pass as the first argument to f.
+/// @return If the entire hashmap was iterated then 0 is returned. Otherwise if
+/// the callback function f returned non-zero then non-zero is returned.
+static int hashmap_iterate(const struct hashmap_s *const hashmap,
+                           int (*f)(void *const context, void *const value),
+                           void *const context) HASHMAP_USED;
+
+/// @brief Iterate over all the elements in a hashmap.
+/// @param hashmap The hashmap to iterate over.
+/// @param f The function pointer to call on each element.
+/// @param context The context to pass as the first argument to f.
+/// @return If the entire hashmap was iterated then 0 is returned.
+/// Otherwise if the callback function f returned positive then the positive 
+/// value is returned.  If the callback function returns -1, the current item
+/// is removed and iteration continues.
+static int hashmap_iterate_pairs(struct hashmap_s *const hashmap,
+                    int (*f)(void *const, struct hashmap_element_s *const),
+                    void *const context) HASHMAP_USED;
+
+/// @brief Get the size of the hashmap.
+/// @param hashmap The hashmap to get the size of.
+/// @return The size of the hashmap.
+static unsigned
+hashmap_num_entries(const struct hashmap_s *const hashmap) HASHMAP_USED;
+
+/// @brief Destroy the hashmap.
+/// @param hashmap The hashmap to destroy.
+static void hashmap_destroy(struct hashmap_s *const hashmap) HASHMAP_USED;
+
+static unsigned hashmap_crc32_helper(const char *const s,
+                                     const unsigned len) HASHMAP_USED;
+static unsigned
+hashmap_hash_helper_int_helper(const struct hashmap_s *const m,
+                               const char *const keystring,
+                               const unsigned len) HASHMAP_USED;
+static int hashmap_match_helper(const struct hashmap_element_s *const element,
+                                const char *const key,
+                                const unsigned len) HASHMAP_USED;
+static int hashmap_hash_helper(const struct hashmap_s *const m,
+                               const char *const key, const unsigned len,
+                               unsigned *const out_index) HASHMAP_USED;
+static int hashmap_rehash_iterator(void *const new_hash, 
+                              struct hashmap_element_s *const e) HASHMAP_USED;
+static int hashmap_rehash_helper(struct hashmap_s *const m) HASHMAP_USED;
+
+#if defined(__cplusplus)
+}
+#endif
+
+#if defined(__cplusplus)
+#define HASHMAP_CAST(type, x) static_cast<type>(x)
+#define HASHMAP_PTR_CAST(type, x) reinterpret_cast<type>(x)
+#define HASHMAP_NULL NULL
+#else
+#define HASHMAP_CAST(type, x) ((type)x)
+#define HASHMAP_PTR_CAST(type, x) ((type)x)
+#define HASHMAP_NULL 0
+#endif
+
+int hashmap_create(const unsigned initial_size,
+                   struct hashmap_s *const out_hashmap) {
+  if (0 == initial_size || 0 != (initial_size & (initial_size - 1))) {
+    return 1;
+  }
+
+  out_hashmap->data =
+      HASHMAP_CAST(struct hashmap_element_s *,
+                   calloc(initial_size, sizeof(struct hashmap_element_s)));
+  if (!out_hashmap->data) {
+    return 1;
+  }
+
+  out_hashmap->table_size = initial_size;
+  out_hashmap->size = 0;
+
+  return 0;
+}
+
+int hashmap_put(struct hashmap_s *const m, const char *const key,
+                const unsigned len, void *const value) {
+  unsigned int index;
+
+  /* Find a place to put our value. */
+  while (!hashmap_hash_helper(m, key, len, &index)) {
+    if (hashmap_rehash_helper(m)) {
+      return 1;
+    }
+  }
+
+  /* Set the data. */
+  m->data[index].data = value;
+  m->data[index].key = key;
+  m->data[index].key_len = len;
+  m->data[index].in_use = 1;
+  m->size++;
+
+  return 0;
+}
+
+void *hashmap_get(const struct hashmap_s *const m, const char *const key,
+                  const unsigned len) {
+  unsigned int curr;
+  unsigned int i;
+
+  /* Find data location */
+  curr = hashmap_hash_helper_int_helper(m, key, len);
+
+  /* Linear probing, if necessary */
+  for (i = 0; i < HASHMAP_MAX_CHAIN_LENGTH; i++) {
+    if (m->data[curr].in_use) {
+      if (hashmap_match_helper(&m->data[curr], key, len)) {
+        return m->data[curr].data;
+      }
+    }
+
+    curr = (curr + 1) % m->table_size;
+  }
+
+  /* Not found */
+  return HASHMAP_NULL;
+}
+
+int hashmap_remove(struct hashmap_s *const m, const char *const key,
+                   const unsigned len) {
+  unsigned int i;
+  unsigned int curr;
+
+  /* Find key */
+  curr = hashmap_hash_helper_int_helper(m, key, len);
+
+  /* Linear probing, if necessary */
+  for (i = 0; i < HASHMAP_MAX_CHAIN_LENGTH; i++) {
+    if (m->data[curr].in_use) {
+      if (hashmap_match_helper(&m->data[curr], key, len)) {
+        /* Blank out the fields including in_use */
+        memset(&m->data[curr], 0, sizeof(struct hashmap_element_s));
+
+        /* Reduce the size */
+        m->size--;
+        return 0;
+      }
+    }
+    curr = (curr + 1) % m->table_size;
+  }
+
+  return 1;
+}
+
+int hashmap_iterate(const struct hashmap_s *const m,
+                    int (*f)(void *const, void *const), void *const context) {
+  unsigned int i;
+
+  /* Linear probing */
+  for (i = 0; i < m->table_size; i++) {
+    if (m->data[i].in_use) {
+      if (!f(context, m->data[i].data)) {
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+int hashmap_iterate_pairs(struct hashmap_s *const hashmap,
+            int (*f)(void *const, struct hashmap_element_s *const),
+            void *const context) {
+  unsigned int i;
+  struct hashmap_element_s *p;
+  int r;
+
+  /* Linear probing */
+  for (i = 0; i < hashmap->table_size; i++) {
+    p=&hashmap->data[i];
+    if (p->in_use) {
+      r=f(context, p);
+      switch (r)
+      {
+        case -1: /* remove item */
+          memset(p, 0, sizeof(struct hashmap_element_s));
+          hashmap->size--;
+          break;
+        case 0: /* continue iterating */
+          break;
+        default: /* early exit */
+          return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+void hashmap_destroy(struct hashmap_s *const m) {
+  free(m->data);
+  memset(m, 0, sizeof(struct hashmap_s));
+}
+
+unsigned hashmap_num_entries(const struct hashmap_s *const m) {
+  return m->size;
+}
+
+unsigned hashmap_crc32_helper(const char *const s, const unsigned len) {
+  unsigned i;
+  unsigned crc32val = 0;
+
+#if defined(HASHMAP_SSE42)
+  for (i = 0; i < len; i++) {
+    crc32val = _mm_crc32_u8(crc32val, HASHMAP_CAST(unsigned char, s[i]));
+  }
+
+  return crc32val;
+#else
+  // Using polynomial 0x11EDC6F41 to match SSE 4.2's crc function.
+  static const unsigned crc32_tab[] = {
+      0x00000000U, 0xF26B8303U, 0xE13B70F7U, 0x1350F3F4U, 0xC79A971FU,
+      0x35F1141CU, 0x26A1E7E8U, 0xD4CA64EBU, 0x8AD958CFU, 0x78B2DBCCU,
+      0x6BE22838U, 0x9989AB3BU, 0x4D43CFD0U, 0xBF284CD3U, 0xAC78BF27U,
+      0x5E133C24U, 0x105EC76FU, 0xE235446CU, 0xF165B798U, 0x030E349BU,
+      0xD7C45070U, 0x25AFD373U, 0x36FF2087U, 0xC494A384U, 0x9A879FA0U,
+      0x68EC1CA3U, 0x7BBCEF57U, 0x89D76C54U, 0x5D1D08BFU, 0xAF768BBCU,
+      0xBC267848U, 0x4E4DFB4BU, 0x20BD8EDEU, 0xD2D60DDDU, 0xC186FE29U,
+      0x33ED7D2AU, 0xE72719C1U, 0x154C9AC2U, 0x061C6936U, 0xF477EA35U,
+      0xAA64D611U, 0x580F5512U, 0x4B5FA6E6U, 0xB93425E5U, 0x6DFE410EU,
+      0x9F95C20DU, 0x8CC531F9U, 0x7EAEB2FAU, 0x30E349B1U, 0xC288CAB2U,
+      0xD1D83946U, 0x23B3BA45U, 0xF779DEAEU, 0x05125DADU, 0x1642AE59U,
+      0xE4292D5AU, 0xBA3A117EU, 0x4851927DU, 0x5B016189U, 0xA96AE28AU,
+      0x7DA08661U, 0x8FCB0562U, 0x9C9BF696U, 0x6EF07595U, 0x417B1DBCU,
+      0xB3109EBFU, 0xA0406D4BU, 0x522BEE48U, 0x86E18AA3U, 0x748A09A0U,
+      0x67DAFA54U, 0x95B17957U, 0xCBA24573U, 0x39C9C670U, 0x2A993584U,
+      0xD8F2B687U, 0x0C38D26CU, 0xFE53516FU, 0xED03A29BU, 0x1F682198U,
+      0x5125DAD3U, 0xA34E59D0U, 0xB01EAA24U, 0x42752927U, 0x96BF4DCCU,
+      0x64D4CECFU, 0x77843D3BU, 0x85EFBE38U, 0xDBFC821CU, 0x2997011FU,
+      0x3AC7F2EBU, 0xC8AC71E8U, 0x1C661503U, 0xEE0D9600U, 0xFD5D65F4U,
+      0x0F36E6F7U, 0x61C69362U, 0x93AD1061U, 0x80FDE395U, 0x72966096U,
+      0xA65C047DU, 0x5437877EU, 0x4767748AU, 0xB50CF789U, 0xEB1FCBADU,
+      0x197448AEU, 0x0A24BB5AU, 0xF84F3859U, 0x2C855CB2U, 0xDEEEDFB1U,
+      0xCDBE2C45U, 0x3FD5AF46U, 0x7198540DU, 0x83F3D70EU, 0x90A324FAU,
+      0x62C8A7F9U, 0xB602C312U, 0x44694011U, 0x5739B3E5U, 0xA55230E6U,
+      0xFB410CC2U, 0x092A8FC1U, 0x1A7A7C35U, 0xE811FF36U, 0x3CDB9BDDU,
+      0xCEB018DEU, 0xDDE0EB2AU, 0x2F8B6829U, 0x82F63B78U, 0x709DB87BU,
+      0x63CD4B8FU, 0x91A6C88CU, 0x456CAC67U, 0xB7072F64U, 0xA457DC90U,
+      0x563C5F93U, 0x082F63B7U, 0xFA44E0B4U, 0xE9141340U, 0x1B7F9043U,
+      0xCFB5F4A8U, 0x3DDE77ABU, 0x2E8E845FU, 0xDCE5075CU, 0x92A8FC17U,
+      0x60C37F14U, 0x73938CE0U, 0x81F80FE3U, 0x55326B08U, 0xA759E80BU,
+      0xB4091BFFU, 0x466298FCU, 0x1871A4D8U, 0xEA1A27DBU, 0xF94AD42FU,
+      0x0B21572CU, 0xDFEB33C7U, 0x2D80B0C4U, 0x3ED04330U, 0xCCBBC033U,
+      0xA24BB5A6U, 0x502036A5U, 0x4370C551U, 0xB11B4652U, 0x65D122B9U,
+      0x97BAA1BAU, 0x84EA524EU, 0x7681D14DU, 0x2892ED69U, 0xDAF96E6AU,
+      0xC9A99D9EU, 0x3BC21E9DU, 0xEF087A76U, 0x1D63F975U, 0x0E330A81U,
+      0xFC588982U, 0xB21572C9U, 0x407EF1CAU, 0x532E023EU, 0xA145813DU,
+      0x758FE5D6U, 0x87E466D5U, 0x94B49521U, 0x66DF1622U, 0x38CC2A06U,
+      0xCAA7A905U, 0xD9F75AF1U, 0x2B9CD9F2U, 0xFF56BD19U, 0x0D3D3E1AU,
+      0x1E6DCDEEU, 0xEC064EEDU, 0xC38D26C4U, 0x31E6A5C7U, 0x22B65633U,
+      0xD0DDD530U, 0x0417B1DBU, 0xF67C32D8U, 0xE52CC12CU, 0x1747422FU,
+      0x49547E0BU, 0xBB3FFD08U, 0xA86F0EFCU, 0x5A048DFFU, 0x8ECEE914U,
+      0x7CA56A17U, 0x6FF599E3U, 0x9D9E1AE0U, 0xD3D3E1ABU, 0x21B862A8U,
+      0x32E8915CU, 0xC083125FU, 0x144976B4U, 0xE622F5B7U, 0xF5720643U,
+      0x07198540U, 0x590AB964U, 0xAB613A67U, 0xB831C993U, 0x4A5A4A90U,
+      0x9E902E7BU, 0x6CFBAD78U, 0x7FAB5E8CU, 0x8DC0DD8FU, 0xE330A81AU,
+      0x115B2B19U, 0x020BD8EDU, 0xF0605BEEU, 0x24AA3F05U, 0xD6C1BC06U,
+      0xC5914FF2U, 0x37FACCF1U, 0x69E9F0D5U, 0x9B8273D6U, 0x88D28022U,
+      0x7AB90321U, 0xAE7367CAU, 0x5C18E4C9U, 0x4F48173DU, 0xBD23943EU,
+      0xF36E6F75U, 0x0105EC76U, 0x12551F82U, 0xE03E9C81U, 0x34F4F86AU,
+      0xC69F7B69U, 0xD5CF889DU, 0x27A40B9EU, 0x79B737BAU, 0x8BDCB4B9U,
+      0x988C474DU, 0x6AE7C44EU, 0xBE2DA0A5U, 0x4C4623A6U, 0x5F16D052U,
+      0xAD7D5351U};
+
+  for (i = 0; i < len; i++) {
+    crc32val = crc32_tab[(HASHMAP_CAST(unsigned char, crc32val) ^
+                          HASHMAP_CAST(unsigned char, s[i]))] ^
+               (crc32val >> 8);
+  }
+  return crc32val;
+#endif
+}
+
+unsigned hashmap_hash_helper_int_helper(const struct hashmap_s *const m,
+                                        const char *const keystring,
+                                        const unsigned len) {
+  unsigned key = hashmap_crc32_helper(keystring, len);
+
+  /* Robert Jenkins' 32 bit Mix Function */
+  key += (key << 12);
+  key ^= (key >> 22);
+  key += (key << 4);
+  key ^= (key >> 9);
+  key += (key << 10);
+  key ^= (key >> 2);
+  key += (key << 7);
+  key ^= (key >> 12);
+
+  /* Knuth's Multiplicative Method */
+  key = (key >> 3) * 2654435761;
+
+  return key % m->table_size;
+}
+
+int hashmap_match_helper(const struct hashmap_element_s *const element,
+                         const char *const key, const unsigned len) {
+  return (element->key_len == len) && (0 == memcmp(element->key, key, len));
+}
+
+int hashmap_hash_helper(const struct hashmap_s *const m, const char *const key,
+                        const unsigned len, unsigned *const out_index) {
+  unsigned int curr;
+  unsigned int i;
+
+  /* If full, return immediately */
+  if (m->size >= m->table_size) {
+    return 0;
+  }
+
+  /* Find the best index */
+  curr = hashmap_hash_helper_int_helper(m, key, len);
+
+  /* Linear probing */
+  for (i = 0; i < HASHMAP_MAX_CHAIN_LENGTH; i++) {
+    if (!m->data[curr].in_use) {
+      *out_index = curr;
+      return 1;
+    }
+
+    if (m->data[curr].in_use &&
+        hashmap_match_helper(&m->data[curr], key, len)) {
+      *out_index = curr;
+      return 1;
+    }
+
+    curr = (curr + 1) % m->table_size;
+  }
+
+  return 0;
+}
+
+int hashmap_rehash_iterator(void *const new_hash,
+  struct hashmap_element_s *const e) {
+  int temp=hashmap_put(HASHMAP_PTR_CAST(struct hashmap_s *, new_hash),
+    e->key, e->key_len, e->data);
+  if (0<temp) {
+    return 1;
+  }
+  /* clear old value to avoid stale pointers */
+  return -1;
+}
+/*
+ * Doubles the size of the hashmap, and rehashes all the elements
+ */
+int hashmap_rehash_helper(struct hashmap_s *const m) {
+  /* If this multiplication overflows hashmap_create will fail. */
+  unsigned new_size = 2 * m->table_size;
+
+  struct hashmap_s new_hash;
+
+  int flag = hashmap_create(new_size, &new_hash);
+  if (0!=flag) {
+    return flag;
+  }
+
+  /* copy the old elements to the new table */
+  flag = hashmap_iterate_pairs(m, hashmap_rehash_iterator, HASHMAP_PTR_CAST(void *, &new_hash));
+  if (0!=flag) {
+    return flag;
+  }
+
+  hashmap_destroy(m);
+  /* put new hash into old hash structure by copying */
+  memcpy(m, &new_hash, sizeof(struct hashmap_s));
+
+  return 0;
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#elif defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif

v2/internal/ffenestri/json.h

@@ -0,0 +1,122 @@
+/*
+  Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
+  All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+
+  Source: http://git.ozlabs.org/?p=ccan;a=tree;f=ccan/json;hb=HEAD
+*/
+
+#ifndef CCAN_JSON_H
+#define CCAN_JSON_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum {
+	JSON_NULL,
+	JSON_BOOL,
+	JSON_STRING,
+	JSON_NUMBER,
+	JSON_ARRAY,
+	JSON_OBJECT,
+} JsonTag;
+
+typedef struct JsonNode JsonNode;
+
+struct JsonNode
+{
+	/* only if parent is an object or array (NULL otherwise) */
+	JsonNode *parent;
+	JsonNode *prev, *next;
+	
+	/* only if parent is an object (NULL otherwise) */
+	char *key; /* Must be valid UTF-8. */
+	
+	JsonTag tag;
+	union {
+		/* JSON_BOOL */
+		bool bool_;
+		
+		/* JSON_STRING */
+		char *string_; /* Must be valid UTF-8. */
+		
+		/* JSON_NUMBER */
+		double number_;
+		
+		/* JSON_ARRAY */
+		/* JSON_OBJECT */
+		struct {
+			JsonNode *head, *tail;
+		} children;
+	};
+};
+
+/*** Encoding, decoding, and validation ***/
+
+JsonNode   *json_decode         (const char *json);
+char       *json_encode         (const JsonNode *node);
+char       *json_encode_string  (const char *str);
+char       *json_stringify      (const JsonNode *node, const char *space);
+void        json_delete         (JsonNode *node);
+
+bool        json_validate       (const char *json);
+
+/*** Lookup and traversal ***/
+
+JsonNode   *json_find_element   (JsonNode *array, int index);
+JsonNode   *json_find_member    (JsonNode *object, const char *key);
+
+JsonNode   *json_first_child    (const JsonNode *node);
+
+#define json_foreach(i, object_or_array)            \
+	for ((i) = json_first_child(object_or_array);   \
+		 (i) != NULL;                               \
+		 (i) = (i)->next)
+
+/*** Construction and manipulation ***/
+
+JsonNode *json_mknull(void);
+JsonNode *json_mkbool(bool b);
+JsonNode *json_mkstring(const char *s);
+JsonNode *json_mknumber(double n);
+JsonNode *json_mkarray(void);
+JsonNode *json_mkobject(void);
+
+void json_append_element(JsonNode *array, JsonNode *element);
+void json_prepend_element(JsonNode *array, JsonNode *element);
+void json_append_member(JsonNode *object, const char *key, JsonNode *value);
+void json_prepend_member(JsonNode *object, const char *key, JsonNode *value);
+
+void json_remove_from_parent(JsonNode *node);
+
+/*** Debugging ***/
+
+/*
+ * Look for structure and encoding problems in a JsonNode or its descendents.
+ *
+ * If a problem is detected, return false, writing a description of the problem
+ * to errmsg (unless errmsg is NULL).
+ */
+bool json_check(const JsonNode *node, char errmsg[256]);
+
+// Added by Lea Anthony 28/11/2020
+int json_array_length(JsonNode *array);
+
+#endif

v2/internal/ffenestri/menu.go

@@ -0,0 +1,80 @@
+package ffenestri
+
+import "github.com/wailsapp/wails/v2/pkg/menu"
+
+// ProcessedMenu is the original menu with the addition
+// of radio groups extracted from the menu data
+type ProcessedMenu struct {
+	Menu              *menu.Menu
+	RadioGroups       []*RadioGroup
+	currentRadioGroup []string
+}
+
+// RadioGroup holds all the members of the same radio group
+type RadioGroup struct {
+	Members []string
+	Length  int
+}
+
+// NewProcessedMenu processed the given menu and returns
+// the original menu with the extracted radio groups
+func NewProcessedMenu(menu *menu.Menu) *ProcessedMenu {
+	result := &ProcessedMenu{
+		Menu:              menu,
+		RadioGroups:       []*RadioGroup{},
+		currentRadioGroup: []string{},
+	}
+
+	result.processMenu()
+
+	return result
+}
+
+func (p *ProcessedMenu) processMenu() {
+	// Loop over top level menus
+	for _, item := range p.Menu.Items {
+		// Process MenuItem
+		p.processMenuItem(item)
+	}
+
+	p.finaliseRadioGroup()
+}
+
+func (p *ProcessedMenu) processMenuItem(item *menu.MenuItem) {
+
+	switch item.Type {
+
+	// We need to recurse submenus
+	case menu.SubmenuType:
+
+		// Finalise any current radio groups as they don't trickle down to submenus
+		p.finaliseRadioGroup()
+
+		// Process each submenu item
+		for _, subitem := range item.SubMenu {
+			p.processMenuItem(subitem)
+		}
+	case menu.RadioType:
+		// Add the item to the radio group
+		p.currentRadioGroup = append(p.currentRadioGroup, item.ID)
+	default:
+		p.finaliseRadioGroup()
+	}
+}
+
+func (p *ProcessedMenu) finaliseRadioGroup() {
+
+	// If we were processing a radio group, fix up the references
+	if len(p.currentRadioGroup) > 0 {
+
+		// Create new radiogroup
+		group := &RadioGroup{
+			Members: p.currentRadioGroup,
+			Length:  len(p.currentRadioGroup),
+		}
+		p.RadioGroups = append(p.RadioGroups, group)
+
+		// Empty the radio group
+		p.currentRadioGroup = []string{}
+	}
+}

v2/internal/ffenestri/vec.c

@@ -0,0 +1,113 @@
+/** 
+ * Copyright (c) 2014 rxi
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "vec.h"
+
+
+int vec_expand_(char **data, int *length, int *capacity, int memsz) {
+  if (*length + 1 > *capacity) {
+    void *ptr;
+    int n = (*capacity == 0) ? 1 : *capacity << 1;
+    ptr = realloc(*data, n * memsz);
+    if (ptr == NULL) return -1;
+    *data = ptr;
+    *capacity = n;
+  }
+  return 0;
+}
+
+
+int vec_reserve_(char **data, int *length, int *capacity, int memsz, int n) {
+  (void) length;
+  if (n > *capacity) {
+    void *ptr = realloc(*data, n * memsz);
+    if (ptr == NULL) return -1;
+    *data = ptr;
+    *capacity = n;
+  }
+  return 0;
+}
+
+
+int vec_reserve_po2_(
+  char **data, int *length, int *capacity, int memsz, int n
+) {
+  int n2 = 1;
+  if (n == 0) return 0;
+  while (n2 < n) n2 <<= 1;
+  return vec_reserve_(data, length, capacity, memsz, n2);
+}
+
+
+int vec_compact_(char **data, int *length, int *capacity, int memsz) {
+  if (*length == 0) {
+    free(*data);
+    *data = NULL;
+    *capacity = 0;
+    return 0;
+  } else {
+    void *ptr;
+    int n = *length;
+    ptr = realloc(*data, n * memsz);
+    if (ptr == NULL) return -1;
+    *capacity = n;
+    *data = ptr;
+  }
+  return 0;
+}
+
+
+int vec_insert_(char **data, int *length, int *capacity, int memsz,
+                 int idx
+) {
+  int err = vec_expand_(data, length, capacity, memsz);
+  if (err) return err;
+  memmove(*data + (idx + 1) * memsz,
+          *data + idx * memsz,
+          (*length - idx) * memsz);
+  return 0;
+}
+
+
+void vec_splice_(char **data, int *length, int *capacity, int memsz,
+                 int start, int count
+) {
+  (void) capacity;
+  memmove(*data + start * memsz,
+          *data + (start + count) * memsz,
+          (*length - start - count) * memsz);
+}
+
+
+void vec_swapsplice_(char **data, int *length, int *capacity, int memsz,
+                     int start, int count
+) {
+  (void) capacity;
+  memmove(*data + start * memsz,
+          *data + (*length - count) * memsz,
+          count * memsz);
+}
+
+
+void vec_swap_(char **data, int *length, int *capacity, int memsz,
+               int idx1, int idx2 
+) {
+  unsigned char *a, *b, tmp;
+  int count;
+  (void) length;
+  (void) capacity;
+  if (idx1 == idx2) return;
+  a = (unsigned char*) *data + idx1 * memsz;
+  b = (unsigned char*) *data + idx2 * memsz;
+  count = memsz;
+  while (count--) {
+    tmp = *a;
+    *a = *b;
+    *b = tmp;
+    a++, b++;
+  }
+}

v2/internal/ffenestri/vec.h

@@ -0,0 +1,181 @@
+/** 
+ * Copyright (c) 2014 rxi
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef VEC_H
+#define VEC_H
+
+#include <stdlib.h>
+#include <string.h>
+
+#define VEC_VERSION "0.2.1"
+
+
+#define vec_unpack_(v)\
+  (char**)&(v)->data, &(v)->length, &(v)->capacity, sizeof(*(v)->data)
+
+
+#define vec_t(T)\
+  struct { T *data; int length, capacity; }
+
+
+#define vec_init(v)\
+  memset((v), 0, sizeof(*(v)))
+
+
+#define vec_deinit(v)\
+  ( free((v)->data),\
+    vec_init(v) ) 
+
+
+#define vec_push(v, val)\
+  ( vec_expand_(vec_unpack_(v)) ? -1 :\
+    ((v)->data[(v)->length++] = (val), 0), 0 )
+
+
+#define vec_pop(v)\
+  (v)->data[--(v)->length]
+
+
+#define vec_splice(v, start, count)\
+  ( vec_splice_(vec_unpack_(v), start, count),\
+    (v)->length -= (count) )
+
+
+#define vec_swapsplice(v, start, count)\
+  ( vec_swapsplice_(vec_unpack_(v), start, count),\
+    (v)->length -= (count) )
+
+
+#define vec_insert(v, idx, val)\
+  ( vec_insert_(vec_unpack_(v), idx) ? -1 :\
+    ((v)->data[idx] = (val), 0), (v)->length++, 0 )
+    
+
+#define vec_sort(v, fn)\
+  qsort((v)->data, (v)->length, sizeof(*(v)->data), fn)
+
+
+#define vec_swap(v, idx1, idx2)\
+  vec_swap_(vec_unpack_(v), idx1, idx2)
+
+
+#define vec_truncate(v, len)\
+  ((v)->length = (len) < (v)->length ? (len) : (v)->length)
+
+
+#define vec_clear(v)\
+  ((v)->length = 0)
+
+
+#define vec_first(v)\
+  (v)->data[0]
+
+
+#define vec_last(v)\
+  (v)->data[(v)->length - 1]
+
+
+#define vec_reserve(v, n)\
+  vec_reserve_(vec_unpack_(v), n)
+
+ 
+#define vec_compact(v)\
+  vec_compact_(vec_unpack_(v))
+
+
+#define vec_pusharr(v, arr, count)\
+  do {\
+    int i__, n__ = (count);\
+    if (vec_reserve_po2_(vec_unpack_(v), (v)->length + n__) != 0) break;\
+    for (i__ = 0; i__ < n__; i__++) {\
+      (v)->data[(v)->length++] = (arr)[i__];\
+    }\
+  } while (0)
+
+
+#define vec_extend(v, v2)\
+  vec_pusharr((v), (v2)->data, (v2)->length)
+
+
+#define vec_find(v, val, idx)\
+  do {\
+    for ((idx) = 0; (idx) < (v)->length; (idx)++) {\
+      if ((v)->data[(idx)] == (val)) break;\
+    }\
+    if ((idx) == (v)->length) (idx) = -1;\
+  } while (0)
+
+
+#define vec_remove(v, val)\
+  do {\
+    int idx__;\
+    vec_find(v, val, idx__);\
+    if (idx__ != -1) vec_splice(v, idx__, 1);\
+  } while (0)
+
+
+#define vec_reverse(v)\
+  do {\
+    int i__ = (v)->length / 2;\
+    while (i__--) {\
+      vec_swap((v), i__, (v)->length - (i__ + 1));\
+    }\
+  } while (0)
+
+
+#define vec_foreach(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = 0;\
+        (iter) < (v)->length && (((var) = (v)->data[(iter)]), 1);\
+        ++(iter))
+
+
+#define vec_foreach_rev(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = (v)->length - 1;\
+        (iter) >= 0 && (((var) = (v)->data[(iter)]), 1);\
+        --(iter))
+
+
+#define vec_foreach_ptr(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = 0;\
+        (iter) < (v)->length && (((var) = &(v)->data[(iter)]), 1);\
+        ++(iter))
+
+
+#define vec_foreach_ptr_rev(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = (v)->length - 1;\
+        (iter) >= 0 && (((var) = &(v)->data[(iter)]), 1);\
+        --(iter))
+
+
+
+int vec_expand_(char **data, int *length, int *capacity, int memsz);
+int vec_reserve_(char **data, int *length, int *capacity, int memsz, int n);
+int vec_reserve_po2_(char **data, int *length, int *capacity, int memsz,
+                     int n);
+int vec_compact_(char **data, int *length, int *capacity, int memsz);
+int vec_insert_(char **data, int *length, int *capacity, int memsz,
+                int idx);
+void vec_splice_(char **data, int *length, int *capacity, int memsz,
+                 int start, int count);
+void vec_swapsplice_(char **data, int *length, int *capacity, int memsz,
+                     int start, int count);
+void vec_swap_(char **data, int *length, int *capacity, int memsz,
+               int idx1, int idx2);
+
+
+typedef vec_t(void*) vec_void_t;
+typedef vec_t(char*) vec_str_t;
+typedef vec_t(int) vec_int_t;
+typedef vec_t(char) vec_char_t;
+typedef vec_t(float) vec_float_t;
+typedef vec_t(double) vec_double_t;
+
+#endif

v2/internal/fs/fs.go

@@ -0,0 +1,279 @@
+package fs
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"unsafe"
+
+	"github.com/leaanthony/slicer"
+)
+
+// LocalDirectory gets the caller's file directory
+// Equivalent to node's __DIRNAME
+func LocalDirectory() string {
+	_, thisFile, _, _ := runtime.Caller(1)
+	return filepath.Dir(thisFile)
+}
+
+// RelativeToCwd returns an absolute path based on the cwd
+// and the given relative path
+func RelativeToCwd(relativePath string) (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(cwd, relativePath), nil
+}
+
+// Mkdir will create the given directory
+func Mkdir(dirname string) error {
+	return os.Mkdir(dirname, 0755)
+}
+
+// MkDirs creates the given nested directories.
+// Returns error on failure
+func MkDirs(fullPath string, mode ...os.FileMode) error {
+	var perms os.FileMode
+	perms = 0700
+	if len(mode) == 1 {
+		perms = mode[0]
+	}
+	return os.MkdirAll(fullPath, perms)
+}
+
+// MoveFile attempts to move the source file to the target
+// Target is a fully qualified path to a file *name*, not a
+// directory
+func MoveFile(source string, target string) error {
+	return os.Rename(source, target)
+}
+
+// DeleteFile will delete the given file
+func DeleteFile(filename string) error {
+	return os.Remove(filename)
+}
+
+// CopyFile from source to target
+func CopyFile(source string, target string) error {
+	s, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer s.Close()
+	d, err := os.Create(target)
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(d, s); err != nil {
+		d.Close()
+		return err
+	}
+	return d.Close()
+}
+
+// DirExists - Returns true if the given path resolves to a directory on the filesystem
+func DirExists(path string) bool {
+	fi, err := os.Lstat(path)
+	if err != nil {
+		return false
+	}
+
+	return fi.Mode().IsDir()
+}
+
+// FileExists returns a boolean value indicating whether
+// the given file exists
+func FileExists(path string) bool {
+	fi, err := os.Lstat(path)
+	if err != nil {
+		return false
+	}
+
+	return fi.Mode().IsRegular()
+}
+
+// RelativePath returns a qualified path created by joining the
+// directory of the calling file and the given relative path.
+//
+// Example: RelativePath("..") in *this* file would give you '/path/to/wails2/v2/internal`
+func RelativePath(relativepath string, optionalpaths ...string) string {
+	_, thisFile, _, _ := runtime.Caller(1)
+	localDir := filepath.Dir(thisFile)
+
+	// If we have optional paths, join them to the relativepath
+	if len(optionalpaths) > 0 {
+		paths := []string{relativepath}
+		paths = append(paths, optionalpaths...)
+		relativepath = filepath.Join(paths...)
+	}
+	result, err := filepath.Abs(filepath.Join(localDir, relativepath))
+	if err != nil {
+		// I'm allowing this for 1 reason only: It's fatal if the path
+		// supplied is wrong as it's only used internally in Wails. If we get
+		// that path wrong, we should know about it immediately. The other reason is
+		// that it cuts down a ton of unnecassary error handling.
+		panic(err)
+	}
+	return result
+}
+
+// MustLoadString attempts to load a string and will abort with a fatal message if
+// something goes wrong
+func MustLoadString(filename string) string {
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		fmt.Printf("FATAL: Unable to load file '%s': %s\n", filename, err.Error())
+		os.Exit(1)
+	}
+	return *(*string)(unsafe.Pointer(&data))
+}
+
+// MD5File returns the md5sum of the given file
+func MD5File(filename string) (string, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+
+	h := md5.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
+}
+
+// MustMD5File will call MD5File and abort the program on error
+func MustMD5File(filename string) string {
+	result, err := MD5File(filename)
+	if err != nil {
+		println("FATAL: Unable to MD5Sum file:", err.Error())
+		os.Exit(1)
+	}
+	return result
+}
+
+// MustWriteString will attempt to write the given data to the given filename
+// It will abort the program in the event of a failure
+func MustWriteString(filename string, data string) {
+	err := ioutil.WriteFile(filename, []byte(data), 0755)
+	if err != nil {
+		fatal("Unable to write file", filename, ":", err.Error())
+		os.Exit(1)
+	}
+}
+
+// fatal will print the optional messages and die
+func fatal(message ...string) {
+	if len(message) > 0 {
+		print("FATAL:")
+		for text := range message {
+			print(text)
+		}
+	}
+	os.Exit(1)
+}
+
+// GetSubdirectories returns a list of subdirectories for the given root directory
+func GetSubdirectories(rootDir string) (*slicer.StringSlicer, error) {
+	var result slicer.StringSlicer
+
+	// Iterate root dir
+	err := filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// If we have a directory, save it
+		if info.IsDir() {
+			result.Add(path)
+		}
+		return nil
+	})
+	return &result, err
+}
+
+func DirIsEmpty(dir string) (bool, error) {
+
+	if !DirExists(dir) {
+		return false, fmt.Errorf("DirIsEmpty called with a non-existant directory: %s", dir)
+	}
+
+	// CREDIT: https://stackoverflow.com/a/30708914/8325411
+	f, err := os.Open(dir)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+
+	_, err = f.Readdirnames(1) // Or f.Readdir(1)
+	if err == io.EOF {
+		return true, nil
+	}
+	return false, err // Either not empty or error, suits both cases
+}
+
+// Credit: https://gist.github.com/r0l1/92462b38df26839a3ca324697c8cba04
+// CopyDir recursively copies a directory tree, attempting to preserve permissions.
+// Source directory must exist, destination directory must *not* exist.
+// Symlinks are ignored and skipped.
+func CopyDir(src string, dst string) (err error) {
+	src = filepath.Clean(src)
+	dst = filepath.Clean(dst)
+
+	si, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+	if !si.IsDir() {
+		return fmt.Errorf("source is not a directory")
+	}
+
+	_, err = os.Stat(dst)
+	if err != nil && !os.IsNotExist(err) {
+		return
+	}
+	if err == nil {
+		return fmt.Errorf("destination already exists")
+	}
+
+	err = os.MkdirAll(dst, si.Mode())
+	if err != nil {
+		return
+	}
+
+	entries, err := ioutil.ReadDir(src)
+	if err != nil {
+		return
+	}
+
+	for _, entry := range entries {
+		srcPath := filepath.Join(src, entry.Name())
+		dstPath := filepath.Join(dst, entry.Name())
+
+		if entry.IsDir() {
+			err = CopyDir(srcPath, dstPath)
+			if err != nil {
+				return
+			}
+		} else {
+			// Skip symlinks.
+			if entry.Mode()&os.ModeSymlink != 0 {
+				continue
+			}
+
+			err = CopyFile(srcPath, dstPath)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}

v2/internal/fs/fs_test.go

@@ -0,0 +1,31 @@
+package fs
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/matryer/is"
+)
+
+func TestRelativePath(t *testing.T) {
+
+	is := is.New(t)
+
+	cwd, err := os.Getwd()
+	is.Equal(err, nil)
+
+	// Check current directory
+	actual := RelativePath(".")
+	is.Equal(actual, cwd)
+
+	// Check 2 parameters
+	actual = RelativePath("..", "fs")
+	is.Equal(actual, cwd)
+
+	// Check 3 parameters including filename
+	actual = RelativePath("..", "fs", "fs.go")
+	expected := filepath.Join(cwd, "fs.go")
+	is.Equal(actual, expected)
+
+}

v2/internal/html/asset.go

@@ -0,0 +1,127 @@
+package html
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/url"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"unsafe"
+
+	"github.com/tdewolff/minify"
+	"github.com/tdewolff/minify/js"
+)
+
+type assetTypes struct {
+	JS      string
+	CSS     string
+	FAVICON string
+	HTML    string
+}
+
+// AssetTypes is an enum for the asset type keys
+var AssetTypes *assetTypes = &assetTypes{
+	JS:      "javascript",
+	CSS:     "css",
+	FAVICON: "favicon",
+	HTML:    "html",
+}
+
+// Asset describes an asset type and its path
+type Asset struct {
+	Type string
+	Path string
+	Data string
+}
+
+// Load the asset from disk
+func (a *Asset) Load(basedirectory string) error {
+	assetpath := filepath.Join(basedirectory, a.Path)
+	data, err := ioutil.ReadFile(assetpath)
+	if err != nil {
+		return err
+	}
+	a.Data = string(data)
+	return nil
+}
+
+// AsString returns the data as a READ ONLY string
+func (a *Asset) AsString() string {
+	return a.Data
+}
+
+// AsCHexData processes the asset data so it may be used by C
+func (a *Asset) AsCHexData() string {
+
+	// This will be our final string to hexify
+	dataString := a.Data
+
+	switch a.Type {
+	case AssetTypes.HTML:
+
+		// Escape HTML
+		var re = regexp.MustCompile(`\s{2,}`)
+		result := re.ReplaceAllString(a.Data, ``)
+		result = strings.ReplaceAll(result, "\n", "")
+		result = strings.ReplaceAll(result, "\r\n", "")
+		result = strings.ReplaceAll(result, "\n", "")
+
+		// Inject wailsloader code
+		result = strings.Replace(result, `</body>`, `<script id='wailsloader'>window.wailsloader = { html: true, runtime: false, userjs: false, usercss: false };var self=document.querySelector('#wailsloader');self.parentNode.removeChild(self);</script></body>`, 1)
+
+		url := url.URL{Path: result}
+		urlString := strings.ReplaceAll(url.String(), "/", "%2f")
+
+		// Save Data uRI string
+		dataString = "data:text/html;charset=utf-8," + urlString
+
+	case AssetTypes.CSS:
+
+		// Escape CSS data
+		var re = regexp.MustCompile(`\s{2,}`)
+		result := re.ReplaceAllString(a.Data, ``)
+		result = strings.ReplaceAll(result, "\n", "")
+		result = strings.ReplaceAll(result, "\r\n", "")
+		result = strings.ReplaceAll(result, "\n", "")
+		result = strings.ReplaceAll(result, "\t", "")
+		result = strings.ReplaceAll(result, `\`, `\\`)
+		result = strings.ReplaceAll(result, `"`, `\"`)
+		result = strings.ReplaceAll(result, `'`, `\'`)
+		result = strings.ReplaceAll(result, ` {`, `{`)
+		result = strings.ReplaceAll(result, `: `, `:`)
+		dataString = fmt.Sprintf("window.wails._.InjectCSS(\"%s\");", result)
+
+	case AssetTypes.JS:
+		m := minify.New()
+		m.AddFunc("application/javascript", js.Minify)
+		var err error
+		dataString, err = m.String("application/javascript", a.Data+";")
+		if err != nil {
+			log.Fatal(err)
+		}
+		a.Data = dataString
+	}
+
+	// Get byte data of the string
+	bytes := *(*[]byte)(unsafe.Pointer(&dataString))
+
+	// Create a strings builder
+	var cdata strings.Builder
+
+	// Set buffer size to 4k
+	cdata.Grow(4096)
+
+	// Convert each byte to hex
+	for _, b := range bytes {
+		cdata.WriteString(fmt.Sprintf("0x%x, ", b))
+	}
+
+	return cdata.String()
+}
+
+// Dump will output the asset to the terminal
+func (a *Asset) Dump() {
+	fmt.Printf("{ Type: %s, Path: %s, Data: %+v }\n", a.Type, a.Path, a.Data[:10])
+}

v2/internal/html/assetbundle.go

@@ -0,0 +1,215 @@
+package html
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/leaanthony/slicer"
+	"github.com/wailsapp/wails/v2/internal/assetdb"
+	"golang.org/x/net/html"
+)
+
+// AssetBundle is a collection of Assets
+type AssetBundle struct {
+	assets        []*Asset
+	basedirectory string
+}
+
+// NewAssetBundle creates a new AssetBundle struct containing
+// the given html and all the assets referenced by it
+func NewAssetBundle(pathToHTML string) (*AssetBundle, error) {
+
+	// Create result
+	result := &AssetBundle{
+		basedirectory: filepath.Dir(pathToHTML),
+	}
+
+	err := result.loadAssets(pathToHTML)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// loadAssets processes the given html file and loads in
+// all referenced assets
+func (a *AssetBundle) loadAssets(pathToHTML string) error {
+
+	// Save HTML
+	htmlAsset := &Asset{
+		Type: AssetTypes.HTML,
+		Path: filepath.Base(pathToHTML),
+	}
+	err := htmlAsset.Load(a.basedirectory)
+	if err != nil {
+		return err
+	}
+	a.assets = append(a.assets, htmlAsset)
+
+	return a.processHTML(htmlAsset.AsString())
+}
+
+// Credit to: https://drstearns.github.io/tutorials/tokenizing/
+func (a *AssetBundle) processHTML(htmldata string) error {
+
+	// Tokenize the html
+	buf := bytes.NewBufferString(htmldata)
+	tokenizer := html.NewTokenizer(buf)
+
+	paths := slicer.String()
+
+	for {
+		//get the next token type
+		tokenType := tokenizer.Next()
+
+		//if it's an error token, we either reached
+		//the end of the file, or the HTML was malformed
+		if tokenType == html.ErrorToken {
+			err := tokenizer.Err()
+			if err == io.EOF {
+				//end of the file, break out of the loop
+				break
+			}
+			//otherwise, there was an error tokenizing,
+			//which likely means the HTML was malformed.
+			//since this is a simple command-line utility,
+			//we can just use log.Fatalf() to report the error
+			//and exit the process with a non-zero status code
+			return tokenizer.Err()
+		}
+
+		//process the token according to the token type...
+		if tokenType == html.StartTagToken {
+			//get the token
+			token := tokenizer.Token()
+
+			//if the name of the element is "title"
+			if "link" == token.Data {
+				//the next token should be the page title
+				tokenType = tokenizer.Next()
+				//just make sure it's actually a text token
+				asset := &Asset{}
+				for _, attr := range token.Attr {
+					// Favicon
+					if attr.Key == "rel" && attr.Val == "icon" {
+						asset.Type = AssetTypes.FAVICON
+					}
+					if attr.Key == "href" {
+						asset.Path = attr.Val
+					}
+					// standard stylesheet
+					if attr.Key == "rel" && attr.Val == "stylesheet" {
+						asset.Type = AssetTypes.CSS
+					}
+					if attr.Key == "as" && attr.Val == "style" {
+						asset.Type = AssetTypes.CSS
+					}
+					if attr.Key == "as" && attr.Val == "script" {
+						asset.Type = AssetTypes.JS
+					}
+				}
+
+				// Ensure we don't include duplicates
+				if !paths.Contains(asset.Path) {
+					err := asset.Load(a.basedirectory)
+					if err != nil {
+						return err
+					}
+					a.assets = append(a.assets, asset)
+					paths.Add(asset.Path)
+				}
+			}
+			if "script" == token.Data {
+				tokenType = tokenizer.Next()
+				//just make sure it's actually a text token
+				asset := &Asset{Type: AssetTypes.JS}
+				for _, attr := range token.Attr {
+					if attr.Key == "src" {
+						asset.Path = attr.Val
+						break
+					}
+				}
+				if !paths.Contains(asset.Path) {
+					err := asset.Load(a.basedirectory)
+					if err != nil {
+						return err
+					}
+					a.assets = append(a.assets, asset)
+					paths.Add(asset.Path)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// WriteToCFile dumps all the assets to C files in the given directory
+func (a *AssetBundle) WriteToCFile(targetDir string) (string, error) {
+
+	// Write out the assets.c file
+	var cdata strings.Builder
+
+	// Write header
+	header := `// assets.h
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL.
+// This file was auto-generated. DO NOT MODIFY.
+
+`
+	cdata.WriteString(header)
+
+	// Loop over the Assets
+	var err error
+	assetVariables := slicer.String()
+	var variableName string
+	for index, asset := range a.assets {
+		// For desktop we ignore the favicon
+		if asset.Type == AssetTypes.FAVICON {
+			continue
+		}
+		variableName = fmt.Sprintf("%s%d", asset.Type, index)
+		assetCdata := fmt.Sprintf("const unsigned char %s[]={ %s0x00 };\n", variableName, asset.AsCHexData())
+		cdata.WriteString(assetCdata)
+		assetVariables.Add(variableName)
+	}
+
+	if assetVariables.Length() > 0 {
+		cdata.WriteString(fmt.Sprintf("\nconst unsigned char *assets[] = { %s, 0x00 };", assetVariables.Join(", ")))
+	} else {
+		cdata.WriteString("\nconst unsigned char *assets[] = { 0x00 };")
+	}
+
+	// Save file
+	assetsFile := filepath.Join(targetDir, "assets.h")
+	err = ioutil.WriteFile(assetsFile, []byte(cdata.String()), 0600)
+	if err != nil {
+		return "", err
+	}
+	return assetsFile, nil
+}
+
+// ConvertToAssetDB returns an assetdb.AssetDB initialized with
+// the items in the AssetBundle
+func (a *AssetBundle) ConvertToAssetDB() (*assetdb.AssetDB, error) {
+	theassetdb := assetdb.NewAssetDB()
+
+	// Loop over the Assets
+	for _, asset := range a.assets {
+		theassetdb.AddAsset(asset.Path, []byte(asset.Data))
+	}
+
+	return theassetdb, nil
+}
+
+// Dump will output the assets to the terminal
+func (a *AssetBundle) Dump() {
+	println("Assets:")
+	for _, asset := range a.assets {
+		asset.Dump()
+	}
+}

v2/internal/logger/custom_logger.go

@@ -0,0 +1,96 @@
+package logger
+
+import (
+	"fmt"
+)
+
+// CustomLogger defines what a user can do with a logger
+type CustomLogger interface {
+	// Writeln writes directly to the output with no log level plus line ending
+	Writeln(message string)
+
+	// Write writes directly to the output with no log level
+	Write(message string)
+
+	// Trace level logging. Works like Sprintf.
+	Trace(format string, args ...interface{})
+
+	// Debug level logging. Works like Sprintf.
+	Debug(format string, args ...interface{})
+
+	// Info level logging. Works like Sprintf.
+	Info(format string, args ...interface{})
+
+	// Warning level logging. Works like Sprintf.
+	Warning(format string, args ...interface{})
+
+	// Error level logging. Works like Sprintf.
+	Error(format string, args ...interface{})
+
+	// Fatal level logging. Works like Sprintf.
+	Fatal(format string, args ...interface{})
+}
+
+// customLogger is a utlility to log messages to a number of destinations
+type customLogger struct {
+	logger *Logger
+	name   string
+}
+
+// New creates a new customLogger. You may pass in a number of `io.Writer`s that
+// are the targets for the logs
+func newcustomLogger(logger *Logger, name string) *customLogger {
+	result := &customLogger{
+		name:   name,
+		logger: logger,
+	}
+	return result
+}
+
+// Writeln writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *customLogger) Writeln(message string) {
+	l.logger.Writeln(message)
+}
+
+// Write writes directly to the output with no log level
+func (l *customLogger) Write(message string) {
+	l.logger.Write(message)
+}
+
+// Trace level logging. Works like Sprintf.
+func (l *customLogger) Trace(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Trace(format, args...)
+}
+
+// Debug level logging. Works like Sprintf.
+func (l *customLogger) Debug(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Debug(format, args...)
+}
+
+// Info level logging. Works like Sprintf.
+func (l *customLogger) Info(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Info(format, args...)
+}
+
+// Warning level logging. Works like Sprintf.
+func (l *customLogger) Warning(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Warning(format, args...)
+}
+
+// Error level logging. Works like Sprintf.
+func (l *customLogger) Error(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Error(format, args...)
+
+}
+
+// Fatal level logging. Works like Sprintf.
+func (l *customLogger) Fatal(format string, args ...interface{}) {
+	format = fmt.Sprintf("%s | %s", l.name, format)
+	l.logger.Fatal(format, args...)
+}

v2/internal/logger/default_logger.go

@@ -0,0 +1,105 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/wailsapp/wails/v2/pkg/logger"
+)
+
+// LogLevel is an alias for the public LogLevel
+type LogLevel = logger.LogLevel
+
+// Logger is a utlility to log messages to a number of destinations
+type Logger struct {
+	output         logger.Logger
+	logLevel       LogLevel
+	showLevelInLog bool
+}
+
+// New creates a new Logger. You may pass in a number of `io.Writer`s that
+// are the targets for the logs
+func New(output logger.Logger) *Logger {
+	result := &Logger{
+		logLevel:       logger.INFO,
+		showLevelInLog: true,
+		output:         output,
+	}
+	return result
+}
+
+// CustomLogger creates a new custom logger that prints out a name/id
+// before the messages
+func (l *Logger) CustomLogger(name string) CustomLogger {
+	return newcustomLogger(l, name)
+}
+
+// HideLogLevel removes the loglevel text from the start of each logged line
+func (l *Logger) HideLogLevel() {
+	l.showLevelInLog = true
+}
+
+// SetLogLevel sets the minimum level of logs that will be output
+func (l *Logger) SetLogLevel(level LogLevel) {
+	l.logLevel = level
+}
+
+// Writeln writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *Logger) Writeln(message string) {
+	l.output.Print(message)
+}
+
+// Write writes directly to the output with no log level
+func (l *Logger) Write(message string) {
+	l.output.Print(message)
+}
+
+// Print writes directly to the output with no log level
+// Appends a carriage return to the message
+func (l *Logger) Print(message string) {
+	l.Write(message)
+}
+
+// Trace level logging. Works like Sprintf.
+func (l *Logger) Trace(format string, args ...interface{}) {
+	if l.logLevel <= logger.TRACE {
+		l.output.Trace(fmt.Sprintf(format, args...))
+	}
+}
+
+// Debug level logging. Works like Sprintf.
+func (l *Logger) Debug(format string, args ...interface{}) {
+	if l.logLevel <= logger.DEBUG {
+		l.output.Debug(fmt.Sprintf(format, args...))
+	}
+}
+
+// Info level logging. Works like Sprintf.
+func (l *Logger) Info(format string, args ...interface{}) {
+	if l.logLevel <= logger.INFO {
+		l.output.Info(fmt.Sprintf(format, args...))
+	}
+
+}
+
+// Warning level logging. Works like Sprintf.
+func (l *Logger) Warning(format string, args ...interface{}) {
+	if l.logLevel <= logger.WARNING {
+		l.output.Warning(fmt.Sprintf(format, args...))
+	}
+}
+
+// Error level logging. Works like Sprintf.
+func (l *Logger) Error(format string, args ...interface{}) {
+	if l.logLevel <= logger.ERROR {
+		l.output.Error(fmt.Sprintf(format, args...))
+	}
+
+}
+
+// Fatal level logging. Works like Sprintf.
+func (l *Logger) Fatal(format string, args ...interface{}) {
+	l.output.Fatal(fmt.Sprintf(format, args...))
+	os.Exit(1)
+}

v2/internal/messagedispatcher/dispatchclient.go

@@ -0,0 +1,86 @@
+package messagedispatcher
+
+import (
+	"fmt"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// Client defines what a frontend client can do
+type Client interface {
+	Quit()
+	NotifyEvent(message string)
+	CallResult(message string)
+	OpenDialog(dialogOptions *options.OpenDialog, callbackID string)
+	SaveDialog(dialogOptions *options.SaveDialog, callbackID string)
+	MessageDialog(dialogOptions *options.MessageDialog, callbackID string)
+	WindowSetTitle(title string)
+	WindowShow()
+	WindowHide()
+	WindowCenter()
+	WindowMaximise()
+	WindowUnmaximise()
+	WindowMinimise()
+	WindowUnminimise()
+	WindowPosition(x int, y int)
+	WindowSize(width int, height int)
+	WindowFullscreen()
+	WindowUnFullscreen()
+	WindowSetColour(colour int)
+	DarkModeEnabled(callbackID string)
+	UpdateMenu(menu *menu.Menu)
+	UpdateTray(menu *menu.Menu)
+	UpdateTrayLabel(label string)
+	UpdateTrayIcon(name string)
+	UpdateContextMenus(contextMenus *menu.ContextMenus)
+}
+
+// DispatchClient is what the frontends use to interface with the
+// dispatcher
+type DispatchClient struct {
+	id     string
+	logger logger.CustomLogger
+
+	bus *servicebus.ServiceBus
+
+	// Client
+	frontend Client
+}
+
+func newDispatchClient(id string, frontend Client, logger logger.CustomLogger, bus *servicebus.ServiceBus) *DispatchClient {
+
+	return &DispatchClient{
+		id:       id,
+		frontend: frontend,
+		logger:   logger,
+		bus:      bus,
+	}
+
+}
+
+// DispatchMessage is called by the front ends. It is passed
+// an IPC message, translates it to a more concrete message
+// type then publishes it on the service bus.
+func (d *DispatchClient) DispatchMessage(incomingMessage string) {
+
+	// Parse the message
+	d.logger.Trace(fmt.Sprintf("Received message: %+v", incomingMessage))
+	parsedMessage, err := message.Parse(incomingMessage)
+	if err != nil {
+		d.logger.Error(err.Error())
+		return
+	}
+
+	// Save this client id
+	parsedMessage.ClientID = d.id
+
+	d.logger.Trace("I got a parsedMessage: %+v", parsedMessage)
+
+	// Publish the parsed message
+	d.bus.PublishForTarget(parsedMessage.Topic, parsedMessage.Data, d.id)
+
+}

v2/internal/messagedispatcher/message/call.go

@@ -0,0 +1,38 @@
+package message
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type CallMessage struct {
+	Name       string            `json:"name"`
+	Args       []json.RawMessage `json:"args"`
+	CallbackID string            `json:"callbackID,omitempty"`
+}
+
+// callMessageParser does what it says on the tin!
+func callMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Call messages must be at least 3 bytes `C{}``
+	if len(message) < 3 {
+		return nil, fmt.Errorf("call message was an invalid length")
+	}
+
+	callMessage := new(CallMessage)
+
+	m := message[1:]
+
+	err := json.Unmarshal([]byte(m), callMessage)
+	if err != nil {
+		println(err.Error())
+		return nil, err
+	}
+
+	topic := "call:invoke"
+
+	// Create a new parsed message struct
+	parsedMessage := &parsedMessage{Topic: topic, Data: callMessage}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/message/contextmenus.go

@@ -0,0 +1,43 @@
+package message
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+// ContextMenusOnMessage is used to emit listener registration requests
+// on the service bus
+type ContextMenusOnMessage struct {
+	// MenuID is the id of the menu item we are interested in
+	MenuID string
+	// Callback is called when the menu is clicked
+	Callback func(*menu.MenuItem, string)
+}
+
+// contextMenusMessageParser does what it says on the tin!
+func contextMenusMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Menu messages must be at least 2 bytes
+	if len(message) < 3 {
+		return nil, fmt.Errorf("context menus message was an invalid length")
+	}
+
+	var topic string
+	var data interface{}
+
+	// Switch the message type
+	switch message[1] {
+	case 'C':
+		contextMenuData := message[2:]
+		topic = "contextmenus:clicked"
+		data = contextMenuData
+	default:
+		return nil, fmt.Errorf("invalid menu message: %s", message)
+	}
+
+	// Create a new parsed message struct
+	parsedMessage := &parsedMessage{Topic: topic, Data: data}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/message/dialog.go

@@ -0,0 +1,55 @@
+package message
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// dialogMessageParser does what it says on the tin!
+func dialogMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Dialog messages must be at least 4 bytes
+	if len(message) < 4 {
+		return nil, fmt.Errorf("dialog message was an invalid length")
+	}
+
+	var topic = "bad topic from dialogMessageParser"
+	var responseMessage *parsedMessage
+
+	// Switch the event type (with or without data)
+	switch message[0] {
+	// Format of Dialog response messages: D<dialog type><callbackID>|<[]string as json encoded string>
+	case 'D':
+		dialogType := message[1]
+		message = message[2:]
+		idx := strings.IndexByte(message, '|')
+		if idx < 0 {
+			return nil, fmt.Errorf("Invalid dialog response message format: %+v", message)
+		}
+		callbackID := message[:idx+1]
+		payloadData := message[idx+1:]
+
+		switch dialogType {
+		case 'O':
+			var data []string
+			topic = "dialog:openselected:" + callbackID
+			err := json.Unmarshal([]byte(payloadData), &data)
+			if err != nil {
+				return nil, err
+			}
+			responseMessage = &parsedMessage{Topic: topic, Data: data}
+		case 'S':
+			topic = "dialog:saveselected:" + callbackID
+			responseMessage = &parsedMessage{Topic: topic, Data: payloadData}
+		case 'M':
+			topic = "dialog:messageselected:" + callbackID
+			responseMessage = &parsedMessage{Topic: topic, Data: payloadData}
+		}
+
+	default:
+		return nil, fmt.Errorf("Invalid message to dialogMessageParser()")
+	}
+
+	return responseMessage, nil
+}

v2/internal/messagedispatcher/message/event.go

@@ -0,0 +1,47 @@
+package message
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type EventMessage struct {
+	Name string        `json:"name"`
+	Data []interface{} `json:"data"`
+}
+
+type OnEventMessage struct {
+	Name     string
+	Callback func(optionalData ...interface{})
+	Counter  int
+}
+
+// eventMessageParser does what it says on the tin!
+func eventMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Event messages must be at least 2 bytes
+	if len(message) < 3 {
+		return nil, fmt.Errorf("event message was an invalid length")
+	}
+
+	eventMessage := new(EventMessage)
+	direction := message[1]
+
+	// Switch the event type (with or without data)
+	switch message[0] {
+	case 'E':
+		m := message[2:]
+		err := json.Unmarshal([]byte(m), eventMessage)
+		if err != nil {
+			println(err.Error())
+			return nil, err
+		}
+	}
+
+	topic := "event:emit:from:" + string(direction)
+
+	// Create a new parsed message struct
+	parsedMessage := &parsedMessage{Topic: topic, Data: eventMessage}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/message/log.go

@@ -0,0 +1,36 @@
+package message
+
+import "fmt"
+
+var logMessageMap = map[byte]string{
+	'P': "log:print",
+	'T': "log:trace",
+	'D': "log:debug",
+	'I': "log:info",
+	'W': "log:warning",
+	'E': "log:error",
+	'F': "log:fatal",
+	'S': "log:setlevel",
+}
+
+// logMessageParser does what it says on the tin!
+func logMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Log messages must be at least 2 bytes
+	if len(message) < 2 {
+		return nil, fmt.Errorf("log message was an invalid length")
+	}
+
+	// Switch on the log type
+	messageTopic := logMessageMap[message[1]]
+
+	// If the type is invalid, raise error
+	if messageTopic == "" {
+		return nil, fmt.Errorf("log message type '%c' invalid", message[1])
+	}
+
+	// Create a new parsed message struct
+	parsedMessage := &parsedMessage{Topic: messageTopic, Data: message[2:]}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/message/menu.go

@@ -0,0 +1,43 @@
+package message
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+// MenuOnMessage is used to emit listener registration requests
+// on the service bus
+type MenuOnMessage struct {
+	// MenuID is the id of the menu item we are interested in
+	MenuID string
+	// Callback is called when the menu is clicked
+	Callback func(*menu.MenuItem)
+}
+
+// menuMessageParser does what it says on the tin!
+func menuMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Menu messages must be at least 2 bytes
+	if len(message) < 3 {
+		return nil, fmt.Errorf("event message was an invalid length")
+	}
+
+	var topic string
+	var data interface{}
+
+	// Switch the message type
+	switch message[1] {
+	case 'C':
+		callbackid := message[2:]
+		topic = "menu:clicked"
+		data = callbackid
+	default:
+		return nil, fmt.Errorf("invalid menu message: %s", message)
+	}
+
+	// Create a new parsed message struct
+	parsedMessage := &parsedMessage{Topic: topic, Data: data}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/message/messageparser.go

@@ -0,0 +1,35 @@
+package message
+
+import "fmt"
+
+// Parse
+type parsedMessage struct {
+	Topic    string
+	ClientID string
+	Data     interface{}
+}
+
+// Map of different message parsers based on the header byte of the message
+var messageParsers = map[byte]func(string) (*parsedMessage, error){
+	'L': logMessageParser,
+	'R': runtimeMessageParser,
+	'E': eventMessageParser,
+	'C': callMessageParser,
+	'W': windowMessageParser,
+	'D': dialogMessageParser,
+	'S': systemMessageParser,
+	'M': menuMessageParser,
+	'T': trayMessageParser,
+	'X': contextMenusMessageParser,
+}
+
+// Parse will attempt to parse the given message
+func Parse(message string) (*parsedMessage, error) {
+
+	parseMethod := messageParsers[message[0]]
+	if parseMethod == nil {
+		return nil, fmt.Errorf("message type '%c' invalid", message[0])
+	}
+
+	return parseMethod(message)
+}

v2/internal/messagedispatcher/message/runtime.go

@@ -0,0 +1,37 @@
+package message
+
+import "fmt"
+
+// runtimeMessageParser does what it says on the tin!
+func runtimeMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Log messages must be at least 2 bytes
+	if len(message) < 3 {
+		return nil, fmt.Errorf("runtime message was an invalid length")
+	}
+
+	// Switch on the runtime module type
+	module := message[1]
+	switch module {
+	case 'B':
+		return processBrowserMessage(message)
+	}
+
+	return nil, fmt.Errorf("unknown message: %s", message)
+}
+
+// processBrowserMessage expects messages of the following format:
+// RB<METHOD><DATA>
+// O = Open
+func processBrowserMessage(message string) (*parsedMessage, error) {
+	method := message[2]
+	switch method {
+	case 'O':
+		// Open URL
+		target := message[3:]
+		return &parsedMessage{Topic: "runtime:browser:open", Data: target}, nil
+	}
+
+	return nil, fmt.Errorf("unknown browser message: %s", message)
+
+}

v2/internal/messagedispatcher/message/system.go

@@ -0,0 +1,42 @@
+package message
+
+import (
+	"fmt"
+	"strings"
+)
+
+// systemMessageParser does what it says on the tin!
+func systemMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: system messages must be at least 4 bytes
+	if len(message) < 4 {
+		return nil, fmt.Errorf("system message was an invalid length")
+	}
+
+	var responseMessage *parsedMessage
+
+	// Remove 'S'
+	message = message[1:]
+
+	// Switch the event type (with or without data)
+	switch message[0] {
+	// Format of system response messages: S<command><callbackID>|<payload>
+	// DarkModeEnabled
+	case 'D':
+		message = message[1:]
+		idx := strings.IndexByte(message, '|')
+		if idx < 0 {
+			return nil, fmt.Errorf("Invalid system response message format")
+		}
+		callbackID := message[:idx]
+		payloadData := message[idx+1:]
+
+		topic := "systemresponse:" + callbackID
+		responseMessage = &parsedMessage{Topic: topic, Data: payloadData == "T"}
+
+	default:
+		return nil, fmt.Errorf("Invalid message to systemMessageParser()")
+	}
+
+	return responseMessage, nil
+}

v2/internal/messagedispatcher/message/tray.go

@@ -0,0 +1,46 @@
+package message
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+// TrayOnMessage is used to emit listener registration requests
+// on the service bus
+type TrayOnMessage struct {
+	// MenuID is the id of the menu item we are interested in
+	MenuID string
+	// Callback is called when the menu is clicked
+	Callback func(*menu.MenuItem)
+}
+
+// trayMessageParser does what it says on the tin!
+func trayMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Menu messages must be at least 2 bytes
+	if len(message) < 3 {
+		return nil, fmt.Errorf("tray message was an invalid length")
+	}
+
+	var topic string
+	var data interface{}
+
+	// Switch the message type
+	switch message[1] {
+	case 'C':
+		callbackid := message[2:]
+		topic = "tray:clicked"
+		data = callbackid
+	case 'I':
+		topic = "trayfrontend:seticon"
+		data = message[2:]
+	default:
+		return nil, fmt.Errorf("invalid tray message: %s", message)
+	}
+
+	// Create a new parsed message struct
+	parsedMessage := &parsedMessage{Topic: topic, Data: data}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/message/window.go

@@ -0,0 +1,91 @@
+package message
+
+import "fmt"
+
+// windowMessageParser does what it says on the tin!
+func windowMessageParser(message string) (*parsedMessage, error) {
+
+	// Sanity check: Window messages must be at least 2 bytes
+	if len(message) < 2 {
+		return nil, fmt.Errorf("window message was an invalid length")
+	}
+
+	// Extract event type
+	windowEvent := message[1]
+	parsedMessage := &parsedMessage{}
+
+	// Switch the windowEvent type
+	switch windowEvent {
+
+	// Closed window
+	case 'C':
+		parsedMessage.Topic = "quit"
+		parsedMessage.Data = "Window Closed"
+
+	// Center window
+	case 'c':
+		parsedMessage.Topic = "window:center"
+		parsedMessage.Data = ""
+
+	// Hide window
+	case 'H':
+		parsedMessage.Topic = "window:hide"
+		parsedMessage.Data = ""
+
+	// Show window
+	case 'S':
+		parsedMessage.Topic = "window:show"
+		parsedMessage.Data = ""
+
+	// Position window
+	case 'p':
+		parsedMessage.Topic = "window:position:" + message[3:]
+		parsedMessage.Data = ""
+
+	// Set window size
+	case 's':
+		parsedMessage.Topic = "window:size:" + message[3:]
+		parsedMessage.Data = ""
+
+	// Maximise window
+	case 'M':
+		parsedMessage.Topic = "window:maximise"
+		parsedMessage.Data = ""
+
+	// Unmaximise window
+	case 'U':
+		parsedMessage.Topic = "window:unmaximise"
+		parsedMessage.Data = ""
+
+	// Minimise window
+	case 'm':
+		parsedMessage.Topic = "window:minimise"
+		parsedMessage.Data = ""
+
+	// Unminimise window
+	case 'u':
+		parsedMessage.Topic = "window:unminimise"
+		parsedMessage.Data = ""
+
+	// Fullscreen window
+	case 'F':
+		parsedMessage.Topic = "window:fullscreen"
+		parsedMessage.Data = ""
+
+		// UnFullscreen window
+	case 'f':
+		parsedMessage.Topic = "window:unfullscreen"
+		parsedMessage.Data = ""
+
+		// Set Title
+	case 'T':
+		parsedMessage.Topic = "window:settitle"
+		parsedMessage.Data = message[2:]
+
+	// Unknown event type
+	default:
+		return nil, fmt.Errorf("unknown message: %s", message)
+	}
+
+	return parsedMessage, nil
+}

v2/internal/messagedispatcher/messagedispatcher.go

@@ -0,0 +1,557 @@
+package messagedispatcher
+
+import (
+	"encoding/json"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/wailsapp/wails/v2/internal/crypto"
+	"github.com/wailsapp/wails/v2/internal/logger"
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// Dispatcher translates messages received from the frontend
+// and publishes them onto the service bus
+type Dispatcher struct {
+	quitChannel        <-chan *servicebus.Message
+	resultChannel      <-chan *servicebus.Message
+	eventChannel       <-chan *servicebus.Message
+	windowChannel      <-chan *servicebus.Message
+	dialogChannel      <-chan *servicebus.Message
+	systemChannel      <-chan *servicebus.Message
+	menuChannel        <-chan *servicebus.Message
+	contextMenuChannel <-chan *servicebus.Message
+	trayChannel        <-chan *servicebus.Message
+	running            bool
+
+	servicebus *servicebus.ServiceBus
+	logger     logger.CustomLogger
+
+	// Clients
+	clients map[string]*DispatchClient
+	lock    sync.RWMutex
+}
+
+// New dispatcher. Needs a service bus to send to.
+func New(servicebus *servicebus.ServiceBus, logger *logger.Logger) (*Dispatcher, error) {
+	// Subscribe to call result messages
+	resultChannel, err := servicebus.Subscribe("call:result")
+	if err != nil {
+		return nil, err
+	}
+
+	// Subscribe to event messages
+	eventChannel, err := servicebus.Subscribe("event:emit")
+	if err != nil {
+		return nil, err
+	}
+
+	// Subscribe to quit messages
+	quitChannel, err := servicebus.Subscribe("quit")
+	if err != nil {
+		return nil, err
+	}
+
+	// Subscribe to window messages
+	windowChannel, err := servicebus.Subscribe("window")
+	if err != nil {
+		return nil, err
+	}
+
+	// Subscribe to dialog events
+	dialogChannel, err := servicebus.Subscribe("dialog:select")
+	if err != nil {
+		return nil, err
+	}
+
+	systemChannel, err := servicebus.Subscribe("system:")
+	if err != nil {
+		return nil, err
+	}
+
+	menuChannel, err := servicebus.Subscribe("menufrontend:")
+	if err != nil {
+		return nil, err
+	}
+
+	contextMenuChannel, err := servicebus.Subscribe("contextmenufrontend:")
+	if err != nil {
+		return nil, err
+	}
+
+	trayChannel, err := servicebus.Subscribe("trayfrontend:")
+	if err != nil {
+		return nil, err
+	}
+
+	result := &Dispatcher{
+		servicebus:         servicebus,
+		eventChannel:       eventChannel,
+		logger:             logger.CustomLogger("Message Dispatcher"),
+		clients:            make(map[string]*DispatchClient),
+		resultChannel:      resultChannel,
+		quitChannel:        quitChannel,
+		windowChannel:      windowChannel,
+		dialogChannel:      dialogChannel,
+		systemChannel:      systemChannel,
+		menuChannel:        menuChannel,
+		trayChannel:        trayChannel,
+		contextMenuChannel: contextMenuChannel,
+	}
+
+	return result, nil
+}
+
+// Start the subsystem
+func (d *Dispatcher) Start() error {
+
+	d.logger.Trace("Starting")
+
+	d.running = true
+
+	// Spin off a go routine
+	go func() {
+		for d.running {
+			select {
+			case <-d.quitChannel:
+				d.processQuit()
+				d.running = false
+			case resultMessage := <-d.resultChannel:
+				d.processCallResult(resultMessage)
+			case eventMessage := <-d.eventChannel:
+				d.processEvent(eventMessage)
+			case windowMessage := <-d.windowChannel:
+				d.processWindowMessage(windowMessage)
+			case dialogMessage := <-d.dialogChannel:
+				d.processDialogMessage(dialogMessage)
+			case systemMessage := <-d.systemChannel:
+				d.processSystemMessage(systemMessage)
+			case menuMessage := <-d.menuChannel:
+				d.processMenuMessage(menuMessage)
+			case contextMenuMessage := <-d.contextMenuChannel:
+				d.processContextMenuMessage(contextMenuMessage)
+			case trayMessage := <-d.trayChannel:
+				d.processTrayMessage(trayMessage)
+			}
+		}
+
+		// Call shutdown
+		d.shutdown()
+	}()
+
+	return nil
+}
+
+func (d *Dispatcher) processQuit() {
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+	for _, client := range d.clients {
+		client.frontend.Quit()
+	}
+}
+
+func (d *Dispatcher) shutdown() {
+	d.logger.Trace("Shutdown")
+}
+
+// RegisterClient will register the given callback with the dispatcher
+// and return a DispatchClient that the caller can use to send messages
+func (d *Dispatcher) RegisterClient(client Client) *DispatchClient {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	// Create ID
+	id := d.getUniqueID()
+	d.clients[id] = newDispatchClient(id, client, d.logger, d.servicebus)
+
+	return d.clients[id]
+}
+
+// RemoveClient will remove the registered client
+func (d *Dispatcher) RemoveClient(dc *DispatchClient) {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	delete(d.clients, dc.id)
+}
+
+func (d *Dispatcher) getUniqueID() string {
+	var uid string
+	for {
+		uid = crypto.RandomID()
+
+		if d.clients[uid] == nil {
+			break
+		}
+	}
+
+	return uid
+}
+
+func (d *Dispatcher) processCallResult(result *servicebus.Message) {
+	target := result.Target()
+
+	if target == "" {
+		// This is an error. Calls are 1:1!
+		d.logger.Fatal("No target for call result: %+v", result)
+	}
+
+	d.lock.RLock()
+	client := d.clients[target]
+	d.lock.RUnlock()
+	if client == nil {
+		// This is fatal - unknown target!
+		d.logger.Fatal("Unknown target for call result: %+v", result)
+		return
+	}
+
+	d.logger.Trace("Sending message to client %s: R%s", target, result.Data().(string))
+	client.frontend.CallResult(result.Data().(string))
+}
+
+// processSystem
+func (d *Dispatcher) processSystemMessage(result *servicebus.Message) {
+
+	d.logger.Trace("Got system in message dispatcher: %+v", result)
+
+	splitTopic := strings.Split(result.Topic(), ":")
+	command := splitTopic[1]
+	callbackID := splitTopic[2]
+	switch command {
+	case "isdarkmode":
+		d.lock.RLock()
+		for _, client := range d.clients {
+			client.frontend.DarkModeEnabled(callbackID)
+			break
+		}
+		d.lock.RUnlock()
+
+	default:
+		d.logger.Error("Unknown system command: %s", command)
+	}
+}
+
+// processEvent will
+func (d *Dispatcher) processEvent(result *servicebus.Message) {
+
+	d.logger.Trace("Got event in message dispatcher: %+v", result)
+
+	splitTopic := strings.Split(result.Topic(), ":")
+	eventType := splitTopic[1]
+	switch eventType {
+	case "emit":
+		eventFrom := splitTopic[3]
+		if eventFrom == "g" {
+			// This was sent from Go - notify frontend
+			eventData := result.Data().(*message.EventMessage)
+			// Unpack event
+			payload, err := json.Marshal(eventData)
+			if err != nil {
+				d.logger.Error("Unable to marshal eventData: %s", err.Error())
+				return
+			}
+			d.lock.RLock()
+			for _, client := range d.clients {
+				client.frontend.NotifyEvent(string(payload))
+			}
+			d.lock.RUnlock()
+		}
+	default:
+		d.logger.Error("Unknown event type: %s", eventType)
+	}
+}
+
+// processWindowMessage processes messages intended for the window
+func (d *Dispatcher) processWindowMessage(result *servicebus.Message) {
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+	splitTopic := strings.Split(result.Topic(), ":")
+	command := splitTopic[1]
+	switch command {
+	case "settitle":
+		title, ok := result.Data().(string)
+		if !ok {
+			d.logger.Error("Invalid title for 'window:settitle' : %#v", result.Data())
+			return
+		}
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowSetTitle(title)
+		}
+	case "fullscreen":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowFullscreen()
+		}
+	case "unfullscreen":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowUnFullscreen()
+		}
+	case "setcolour":
+		colour, ok := result.Data().(int)
+		if !ok {
+			d.logger.Error("Invalid colour for 'window:setcolour' : %#v", result.Data())
+			return
+		}
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowSetColour(colour)
+		}
+	case "show":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowShow()
+		}
+	case "hide":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowHide()
+		}
+	case "center":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowCenter()
+		}
+	case "maximise":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowMaximise()
+		}
+	case "unmaximise":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowUnmaximise()
+		}
+	case "minimise":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowMinimise()
+		}
+	case "unminimise":
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowUnminimise()
+		}
+	case "position":
+		// We need 2 arguments
+		if len(splitTopic) != 4 {
+			d.logger.Error("Invalid number of parameters for 'window:position' : %#v", result.Data())
+			return
+		}
+		x, err1 := strconv.Atoi(splitTopic[2])
+		y, err2 := strconv.Atoi(splitTopic[3])
+		if err1 != nil || err2 != nil {
+			d.logger.Error("Invalid integer parameters for 'window:position' : %#v", result.Data())
+			return
+		}
+		// Notify clients
+		for _, client := range d.clients {
+			client.frontend.WindowPosition(x, y)
+		}
+	case "size":
+		// We need 2 arguments
+		if len(splitTopic) != 4 {
+			d.logger.Error("Invalid number of parameters for 'window:size' : %#v", result.Data())
+			return
+		}
+		w, err1 := strconv.Atoi(splitTopic[2])
+		h, err2 := strconv.Atoi(splitTopic[3])
+		if err1 != nil || err2 != nil {
+			d.logger.Error("Invalid integer parameters for 'window:size' : %#v", result.Data())
+			return
+		}
+		// Notifh clients
+		for _, client := range d.clients {
+			client.frontend.WindowSize(w, h)
+		}
+	default:
+		d.logger.Error("Unknown window command: %s", command)
+	}
+	d.logger.Trace("Got window in message dispatcher: %+v", result)
+
+}
+
+// processDialogMessage processes dialog messages
+func (d *Dispatcher) processDialogMessage(result *servicebus.Message) {
+	splitTopic := strings.Split(result.Topic(), ":")
+	if len(splitTopic) < 4 {
+		d.logger.Error("Invalid dialog message : %#v", result.Data())
+		return
+	}
+
+	command := splitTopic[1]
+	switch command {
+	case "select":
+		dialogType := splitTopic[2]
+		switch dialogType {
+		case "open":
+			dialogOptions, ok := result.Data().(*options.OpenDialog)
+			if !ok {
+				d.logger.Error("Invalid data for 'dialog:select:open' : %#v", result.Data())
+				return
+			}
+			// This is hardcoded in the sender too
+			callbackID := splitTopic[3]
+
+			// TODO: Work out what we mean in a multi window environment...
+			// For now we will just pick the first one
+			for _, client := range d.clients {
+				client.frontend.OpenDialog(dialogOptions, callbackID)
+			}
+		case "save":
+			dialogOptions, ok := result.Data().(*options.SaveDialog)
+			if !ok {
+				d.logger.Error("Invalid data for 'dialog:select:save' : %#v", result.Data())
+				return
+			}
+			// This is hardcoded in the sender too
+			callbackID := splitTopic[3]
+
+			// TODO: Work out what we mean in a multi window environment...
+			// For now we will just pick the first one
+			for _, client := range d.clients {
+				client.frontend.SaveDialog(dialogOptions, callbackID)
+			}
+		case "message":
+			dialogOptions, ok := result.Data().(*options.MessageDialog)
+			if !ok {
+				d.logger.Error("Invalid data for 'dialog:select:message' : %#v", result.Data())
+				return
+			}
+			// This is hardcoded in the sender too
+			callbackID := splitTopic[3]
+
+			// TODO: Work out what we mean in a multi window environment...
+			// For now we will just pick the first one
+			for _, client := range d.clients {
+				client.frontend.MessageDialog(dialogOptions, callbackID)
+			}
+		default:
+			d.logger.Error("Unknown dialog type: %s", dialogType)
+		}
+
+	default:
+		d.logger.Error("Unknown dialog command: %s", command)
+	}
+
+}
+
+func (d *Dispatcher) processMenuMessage(result *servicebus.Message) {
+	splitTopic := strings.Split(result.Topic(), ":")
+	if len(splitTopic) < 2 {
+		d.logger.Error("Invalid menu message : %#v", result.Data())
+		return
+	}
+
+	command := splitTopic[1]
+	switch command {
+	case "update":
+
+		updatedMenu, ok := result.Data().(*menu.Menu)
+		if !ok {
+			d.logger.Error("Invalid data for 'menufrontend:update' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateMenu(updatedMenu)
+		}
+
+	default:
+		d.logger.Error("Unknown menufrontend command: %s", command)
+	}
+}
+func (d *Dispatcher) processContextMenuMessage(result *servicebus.Message) {
+	splitTopic := strings.Split(result.Topic(), ":")
+	if len(splitTopic) < 2 {
+		d.logger.Error("Invalid contextmenu message : %#v", result.Data())
+		return
+	}
+
+	command := splitTopic[1]
+	switch command {
+	case "update":
+
+		updatedContextMenus, ok := result.Data().(*menu.ContextMenus)
+		if !ok {
+			d.logger.Error("Invalid data for 'contextmenufrontend:update' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateContextMenus(updatedContextMenus)
+		}
+
+	default:
+		d.logger.Error("Unknown contextmenufrontend command: %s", command)
+	}
+}
+
+func (d *Dispatcher) processTrayMessage(result *servicebus.Message) {
+	splitTopic := strings.Split(result.Topic(), ":")
+	if len(splitTopic) < 2 {
+		d.logger.Error("Invalid tray message : %#v", result.Data())
+		return
+	}
+
+	command := splitTopic[1]
+	switch command {
+	case "update":
+
+		updatedMenu, ok := result.Data().(*menu.Menu)
+		if !ok {
+			d.logger.Error("Invalid data for 'trayfrontend:update' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateTray(updatedMenu)
+		}
+
+	case "setlabel":
+
+		updatedLabel, ok := result.Data().(string)
+		if !ok {
+			d.logger.Error("Invalid data for 'trayfrontend:setlabel' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateTrayLabel(updatedLabel)
+		}
+
+	case "seticon":
+
+		iconname, ok := result.Data().(string)
+		if !ok {
+			d.logger.Error("Invalid data for 'trayfrontend:seticon' : %#v",
+				result.Data())
+			return
+		}
+
+		// TODO: Work out what we mean in a multi window environment...
+		// For now we will just pick the first one
+		for _, client := range d.clients {
+			client.frontend.UpdateTrayIcon(iconname)
+		}
+
+	default:
+		d.logger.Error("Unknown menufrontend command: %s", command)
+	}
+}

v2/internal/parse/README.md

@@ -0,0 +1,10 @@
+# Parse
+
+Parse will attempt to parse your Wails project to perform a number of tasks:
+  * Verify that you have bound struct pointers
+  * Generate JS helper files/docs
+
+It currently checks bindings correctly if your code binds using one of the following methods:
+  * Literal Binding: `app.Bind(&MyStruct{})`
+  * Variable Binding: `app.Bind(m)` - m can be `m := &MyStruct{}` or `m := newMyStruct()`
+  * Function Binding: `app.Bind(newMyStruct())`

v2/internal/parse/parse.go

@@ -0,0 +1,440 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"os"
+	"strings"
+
+	"github.com/leaanthony/slicer"
+	"golang.org/x/tools/go/packages"
+)
+
+var internalMethods = slicer.String([]string{"WailsInit", "Wails Shutdown"})
+
+var structCache = make(map[string]*ParsedStruct)
+var boundStructs = make(map[string]*ParsedStruct)
+var boundMethods = []string{}
+var boundStructPointerLiterals = []string{}
+var boundStructLiterals = slicer.StringSlicer{}
+var boundVariables = slicer.StringSlicer{}
+var app = ""
+var structPointerFunctionDecls = make(map[string]string)
+var structFunctionDecls = make(map[string]string)
+var variableStructDecls = make(map[string]string)
+var variableFunctionDecls = make(map[string]string)
+
+type Parameter struct {
+	Name string
+	Type string
+}
+
+type ParsedMethod struct {
+	Struct   string
+	Name     string
+	Comments []string
+	Inputs   []*Parameter
+	Returns  []*Parameter
+}
+
+type ParsedStruct struct {
+	Name    string
+	Methods []*ParsedMethod
+}
+
+type BoundStructs []*ParsedStruct
+
+func ParseProject(projectPath string) (BoundStructs, error) {
+
+	cfg := &packages.Config{Mode: packages.NeedFiles | packages.NeedSyntax | packages.NeedTypesInfo}
+	pkgs, err := packages.Load(cfg, projectPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "load: %v\n", err)
+		os.Exit(1)
+	}
+	if packages.PrintErrors(pkgs) > 0 {
+		os.Exit(1)
+	}
+
+	// Iterate the packages
+	for _, pkg := range pkgs {
+
+		// Iterate the files
+		for _, file := range pkg.Syntax {
+
+			var wailsPkgVar = ""
+
+			ast.Inspect(file, func(n ast.Node) bool {
+				switch x := n.(type) {
+				// Parse import declarations
+				case *ast.ImportSpec:
+					// Determine what wails has been imported as
+					if x.Path.Value == `"github.com/wailsapp/wails/v2"` {
+						wailsPkgVar = x.Name.Name
+					}
+				// Parse calls. We are looking for app.Bind() calls
+				case *ast.CallExpr:
+					f, ok := x.Fun.(*ast.SelectorExpr)
+					if ok {
+						n, ok := f.X.(*ast.Ident)
+						if ok {
+							//Check this is the Bind() call associated with the app variable
+							if n.Name == app && f.Sel.Name == "Bind" {
+								if len(x.Args) == 1 {
+									ce, ok := x.Args[0].(*ast.CallExpr)
+									if ok {
+										n, ok := ce.Fun.(*ast.Ident)
+										if ok {
+											// We found a bind method using a function call
+											// EG: app.Bind( newMyStruct() )
+											boundMethods = append(boundMethods, n.Name)
+										}
+									} else {
+										// We also want to check for Bind( &MyStruct{} )
+										ue, ok := x.Args[0].(*ast.UnaryExpr)
+										if ok {
+											if ue.Op.String() == "&" {
+												cl, ok := ue.X.(*ast.CompositeLit)
+												if ok {
+													t, ok := cl.Type.(*ast.Ident)
+													if ok {
+														// We have found Bind( &MyStruct{} )
+														boundStructPointerLiterals = append(boundStructPointerLiterals, t.Name)
+													}
+												}
+											}
+										} else {
+											// Let's check when the user binds a struct,
+											// rather than a struct pointer: Bind( MyStruct{} )
+											// We do this to provide better hints to the user
+											cl, ok := x.Args[0].(*ast.CompositeLit)
+											if ok {
+												t, ok := cl.Type.(*ast.Ident)
+												if ok {
+													boundStructLiterals.Add(t.Name)
+												}
+											} else {
+												// Also check for when we bind a variable
+												// myVariable := &MyStruct{}
+												// app.Bind( myVariable )
+												i, ok := x.Args[0].(*ast.Ident)
+												if ok {
+													boundVariables.Add(i.Name)
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+
+				// We scan assignments for a number of reasons:
+				//   * Determine the variable containing the main application
+				//   * Determine the type of variables that get used in Bind()
+				//   * Determine the type of variables that get created with var := &MyStruct{}
+				case *ast.AssignStmt:
+					for _, rhs := range x.Rhs {
+						ce, ok := rhs.(*ast.CallExpr)
+						if ok {
+							se, ok := ce.Fun.(*ast.SelectorExpr)
+							if ok {
+								i, ok := se.X.(*ast.Ident)
+								if ok {
+									// Have we found the wails package name?
+									if i.Name == wailsPkgVar {
+										// Check we are calling a function to create the app
+										if se.Sel.Name == "CreateApp" || se.Sel.Name == "CreateAppWithOptions" {
+											if len(x.Lhs) == 1 {
+												i, ok := x.Lhs[0].(*ast.Ident)
+												if ok {
+													// Found the app variable name
+													app = i.Name
+												}
+											}
+										}
+									}
+								}
+							} else {
+								// Check for function assignment
+								// a := newMyStruct()
+								fe, ok := ce.Fun.(*ast.Ident)
+								if ok {
+									if len(x.Lhs) == 1 {
+										i, ok := x.Lhs[0].(*ast.Ident)
+										if ok {
+											// Store the variable -> Function mapping
+											// so we can later resolve the type
+											variableFunctionDecls[i.Name] = fe.Name
+										}
+									}
+								}
+							}
+						} else {
+							// Check for literal assignment of struct
+							// EG: myvar := MyStruct{}
+							ue, ok := rhs.(*ast.UnaryExpr)
+							if ok {
+								cl, ok := ue.X.(*ast.CompositeLit)
+								if ok {
+									t, ok := cl.Type.(*ast.Ident)
+									if ok {
+										if len(x.Lhs) == 1 {
+											i, ok := x.Lhs[0].(*ast.Ident)
+											if ok {
+												variableStructDecls[i.Name] = t.Name
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				// We scan for functions to build up a list of function names
+				// for a number of reasons:
+				//   * Determine which functions are struct methods that are bound
+				//   * Determine
+				case *ast.FuncDecl:
+					if x.Recv != nil {
+						// This is a struct method
+						for _, field := range x.Recv.List {
+							se, ok := field.Type.(*ast.StarExpr)
+							if ok {
+								// This is a struct pointer method
+								i, ok := se.X.(*ast.Ident)
+								if ok {
+									// We want to ignore Internal functions
+									if internalMethods.Contains(x.Name.Name) {
+										continue
+									}
+									// If we haven't already found this struct,
+									// Create a placeholder in the cache
+									parsedStruct := structCache[i.Name]
+									if parsedStruct == nil {
+										structCache[i.Name] = &ParsedStruct{
+											Name: i.Name,
+										}
+										parsedStruct = structCache[i.Name]
+									}
+
+									// If this method is Public
+									if string(x.Name.Name[0]) == strings.ToUpper((string(x.Name.Name[0]))) {
+										structMethod := &ParsedMethod{
+											Struct: i.Name,
+											Name:   x.Name.Name,
+										}
+										// Check if the method has comments.
+										// If so, save it with the parsed method
+										if x.Doc != nil {
+											for _, comment := range x.Doc.List {
+												stringComment := comment.Text
+												if strings.HasPrefix(stringComment, "//") {
+													stringComment = stringComment[2:]
+												}
+												structMethod.Comments = append(structMethod.Comments, strings.TrimSpace(stringComment))
+											}
+										}
+
+										// Save the input parameters
+										for _, inputField := range x.Type.Params.List {
+											t, ok := inputField.Type.(*ast.Ident)
+											if !ok {
+												continue
+											}
+											for _, name := range inputField.Names {
+												structMethod.Inputs = append(structMethod.Inputs, &Parameter{Name: name.Name, Type: t.Name})
+											}
+										}
+
+										// Save the output parameters
+										for _, outputField := range x.Type.Results.List {
+											t, ok := outputField.Type.(*ast.Ident)
+											if !ok {
+												continue
+											}
+											if len(outputField.Names) == 0 {
+												structMethod.Returns = append(structMethod.Returns, &Parameter{Type: t.Name})
+											} else {
+												for _, name := range outputField.Names {
+													structMethod.Returns = append(structMethod.Returns, &Parameter{Name: name.Name, Type: t.Name})
+												}
+											}
+										}
+
+										// Append this method to the parsed struct
+										parsedStruct.Methods = append(parsedStruct.Methods, structMethod)
+
+									}
+								}
+							}
+						}
+					} else {
+						// This is a function declaration
+						// We care about its name and return type
+						// This will allow us to resolve types later
+						functionName := x.Name.Name
+
+						// Look for one that returns a single value
+						if x.Type != nil && x.Type.Results != nil && x.Type.Results.List != nil {
+							if len(x.Type.Results.List) == 1 {
+								// Check for *struct
+								t, ok := x.Type.Results.List[0].Type.(*ast.StarExpr)
+								if ok {
+									s, ok := t.X.(*ast.Ident)
+									if ok {
+										// println("*** Function", functionName, "found which returns: *"+s.Name)
+										structPointerFunctionDecls[functionName] = s.Name
+									}
+								} else {
+									// Check for functions that return a struct
+									// This is to help us provide hints if the user binds a struct
+									t, ok := x.Type.Results.List[0].Type.(*ast.Ident)
+									if ok {
+										// println("*** Function", functionName, "found which returns: "+t.Name)
+										structFunctionDecls[functionName] = t.Name
+									}
+								}
+							}
+						}
+					}
+				}
+				return true
+			})
+			// spew.Dump(file)
+		}
+	}
+
+	/***** Update bound structs ******/
+
+	// Resolve bound Methods
+	for _, method := range boundMethods {
+		s, ok := structPointerFunctionDecls[method]
+		if !ok {
+			s, ok = structFunctionDecls[method]
+			if !ok {
+				println("Fatal: Bind statement using", method, "but cannot find", method, "declaration")
+			} else {
+				println("Fatal: Cannot bind struct using method `" + method + "` because it returns a struct (" + s + "). Return a pointer to " + s + " instead.")
+			}
+			os.Exit(1)
+		}
+		structDefinition := structCache[s]
+		if structDefinition == nil {
+			println("Fatal: Bind statement using `"+method+"` but cannot find struct", s, "definition")
+			os.Exit(1)
+		}
+		boundStructs[s] = structDefinition
+	}
+
+	// Resolve bound vars
+	for _, structLiteral := range boundStructPointerLiterals {
+		s, ok := structCache[structLiteral]
+		if !ok {
+			println("Fatal: Bind statement using", structLiteral, "but cannot find", structLiteral, "declaration")
+			os.Exit(1)
+		}
+		boundStructs[structLiteral] = s
+	}
+
+	// Resolve bound variables
+	boundVariables.Each(func(variable string) {
+		v, ok := variableStructDecls[variable]
+		if !ok {
+			method, ok := variableFunctionDecls[variable]
+			if !ok {
+				println("Fatal: Bind statement using variable `" + variable + "` which does not resolve to a struct pointer")
+				os.Exit(1)
+			}
+
+			// Resolve function name
+			v, ok = structPointerFunctionDecls[method]
+			if !ok {
+				v, ok = structFunctionDecls[method]
+				if !ok {
+					println("Fatal: Bind statement using", method, "but cannot find", method, "declaration")
+				} else {
+					println("Fatal: Cannot bind variable `" + variable + "` because it resolves to a struct (" + v + "). Return a pointer to " + v + " instead.")
+				}
+				os.Exit(1)
+			}
+
+		}
+
+		s, ok := structCache[v]
+		if !ok {
+			println("Fatal: Bind statement using variable `" + variable + "` which resolves to a `" + v + "` but cannot find its declaration")
+			os.Exit(1)
+		}
+		boundStructs[v] = s
+
+	})
+
+	// Check for struct literals
+	boundStructLiterals.Each(func(structName string) {
+		println("Fatal: Cannot bind struct using struct literal `" + structName + "{}`. Create a pointer to " + structName + " instead.")
+		os.Exit(1)
+	})
+
+	// Check for bound variables
+	// boundVariables.Each(func(varName string) {
+	// 	println("Fatal: Cannot bind struct using struct literal `" + structName + "{}`. Create a pointer to " + structName + " instead.")
+	// })
+
+	// spew.Dump(boundStructs)
+	// os.Exit(0)
+
+	// }
+	// Inspect the AST and print all identifiers and literals.
+
+	println("export {")
+
+	noOfStructs := len(boundStructs)
+	structCount := 0
+	for _, s := range boundStructs {
+		structCount++
+		println()
+		println("  " + s.Name + ": {")
+		println()
+		noOfMethods := len(s.Methods)
+		for methodCount, m := range s.Methods {
+			println("   /****************")
+			for _, comment := range m.Comments {
+				println("    *", comment)
+			}
+			if len(m.Comments) > 0 {
+				println("    *")
+			}
+			inputNames := ""
+			for _, input := range m.Inputs {
+				println("    * @param {"+input.Type+"}", input.Name)
+				inputNames += input.Name + ", "
+			}
+			print("    * @return Promise<")
+			for _, output := range m.Returns {
+				print(output.Type + "|")
+			}
+			println("Error>")
+			println("    *")
+			println("    ***/")
+			if len(inputNames) > 2 {
+				inputNames = inputNames[:len(inputNames)-2]
+			}
+			println("   ", m.Name+": function("+inputNames+") {")
+			println("     return window.backend." + s.Name + "." + m.Name + "(" + inputNames + ");")
+			print("    }")
+			if methodCount < noOfMethods-1 {
+				print(",")
+			}
+			println()
+			println()
+		}
+		print("  }")
+		if structCount < noOfStructs-1 {
+			print(",")
+		}
+		println()
+	}
+	println()
+	println("}")
+	println()
+}

v2/internal/process/process.go

@@ -0,0 +1,63 @@
+package process
+
+import (
+	"os/exec"
+
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+)
+
+// Process defines a process that can be executed
+type Process struct {
+	logger      *clilogger.CLILogger
+	cmd         *exec.Cmd
+	exitChannel chan bool
+	Running     bool
+}
+
+// NewProcess creates a new process struct
+func NewProcess(logger *clilogger.CLILogger, cmd string, args ...string) *Process {
+	return &Process{
+		logger:      logger,
+		cmd:         exec.Command(cmd, args...),
+		exitChannel: make(chan bool, 1),
+	}
+}
+
+// Start the process
+func (p *Process) Start() error {
+
+	err := p.cmd.Start()
+	if err != nil {
+		return err
+	}
+
+	p.Running = true
+
+	go func(cmd *exec.Cmd, running *bool, logger *clilogger.CLILogger, exitChannel chan bool) {
+		logger.Println("Starting process (PID: %d)", cmd.Process.Pid)
+		cmd.Wait()
+		logger.Println("Exiting process (PID: %d)", cmd.Process.Pid)
+		*running = false
+		exitChannel <- true
+	}(p.cmd, &p.Running, p.logger, p.exitChannel)
+
+	return nil
+}
+
+// Kill the process
+func (p *Process) Kill() error {
+	if !p.Running {
+		return nil
+	}
+	err := p.cmd.Process.Kill()
+
+	// Wait for command to exit properly
+	<-p.exitChannel
+
+	return err
+}
+
+// PID returns the process PID
+func (p *Process) PID() int {
+	return p.cmd.Process.Pid
+}

v2/internal/project/project.go

@@ -0,0 +1,97 @@
+package project
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+// Project holds the data related to a Wails project
+type Project struct {
+
+	/*** Application Data ***/
+	Name string `json:"name"`
+
+	// Application HTML, JS and CSS filenames
+	HTML           string `json:"html"`
+	JS             string `json:"js"`
+	CSS            string `json:"css"`
+	BuildCommand   string `json:"frontend:build"`
+	InstallCommand string `json:"frontend:install"`
+	/*** Internal Data ***/
+
+	// The path to the project directory
+	Path string
+
+	// Assets directory
+	AssetsDir string `json:"assetsdir"`
+
+	// The output filename
+	OutputFilename string `json:"outputfilename"`
+
+	// The type of application. EG: Desktop, Server, etc
+	OutputType string
+
+	// The platform to target
+	Platform string
+
+	// The application author
+	Author Author
+}
+
+// Author stores details about the application author
+type Author struct {
+	Name  string `json:"name"`
+	Email string `json:"email"`
+}
+
+// Load the project from the current working directory
+func Load(projectPath string) (*Project, error) {
+
+	// Attempt to load project.json
+	projectFile := filepath.Join(projectPath, "wails.json")
+	rawBytes, err := ioutil.ReadFile(projectFile)
+	if err != nil {
+		return nil, err
+	}
+
+	// Unmarshal JSON
+	var result Project
+	err = json.Unmarshal(rawBytes, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	// Fix up our project paths
+	result.Path = filepath.ToSlash(projectPath) + "/"
+	result.HTML = filepath.Join(projectPath, result.HTML)
+	result.JS = filepath.Join(projectPath, result.JS)
+	result.CSS = filepath.Join(projectPath, result.CSS)
+
+	// Create default name if not given
+	if result.Name == "" {
+		result.Name = "wailsapp"
+	}
+
+	// Set default assets directory if none given
+	if result.AssetsDir == "" {
+		result.AssetsDir = filepath.Join(result.Path, "assets")
+	}
+
+	// Fix up OutputFilename
+	switch runtime.GOOS {
+	case "windows":
+		if !strings.HasSuffix(result.OutputFilename, ".exe") {
+			result.OutputFilename += ".exe"
+		}
+	case "darwin", "linux":
+		if strings.HasSuffix(result.OutputFilename, ".exe") {
+			result.OutputFilename = strings.TrimSuffix(result.OutputFilename, ".exe")
+		}
+	}
+
+	// Return our project data
+	return &result, nil
+}

v2/internal/runtime/browser.go

@@ -0,0 +1,36 @@
+package runtime
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+)
+
+// Browser defines all browser related operations
+type Browser interface {
+	Open(target string) error
+}
+
+type browser struct{}
+
+// Open a url / file using the system default application
+// Credit: https://gist.github.com/hyg/9c4afcd91fe24316cbf0
+func (b *browser) Open(target string) error {
+	var err error
+
+	switch runtime.GOOS {
+	case "linux":
+		err = exec.Command("xdg-open", target).Start()
+	case "windows":
+		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", target).Start()
+	case "darwin":
+		err = exec.Command("open", target).Start()
+	default:
+		err = fmt.Errorf("unsupported platform")
+	}
+	return err
+}
+
+func newBrowser() *browser {
+	return &browser{}
+}

v2/internal/runtime/contextmenus.go

@@ -0,0 +1,48 @@
+package runtime
+
+import (
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+)
+
+// ContextMenus defines all ContextMenu related operations
+type ContextMenus interface {
+	On(menuID string, callback func(*menu.MenuItem, string))
+	Update()
+	GetByID(menuID string) *menu.MenuItem
+	RemoveByID(id string) bool
+}
+
+type contextMenus struct {
+	bus          *servicebus.ServiceBus
+	contextmenus *menu.ContextMenus
+}
+
+// newContextMenus creates a new ContextMenu struct
+func newContextMenus(bus *servicebus.ServiceBus, contextmenus *menu.ContextMenus) ContextMenus {
+	return &contextMenus{
+		bus:          bus,
+		contextmenus: contextmenus,
+	}
+}
+
+// On registers a listener for a particular event
+func (t *contextMenus) On(menuID string, callback func(*menu.MenuItem, string)) {
+	t.bus.Publish("contextmenus:on", &message.ContextMenusOnMessage{
+		MenuID:   menuID,
+		Callback: callback,
+	})
+}
+
+func (t *contextMenus) Update() {
+	t.bus.Publish("contextmenus:update", t.contextmenus)
+}
+
+func (t *contextMenus) GetByID(menuItemID string) *menu.MenuItem {
+	return t.contextmenus.GetByID(menuItemID)
+}
+
+func (t *contextMenus) RemoveByID(menuItemID string) bool {
+	return t.contextmenus.RemoveByID(menuItemID)
+}

v2/internal/runtime/dialog.go

@@ -0,0 +1,120 @@
+package runtime
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/v2/internal/crypto"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+	"github.com/wailsapp/wails/v2/pkg/options"
+)
+
+// Dialog defines all Dialog related operations
+type Dialog interface {
+	Open(dialogOptions *options.OpenDialog) []string
+	Save(dialogOptions *options.SaveDialog) string
+	Message(dialogOptions *options.MessageDialog) string
+}
+
+// dialog exposes the Dialog interface
+type dialog struct {
+	bus *servicebus.ServiceBus
+}
+
+// newDialogs creates a new Dialogs struct
+func newDialog(bus *servicebus.ServiceBus) Dialog {
+	return &dialog{
+		bus: bus,
+	}
+}
+
+// processTitleAndFilter return the title and filter from the given params.
+// title is the first string, filter is the second
+func (r *dialog) processTitleAndFilter(params ...string) (string, string) {
+
+	var title, filter string
+
+	if len(params) > 0 {
+		title = params[0]
+	}
+
+	if len(params) > 1 {
+		filter = params[1]
+	}
+
+	return title, filter
+}
+
+// Open prompts the user to select a file
+func (r *dialog) Open(dialogOptions *options.OpenDialog) []string {
+
+	// Create unique dialog callback
+	uniqueCallback := crypto.RandomID()
+
+	// Subscribe to the respose channel
+	responseTopic := "dialog:openselected:" + uniqueCallback
+	dialogResponseChannel, err := r.bus.Subscribe(responseTopic)
+	if err != nil {
+		fmt.Printf("ERROR: Cannot subscribe to bus topic: %+v\n", err.Error())
+	}
+
+	message := "dialog:select:open:" + uniqueCallback
+	r.bus.Publish(message, dialogOptions)
+
+	// Wait for result
+	var result *servicebus.Message = <-dialogResponseChannel
+
+	// Delete subscription to response topic
+	r.bus.UnSubscribe(responseTopic)
+
+	return result.Data().([]string)
+}
+
+// Save prompts the user to select a file
+func (r *dialog) Save(dialogOptions *options.SaveDialog) string {
+
+	// Create unique dialog callback
+	uniqueCallback := crypto.RandomID()
+
+	// Subscribe to the respose channel
+	responseTopic := "dialog:saveselected:" + uniqueCallback
+	dialogResponseChannel, err := r.bus.Subscribe(responseTopic)
+	if err != nil {
+		fmt.Printf("ERROR: Cannot subscribe to bus topic: %+v\n", err.Error())
+	}
+
+	message := "dialog:select:save:" + uniqueCallback
+	r.bus.Publish(message, dialogOptions)
+
+	// Wait for result
+	var result *servicebus.Message = <-dialogResponseChannel
+
+	// Delete subscription to response topic
+	r.bus.UnSubscribe(responseTopic)
+
+	return result.Data().(string)
+}
+
+// Message show a message to the user
+func (r *dialog) Message(dialogOptions *options.MessageDialog) string {
+
+	// Create unique dialog callback
+	uniqueCallback := crypto.RandomID()
+
+	// Subscribe to the respose channel
+	responseTopic := "dialog:messageselected:" + uniqueCallback
+	dialogResponseChannel, err := r.bus.Subscribe(responseTopic)
+	if err != nil {
+		fmt.Printf("ERROR: Cannot subscribe to bus topic: %+v\n", err.Error())
+	}
+
+	message := "dialog:select:message:" + uniqueCallback
+	r.bus.Publish(message, dialogOptions)
+
+	// Wait for result
+	var result *servicebus.Message = <-dialogResponseChannel
+
+	// Delete subscription to response topic
+	r.bus.UnSubscribe(responseTopic)
+
+	return result.Data().(string)
+}

v2/internal/runtime/events.go

@@ -0,0 +1,86 @@
+package runtime
+
+import (
+	"github.com/wailsapp/wails/v2/internal/messagedispatcher/message"
+	"github.com/wailsapp/wails/v2/internal/servicebus"
+)
+
+// Events defines all events related operations
+type Events interface {
+	On(eventName string, callback func(optionalData ...interface{}))
+	Once(eventName string, callback func(optionalData ...interface{}))
+	OnMultiple(eventName string, callback func(optionalData ...interface{}), maxCallbacks int)
+	Emit(eventName string, optionalData ...interface{})
+	OnThemeChange(callback func(darkMode bool))
+}
+
+// event exposes the events interface
+type event struct {
+	bus *servicebus.ServiceBus
+}
+
+// newEvents creates a new Events struct
+func newEvents(bus *servicebus.ServiceBus) Events {
+	return &event{
+		bus: bus,
+	}
+}
+
+// On registers a listener for a particular event
+func (r *event) On(eventName string, callback func(optionalData ...interface{})) {
+	eventMessage := &message.OnEventMessage{
+		Name:     eventName,
+		Callback: callback,
+		Counter:  -1,
+	}
+	r.bus.Publish("event:on", eventMessage)
+}
+
+// Once registers a listener for a particular event. After the first callback, the
+// listener is deleted.
+func (r *event) Once(eventName string, callback func(optionalData ...interface{})) {
+	eventMessage := &message.OnEventMessage{
+		Name:     eventName,
+		Callback: callback,
+		Counter:  1,
+	}
+	r.bus.Publish("event:on", eventMessage)
+}
+
+// OnMultiple registers a listener for a particular event, for a given maximum amount of callbacks.
+// Once the callback has been run `maxCallbacks` times, the listener is deleted.
+func (r *event) OnMultiple(eventName string, callback func(optionalData ...interface{}), maxCallbacks int) {
+	eventMessage := &message.OnEventMessage{
+		Name:     eventName,
+		Callback: callback,
+		Counter:  maxCallbacks,
+	}
+	r.bus.Publish("event:on", eventMessage)
+}
+
+// Emit pass through
+func (r *event) Emit(eventName string, optionalData ...interface{}) {
+	eventMessage := &message.EventMessage{
+		Name: eventName,
+		Data: optionalData,
+	}
+
+	r.bus.Publish("event:emit:from:g", eventMessage)
+}
+
+// OnThemeChange allows you to register callbacks when the system theme changes
+// from light or dark.
+func (r *event) OnThemeChange(callback func(darkMode bool)) {
+	r.On("wails:system:themechange", func(data ...interface{}) {
+		if len(data) != 1 {
+			// TODO: Log error
+			return
+		}
+		darkMode, ok := data[0].(bool)
+		if !ok {
+			// TODO: Log error
+			return
+		}
+		callback(darkMode)
+	})
+}

v2/internal/runtime/js/.eslintrc

@@ -0,0 +1,24 @@
+{
+    "env": {
+        "browser": true,
+        "es6": true,
+        "amd": true,
+        "node": true,
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaVersion": 2016,
+        "sourceType": "module",
+    },
+    "rules": {
+        "linebreak-style": 0,
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+}

v2/internal/runtime/js/babel.config.js

@@ -0,0 +1,22 @@
+/* eslint-disable */
+
+module.exports = function (api) {
+  api.cache(true);
+
+  const presets = [
+    [
+      "@babel/preset-env",
+      {
+        "useBuiltIns": "entry",
+        "corejs": {
+          "version": 3,
+          "proposals": true
+        }
+      }
+    ]
+  ];
+
+  return {
+    presets,
+  };
+}

v2/internal/runtime/js/core/bindings.js

@@ -0,0 +1,107 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Call } from './calls';
+
+window.backend = {};
+
+/**
+ 
+Map of this format:
+
+{ 
+	packageName: { 
+		structName: { 
+			methodName: { 
+				name: "", 
+				inputs: [
+					{
+						type: <type>
+					}
+				],
+				outputs: [
+					{
+						type: <type>
+					}
+				] 
+			} 
+		} 
+	} 
+}
+ */
+
+export function SetBindings(bindingsMap) {
+	try {
+		bindingsMap = JSON.parse(bindingsMap);
+	} catch (e) {
+		console.error(e);
+	}
+
+	// Initialise the backend map
+	window.backend = window.backend || {};
+
+	// Iterate package names
+	Object.keys(bindingsMap).forEach((packageName) => {
+
+		// Create inner map if it doesn't exist
+		window.backend[packageName] = window.backend[packageName] || {};
+
+		// Iterate struct names
+		Object.keys(bindingsMap[packageName]).forEach((structName) => {
+
+			// Create inner map if it doesn't exist
+			window.backend[packageName][structName] = window.backend[packageName][structName] || {};
+
+			Object.keys(bindingsMap[packageName][structName]).forEach((methodName) => {
+
+				window.backend[packageName][structName][methodName] = function () {
+
+					// No timeout by default
+					var timeout = 0;
+
+					// Actual function
+					function dynamic() {
+						var args = [].slice.call(arguments);
+						return Call([packageName, structName, methodName].join('.'), args, timeout);
+					}
+
+					// Allow setting timeout to function
+					dynamic.setTimeout = function (newTimeout) {
+						timeout = newTimeout;
+					};
+
+					// Allow getting timeout to function
+					dynamic.getTimeout = function () {
+						return timeout;
+					};
+
+					return dynamic;
+				}();
+			});
+		});
+	});
+}
+// /**
+//  * Determines if the given identifier is valid Javascript
+//  *
+//  * @param {boolean} name
+//  * @returns
+//  */
+// function isValidIdentifier(name) {
+// 	// Don't xss yourself :-)
+// 	try {
+// 		new Function('var ' + name);
+// 		return true;
+// 	} catch (e) {
+// 		return false;
+// 	}
+// }
+

v2/internal/runtime/js/core/browser.js

@@ -0,0 +1,24 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { SendMessage } from 'ipc';
+
+/**
+ * Opens the given URL / filename in the system browser
+ *
+ * @export
+ * @param {string} target
+ * @returns
+ */
+export function Open(target) {
+	return SendMessage('RBO' + target);
+}
+

v2/internal/runtime/js/core/calls.js

@@ -0,0 +1,157 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Debug } from './log';
+import { SendMessage } from 'ipc';
+
+var callbacks = {};
+
+/**
+ * Returns a number from the native browser random function
+ *
+ * @returns number
+ */
+function cryptoRandom() {
+	var array = new Uint32Array(1);
+	return window.crypto.getRandomValues(array)[0];
+}
+
+/**
+ * Returns a number using da old-skool Math.Random
+ * I likes to call it LOLRandom
+ *
+ * @returns number
+ */
+function basicRandom() {
+	return Math.random() * 9007199254740991;
+}
+
+// Pick a random number function based on browser capability
+var randomFunc;
+if (window.crypto) {
+	randomFunc = cryptoRandom;
+} else {
+	randomFunc = basicRandom;
+}
+
+
+/**
+ * Call sends a message to the backend to call the binding with the
+ * given data. A promise is returned and will be completed when the
+ * backend responds. This will be resolved when the call was successful
+ * or rejected if an error is passed back.
+ * There is a timeout mechanism. If the call doesn't respond in the given
+ * time (in milliseconds) then the promise is rejected.
+ *
+ * @export
+ * @param {string} name
+ * @param {string} args
+ * @param {number=} timeout
+ * @returns
+ */
+export function Call(name, args, timeout) {
+
+	// Timeout infinite by default
+	if (timeout == null || timeout == undefined) {
+		timeout = 0;
+	}
+
+	// Create a promise
+	return new Promise(function (resolve, reject) {
+
+		// Create a unique callbackID
+		var callbackID;
+		do {
+			callbackID = name + '-' + randomFunc();
+		} while (callbacks[callbackID]);
+
+		// Set timeout
+		if (timeout > 0) {
+			var timeoutHandle = setTimeout(function () {
+				reject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));
+			}, timeout);
+		}
+
+		// Store callback
+		callbacks[callbackID] = {
+			timeoutHandle: timeoutHandle,
+			reject: reject,
+			resolve: resolve
+		};
+
+		try {
+			const payload = {
+				name,
+				args,
+				callbackID,
+			};
+
+			// Make the call
+			SendMessage('C' + JSON.stringify(payload));
+		} catch (e) {
+			// eslint-disable-next-line
+			console.error(e);
+		}
+	});
+}
+
+
+
+/**
+ * Called by the backend to return data to a previously called
+ * binding invocation
+ *
+ * @export
+ * @param {string} incomingMessage
+ */
+export function Callback(incomingMessage) {
+	// Decode the message - Credit: https://stackoverflow.com/a/13865680
+	//incomingMessage = decodeURIComponent(incomingMessage.replace(/\s+/g, '').replace(/[0-9a-f]{2}/g, '%$&'));
+
+	// Parse the message
+	var message;
+	try {
+		message = JSON.parse(incomingMessage);
+	} catch (e) {
+		const error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;
+		Debug(error);
+		throw new Error(error);
+	}
+	var callbackID = message.callbackid;
+	var callbackData = callbacks[callbackID];
+	if (!callbackData) {
+		const error = `Callback '${callbackID}' not registered!!!`;
+		console.error(error); // eslint-disable-line
+		throw new Error(error);
+	}
+	clearTimeout(callbackData.timeoutHandle);
+
+	delete callbacks[callbackID];
+
+	if (message.error) {
+		callbackData.reject(message.error);
+	} else {
+		callbackData.resolve(message.result);
+	}
+}
+
+/**
+ * SystemCall is used to call wails methods from the frontend
+ *
+ * @export
+ * @param {string} method
+ * @param {any[]=} data
+ * @returns
+ */
+export function SystemCall(method) {
+	var data = [].slice.apply(arguments).slice(1);
+	return Call('.wails.' + method, data);
+}

v2/internal/runtime/js/core/desktop.js

@@ -0,0 +1,37 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+import { SetBindings } from './bindings';
+import { Init } from './main';
+
+// Setup global error handler
+window.onerror = function (msg, url, lineNo, columnNo, error) {
+	const errorMessage = {
+		message: msg,
+		url: url,
+		line: lineNo,
+		column: columnNo,
+		error: JSON.stringify(error),
+		stack: function() { return JSON.stringify(new Error().stack); }(),
+	};
+	window.wails.Log.Error(JSON.stringify(errorMessage));
+};
+
+// Initialise the Runtime
+Init();
+
+// Load Bindings if they exist
+if (window.wailsbindings) {
+	SetBindings(window.wailsbindings);
+}
+
+// Emit loaded event. Leaving this for now. It will show any errors if runtime fails to load.
+window.wails.Events.Emit('wails:loaded');
+

v2/internal/runtime/js/core/dialog.js

@@ -0,0 +1,92 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 6 */
+
+import { SystemCall } from './calls';
+
+/**
+ * @type {Object} OpenDialogOptions
+ * @param {string} [DefaultDirectory=""]           
+ * @param {string} [DefaultFilename=""]            
+ * @param {string} [Title=""]                      
+ * @param {string} [Filters=""]                    
+ * @param {boolean} [AllowFiles=false]
+ * @param {boolean} [AllowDirectories=false]
+ * @param {boolean} [AllowMultiple=false]
+ * @param {boolean} [ShowHiddenFiles=false]
+ * @param {boolean} [CanCreateDirectories=false]
+ * @param {boolean} [ResolvesAliases=false] - Mac Only: Resolves aliases (symlinks)
+ * @param {boolean} [TreatPackagesAsDirectories=false] - Mac Only: Show packages (EG Applications) as folders
+ */
+
+
+
+/**
+ * Opens a dialog using the given parameters, prompting the user to
+ * select files/folders.
+ *
+ * @export
+ * @param {OpenDialogOptions} options
+ * @returns {Promise<Array<string>>} - List of files/folders selected
+ */
+export function Open(options) {
+	return SystemCall('Dialog.Open', options);
+}
+
+/**
+ *
+ * @type {Object} SaveDialogOptions
+ * @param {string} [DefaultDirectory=""]
+ * @param {string} [DefaultFilename=""]
+ * @param {string} [Title=""]
+ * @param {string} [Filters=""]
+ * @param {boolean} [ShowHiddenFiles=false]
+ * @param {boolean} [CanCreateDirectories=false]
+ * @param {boolean} [TreatPackagesAsDirectories=false]
+ */
+
+/**
+ * Opens a dialog using the given parameters, prompting the user to
+ * select a single file/folder.
+ *
+ * @export
+ * @param {SaveDialogOptions} options
+ * @returns {Promise<string>}
+ */
+export function Save(options) {
+	return SystemCall('Dialog.Save', options);
+}
+
+
+/**
+ *
+ * @type {Object} MessageDialogOptions
+ * @param {DialogType} [Type=InfoDialog] - The type of the dialog
+ * @param {string} [Title=""] - The dialog title
+ * @param {string} [Message=""] - The dialog message
+ * @param {string[]} [Buttons=[]] - The button titles
+ * @param {string} [DefaultButton=""] - The button that should be used as the default button
+ * @param {string} [CancelButton=""] - The button that should be used as the cancel button
+ * @param {string} [Icon=""] - The name of the icon to use in the dialog
+ */
+
+/**
+ * Opens a dialog using the given parameters, to display a message
+ * or prompt the user to select an option
+ *
+ * @export
+ * @name Message
+ * @param {MessageDialogOptions} options
+ * @returns {Promise<string>} - The button text that was selected
+ */
+export function Message(options) {
+	return SystemCall('Dialog.Message', options);
+}

v2/internal/runtime/js/core/events.js

@@ -0,0 +1,168 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Error } from './log';
+import { SendMessage } from 'ipc';
+
+// Defines a single listener with a maximum number of times to callback
+/**
+ * The Listener class defines a listener! :-)
+ *
+ * @class Listener
+ */
+class Listener {
+	/**
+	 * Creates an instance of Listener.
+	 * @param {function} callback
+	 * @param {number} maxCallbacks
+	 * @memberof Listener
+	 */
+	constructor(callback, maxCallbacks) {
+		// Default of -1 means infinite
+		maxCallbacks = maxCallbacks || -1;
+		// Callback invokes the callback with the given data
+		// Returns true if this listener should be destroyed
+		this.Callback = (data) => {
+			callback.apply(null, data);
+			// If maxCallbacks is infinite, return false (do not destroy)
+			if (maxCallbacks === -1) {
+				return false;
+			}
+			// Decrement maxCallbacks. Return true if now 0, otherwise false
+			maxCallbacks -= 1;
+			return maxCallbacks === 0;
+		};
+	}
+}
+
+var eventListeners = {};
+
+/**
+ * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ * @param {number} maxCallbacks
+ */
+export function OnMultiple(eventName, callback, maxCallbacks) {
+	eventListeners[eventName] = eventListeners[eventName] || [];
+	const thisListener = new Listener(callback, maxCallbacks);
+	console.log('Pushing event listener: ' + eventName);
+	eventListeners[eventName].push(thisListener);
+}
+
+/**
+ * Registers an event listener that will be invoked every time the event is emitted
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ */
+export function On(eventName, callback) {
+	OnMultiple(eventName, callback);
+}
+
+/**
+ * Registers listeners for when the system theme changes from light/dark. A bool is
+ * sent to the listener, true if it is dark mode.
+ *
+ * @export
+ * @param {function} callback
+ */
+export function OnThemeChange(callback) {
+	On('wails:system:themechange', callback);
+}
+
+/**
+ * Registers an event listener that will be invoked once then destroyed
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ */
+export function Once(eventName, callback) {
+	OnMultiple(eventName, callback, 1);
+}
+
+function notifyListeners(eventData) {
+
+	// Get the event name
+	var eventName = eventData.name;
+
+	// Check if we have any listeners for this event
+	if (eventListeners[eventName]) {
+
+		// Keep a list of listener indexes to destroy
+		const newEventListenerList = eventListeners[eventName].slice();
+
+		// Iterate listeners
+		for (let count = 0; count < eventListeners[eventName].length; count += 1) {
+
+			// Get next listener
+			const listener = eventListeners[eventName][count];
+
+			var data = eventData.data;
+
+			// Do the callback
+			const destroy = listener.Callback(data);
+			if (destroy) {
+				// if the listener indicated to destroy itself, add it to the destroy list
+				newEventListenerList.splice(count, 1);
+			}
+		}
+
+		// Update callbacks with new list of listners
+		eventListeners[eventName] = newEventListenerList;
+	}
+}
+
+/**
+ * Notify informs frontend listeners that an event was emitted with the given data
+ *
+ * @export
+ * @param {string} notifyMessage - encoded notification message
+
+ */
+export function Notify(notifyMessage) {
+
+	// Parse the message
+	var message;
+	try {
+		message = JSON.parse(notifyMessage);
+	} catch (e) {
+		const error = 'Invalid JSON passed to Notify: ' + notifyMessage;
+		throw new Error(error);
+	}
+
+	notifyListeners(message);
+}
+
+/**
+ * Emit an event with the given name and data
+ *
+ * @export
+ * @param {string} eventName
+ */
+export function Emit(eventName) {
+
+	const payload = {
+		name: eventName,
+		data: [].slice.apply(arguments).slice(1),
+	};
+
+	// Notify JS listeners
+	notifyListeners(payload);
+
+	// Notify Go listeners
+	SendMessage('Ej' + JSON.stringify(payload));
+
+}

v2/internal/runtime/js/core/log.js

@@ -0,0 +1,115 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 6 */
+
+import { SendMessage } from 'ipc';
+
+/**
+ * Sends a log message to the backend with the given level + message
+ *
+ * @param {string} level
+ * @param {string} message
+ */
+function sendLogMessage(level, message) {
+
+	// Log Message format:
+	// l[type][message]
+	SendMessage('L' + level + message);
+}
+
+/**
+ * Log the given trace message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Trace(message) {
+	sendLogMessage('T', message);
+}
+
+/**
+ * Log the given message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Print(message) {
+	sendLogMessage('P', message);
+}
+
+/**
+ * Log the given debug message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Debug(message) {
+	sendLogMessage('D', message);
+}
+
+/**
+ * Log the given info message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Info(message) {
+	sendLogMessage('I', message);
+}
+
+/**
+ * Log the given warning message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Warning(message) {
+	sendLogMessage('W', message);
+}
+
+/**
+ * Log the given error message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Error(message) {
+	sendLogMessage('E', message);
+}
+
+/**
+ * Log the given fatal message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Fatal(message) {
+	sendLogMessage('F', message);
+}
+
+/**
+ * Sets the Log level to the given log level
+ *
+ * @export
+ * @param {number} loglevel
+ */
+export function SetLogLevel(loglevel) {
+	sendLogMessage('S', loglevel);
+}
+
+// Log levels
+export const Level = {
+	TRACE: 1,
+	DEBUG: 2,
+	INFO: 3,
+	WARNING: 4,
+	ERROR: 5,
+};

v2/internal/runtime/js/core/main.js

@@ -0,0 +1,67 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+import * as Log from './log';
+import * as Browser from './browser';
+import * as Window from './window';
+import * as Dialog from './dialog';
+import { On, Once, OnMultiple, Emit, Notify } from './events';
+import { Callback, SystemCall } from './calls';
+import { AddScript, InjectCSS, DisableDefaultContextMenu } from './utils';
+import { AddIPCListener } from 'ipc';
+import * as Platform from 'platform';
+import * as Store from './store';
+import * as Tray from './tray';
+
+export function Init() {
+	// Backend is where the Go struct wrappers get bound to
+	window.backend = {};
+
+	// Initialise global if not already
+	window.wails = {
+		System: Platform.System,
+		Log,
+		Browser,
+		Window,
+		Tray,
+		Dialog,
+		Events: {
+			On,
+			Once,
+			OnMultiple,
+			Emit,
+		},
+		_: {
+			Callback,
+			Notify,
+			AddScript,
+			InjectCSS,
+			DisableDefaultContextMenu,
+			// Init,
+			AddIPCListener,
+			SystemCall,
+		},
+		Store,
+	};
+
+	// Setup system. Store uses window.wails so needs to be setup after that
+	window.wails.System = {
+		IsDarkMode: Store.New('wails:isdarkmode'),
+		LogLevel: Store.New('wails:loglevel'),
+		AppConfig: Store.New('wails:appconfig'),
+	};
+	// Copy platform specific information into it
+	Object.assign(window.wails.System, Platform.System);
+
+	// Do platform specific Init
+	Platform.Init();
+
+	window.wailsloader.runtime = true;
+}

v2/internal/runtime/js/core/server.js

@@ -0,0 +1,182 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Init } from './main';
+import { SetBindings } from './bindings';
+
+function init() {
+	// Bridge object
+	window.wailsbridge = {
+		reconnectOverlay: null,
+		reconnectTimer: 300,
+		wsURL: 'ws://' + window.location.hostname + ':8080/ws',
+		connectionState: null,
+		config: {},
+		websocket: null,
+		callback: null,
+		overlayHTML:
+			'<div class="wails-reconnect-overlay"><div class="wails-reconnect-overlay-content"><div class="wails-reconnect-overlay-title">Wails Bridge</div><br><div class="wails-reconnect-overlay-loadingspinner"></div><br><div id="wails-reconnect-overlay-message">Waiting for backend</div></div></div>',
+		overlayCSS:
+			'.wails-reconnect-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,.6);font-family:sans-serif;display:none;z-index:999999}.wails-reconnect-overlay-content{padding:20px 30px;text-align:center;width:20em;position:relative;height:14em;border-radius:1em;margin:5% auto 0;background-color:#fff;box-shadow:1px 1px 20px 3px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAC8AAAAuCAMAAACPpbA7AAAAqFBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAEBAQAAAAAAAAAAAAEBAQEBAQDAwMBAQEAAAABAQEAAAAAAAAAAAABAQEAAAAAAAACAgICAgIBAQEAAAAAAAAAAAAAAAAAAAAAAAABAQEAAAACAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBQWKCj6oAAAAN3RSTlMALiIqDhkGBAswJjP0GxP6NR4W9/ztjRDMhWU50G9g5eHXvbZ9XEI9xZTcqZl2aldKo55QwoCvZUgzhAAAAs9JREFUSMeNleeWqjAUhU0BCaH3Itiw9zKT93+zG02QK1hm/5HF+jzZJ6fQe6cyXE+jg9X7o9wxuylIIf4Tv2V3+bOrEXnf8dwQ/KQIGDN2/S+4OmVCVXL/ScBnfibxURqIByP/hONE8r8T+bDMlQ98KSl7Y8hzjpS8v1qtDh8u5f8KQpGpfnPPhqG8JeogN37Hq9eaN2xRhIwAaGnvws8F1ShxqK5ob2twYi1FAMD4rXsYtnC/JEiRbl4cUrCWhnMCLRFemXezXbb59QK4WASOsm6n2W1+4CBT2JmtzQ6fsrbGubR/NFbd2g5Y179+5w/GEHaKsHjYCet7CgrXU3txarNC7YxOVJtIj4/ERzMdZfzc31hp+8cD6eGILgarZY9uZ12hAs03vfBD9C171gS5Omz7OcvxALQIn4u8RRBBBcsi9WW2woO9ipLgfzpYlggg3ZRdROUC8KT7QLqq3W9KB5BbdFVg4929kdwp6+qaZnMCCNBdj+NyN1W885Ry/AL3D4AQbsVV4noCiM/C83kyYq80XlDAYQtralOiDzoRAHlotWl8q2tjvYlOgcg1A8jEApZa+C06TBdAz2Qv0wu11I/zZOyJQ6EwGez2P2b8PIQr1hwwnAZsAxwA4UAYOyXUxM/xp6tHAn4GUmPGM9R28oVxgC0e/zQJJI6DyhyZ1r7uzRQhpcW7x7vTaWSzKSG6aep77kroTEl3U81uSVaUTtgEINfC8epx+Q4F9SpplHG84Ek6m4RAq9/TLkOBrxyeuddZhHvGIp1XXfFy3Z3vtwNblKGiDn+J+92vwwABHghj7HnzlS1H5kB49AZvdGCFgiBPq69qfXPr3y++yilF0ON4R8eR7spAsLpZ95NqAW5tab1c4vkZm6aleajchMwYTdILQQTwE2OV411ZM9WztDjPql12caBi6gDpUKmDd4U1XNdQxZ4LIXQ5/Tr4P7I9tYcFrDK3AAAAAElFTkSuQmCC);background-repeat:no-repeat;background-position:center}.wails-reconnect-overlay-title{font-size:2em}.wails-reconnect-overlay-message{font-size:1.3em}.wails-reconnect-overlay-loadingspinner{pointer-events:none;width:2.5em;height:2.5em;border:.4em solid transparent;border-color:#3E67EC #eee #eee;border-radius:50%;animation:loadingspin 1s linear infinite;margin:auto;padding:2.5em}@keyframes loadingspin{100%{transform:rotate(360deg)}}',
+		log: function (message) {
+			// eslint-disable-next-line
+			console.log(
+				'%c wails bridge %c ' + message + ' ',
+				'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',
+				'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'
+			);
+		}
+	};
+}
+
+// Adapted from webview - thanks zserge!
+function injectCSS(css) {
+	var elem = document.createElement('style');
+	elem.setAttribute('type', 'text/css');
+	if (elem.styleSheet) {
+		elem.styleSheet.cssText = css;
+	} else {
+		elem.appendChild(document.createTextNode(css));
+	}
+	var head = document.head || document.getElementsByTagName('head')[0];
+	head.appendChild(elem);
+}
+
+// Creates a node in the Dom
+function createNode(parent, elementType, id, className, content) {
+	var d = document.createElement(elementType);
+	if (id) {
+		d.id = id;
+	}
+	if (className) {
+		d.className = className;
+	}
+	if (content) {
+		d.innerHTML = content;
+	}
+	parent.appendChild(d);
+	return d;
+}
+
+// Sets up the overlay
+function setupOverlay() {
+	var body = document.body;
+
+	var wailsBridgeNode = createNode(body, 'div', 'wails-bridge');
+	wailsBridgeNode.innerHTML = window.wailsbridge.overlayHTML;
+
+	// Inject the overlay CSS
+	injectCSS(window.wailsbridge.overlayCSS);
+}
+
+// Start the Wails Bridge
+function startBridge() {
+	// Setup the overlay
+	setupOverlay();
+
+	window.wailsbridge.websocket = null;
+	window.wailsbridge.connectTimer = null;
+	window.wailsbridge.reconnectOverlay = document.querySelector(
+		'.wails-reconnect-overlay'
+	);
+	window.wailsbridge.connectionState = 'disconnected';
+
+	// Shows the overlay
+	function showReconnectOverlay() {
+		window.wailsbridge.reconnectOverlay.style.display = 'block';
+	}
+
+	// Hides the overlay
+	function hideReconnectOverlay() {
+		window.wailsbridge.reconnectOverlay.style.display = 'none';
+	}
+
+	// Handles incoming websocket connections
+	function handleConnect() {
+		window.wailsbridge.log('Connected to backend');
+		hideReconnectOverlay();
+		clearInterval(window.wailsbridge.connectTimer);
+		window.wailsbridge.websocket.onclose = handleDisconnect;
+		window.wailsbridge.websocket.onmessage = handleMessage;
+		window.wailsbridge.connectionState = 'connected';
+	}
+
+	// Handles websocket disconnects
+	function handleDisconnect() {
+		window.wailsbridge.log('Disconnected from backend');
+		window.wailsbridge.websocket = null;
+		window.wailsbridge.connectionState = 'disconnected';
+		showReconnectOverlay();
+		connect();
+	}
+
+	// Try to connect to the backend every 300ms (default value).
+	// Change this value in the main wailsbridge object.
+	function connect() {
+		window.wailsbridge.connectTimer = setInterval(function () {
+			if (window.wailsbridge.websocket == null) {
+				window.wailsbridge.websocket = new WebSocket(window.wailsbridge.wsURL);
+				window.wailsbridge.websocket.onopen = handleConnect;
+				window.wailsbridge.websocket.onerror = function (e) {
+					e.stopImmediatePropagation();
+					e.stopPropagation();
+					e.preventDefault();
+					window.wailsbridge.websocket = null;
+					return false;
+				};
+			}
+		}, window.wailsbridge.reconnectTimer);
+	}
+
+	function handleMessage(message) {
+		switch (message.data[0]) {
+		case 'e':
+		case 'E':
+			window.wails._.Notify(message.data.slice(1));
+			break;
+		case 'R':
+			window.wails._.Callback(message.data.slice(1));
+			break;
+		default:
+			window.wails.Log.Error('Unknown message type received: ' + message.data[0]);
+		}
+	}
+
+	// Start by showing the overlay...
+	showReconnectOverlay();
+
+	// ...and attempt to connect
+	connect();
+}
+
+function start() {
+
+	// Set up the bridge
+	init();
+
+	// Start Bridge
+	startBridge();
+
+	// Load bindings
+	window.wailspreinit = function () {
+		if (window.wailsbindings) {
+			SetBindings(window.wailsbindings);
+		}
+	};
+
+	Init();
+
+	// Save the binding script
+	window.SetBindings = SetBindings;
+}
+
+// Start your engines!
+start();

v2/internal/runtime/js/core/store.js

@@ -0,0 +1,96 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Creates a new sync store with the given name and optional default value
+ *
+ * @export
+ * @param {string} name
+ * @param {*} optionalDefault
+ */
+export function New(name, optionalDefault) {
+
+	// This is the store state
+	var state;
+
+	// Check we are initialised
+	if( !window.wails) {
+		throw Error('Wails is not initialised');
+	}
+
+	// Store for the callbacks
+	let callbacks = [];
+	
+	// Subscribe to updates by providing a callback
+	let subscribe = function(callback) {
+		callbacks.push(callback);
+	};
+
+	// sets the store state to the provided `newstate` value
+	let set = function(newstate) {
+		
+		state = newstate;
+
+		// Emit a notification to back end
+		window.wails.Events.Emit('wails:sync:store:updatedbyfrontend:'+name, JSON.stringify(state));
+
+		// Notify callbacks
+		callbacks.forEach( function(callback) {
+			callback(state);
+		});
+	};
+
+	// update mutates the value in the store by calling the
+	// provided method with the current value. The value returned 
+	// by the updater function will be set as the new store value
+	let update = function(updater) {
+		var newValue = updater(state);
+		this.set(newValue);
+	};
+
+	// get returns the current value of the store
+	let get = function() {
+		return state;
+	};
+
+	// Setup event callback
+	window.wails.Events.On('wails:sync:store:updatedbybackend:'+name, function(jsonEncodedState) {
+
+		// Parse state
+		let newState = JSON.parse(jsonEncodedState);
+
+		// Todo: Potential preprocessing?
+
+		// Save state
+		state = newState;
+
+		// Notify callbacks
+		callbacks.forEach( function(callback) {
+			callback(state);
+		});
+
+	});
+
+	// Set to the optional default if set
+	if( optionalDefault ) {
+		this.set(optionalDefault);
+	}
+
+	// Trigger an update to the store
+	window.wails.Events.Emit('wails:sync:store:resync:'+name);
+
+	return {
+		subscribe,
+		get,
+		set,
+		update,
+	};
+}

v2/internal/runtime/js/core/system.js

@@ -0,0 +1,26 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import * as Events from './events';
+import * as Store from './store';
+
+// Set up stores
+export const LogLevel = Store.New('wails:loglevel');
+export const AppConfig = Store.New('wails:appconfig');
+
+// Set up dark mode
+export let isDarkMode;
+
+// Register system event listener to keep isDarkMode up to date
+Events.On('wails:system:themechange', (darkMode) => {
+	isDarkMode = darkMode;
+});
+

v2/internal/runtime/js/core/tray.js

@@ -0,0 +1,28 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 6 */
+
+import { SendMessage } from 'ipc';
+
+/**
+ * Sets the tray icon to the icon referenced by the given ID.
+ * Tray icons must follow this convention:
+ *   - They must be PNG files
+ *   - They must reside in a "trayicons" directory in the project root
+ *   - They must have a ".png" extension
+ *
+ * The icon ID is the name of the file, without the ".png"
+ *
+ * @param {string} trayIconID - The tray icon ID
+ */
+export function SetIcon(trayIconID) {
+	SendMessage('TI' + trayIconID);
+}

v2/internal/runtime/js/core/utils.js

@@ -0,0 +1,42 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Emit } from './events';
+
+export function AddScript(js, callbackID) {
+	var script = document.createElement('script');
+	script.text = js;
+	document.body.appendChild(script);
+	if (callbackID) {
+		Emit(callbackID);
+	}
+}
+
+// Adapted from webview - thanks zserge!
+export function InjectCSS(css) {
+	try {
+		var elem = document.createElement('style');
+		elem.setAttribute('type', 'text/css');
+		if (elem.styleSheet) {
+			elem.styleSheet.cssText = css;
+		} else {
+			elem.appendChild(document.createTextNode(css));
+		}
+		var head = document.head || document.getElementsByTagName('head')[0];
+		head.appendChild(elem);
+	} catch (e) {
+		console.log(e);
+	}
+}
+
+export function DisableDefaultContextMenu() {
+	window.disableWailsDefaultContextMenu = true;
+}

v2/internal/runtime/js/core/window.js

@@ -0,0 +1,135 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 6 */
+
+import { SendMessage } from 'ipc';
+
+/**
+ * Place the window in the center of the screen
+ *
+ * @export
+ */
+export function Center() {
+	SendMessage('Wc');
+}
+
+/**
+ * Sets the window title
+ *
+ * @param {string} title
+ * @export
+ */
+export function SetTitle(title) {
+	SendMessage('WT' + title);
+}
+
+/**
+ * Makes the window go fullscreen
+ *
+ * @export
+ */
+export function Fullscreen() {
+	SendMessage('WF');
+}
+
+/**
+ * Reverts the window from fullscreen
+ *
+ * @export
+ */
+export function UnFullscreen() {
+	SendMessage('Wf');
+}
+
+/**
+ * Set the Size of the window
+ *
+ * @export
+ * @param {number} width
+ * @param {number} height
+ */
+export function SetSize(width, height) {
+	SendMessage('Ws:' + width + ':' + height);
+}
+
+/**
+ * Set the Position of the window
+ *
+ * @export
+ * @param {number} x
+ * @param {number} y
+ */
+export function SetPosition(x, y) {
+	SendMessage('Wp:' + x + ':' + y);
+}
+
+/**
+ * Hide the Window
+ *
+ * @export
+ */
+export function Hide() {
+	SendMessage('WH');
+}
+
+/**
+ * Show the Window
+ *
+ * @export
+ */
+export function Show() {
+	SendMessage('WS');
+}
+
+/**
+ * Maximise the Window
+ *
+ * @export
+ */
+export function Maximise() {
+	SendMessage('WM');
+}
+
+/**
+ * Unmaximise the Window
+ *
+ * @export
+ */
+export function Unmaximise() {
+	SendMessage('WU');
+}
+
+/**
+ * Minimise the Window
+ *
+ * @export
+ */
+export function Minimise() {
+	SendMessage('Wm');
+}
+
+/**
+ * Unminimise the Window
+ *
+ * @export
+ */
+export function Unminimise() {
+	SendMessage('Wu');
+}
+
+/**
+ * Close the Window
+ *
+ * @export
+ */
+export function Close() {
+	SendMessage('WC');
+}

v2/internal/runtime/js/desktop/common.js

@@ -0,0 +1,15 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Initialises platform specific code
+ */
+export const AppType = "desktop";

v2/internal/runtime/js/desktop/darwin.js

@@ -0,0 +1,68 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Initialises platform specific code
+ */
+
+// import * as common from './common';
+const common = require('./common');
+
+export const System = {
+    ...common,
+    Platform: () => "darwin",
+}
+
+export function SendMessage(message) {
+    window.webkit.messageHandlers.external.postMessage(message);
+}
+
+export function Init() {
+
+    // Setup drag handler
+    // Based on code from: https://github.com/patr0nus/DeskGap
+    window.addEventListener('mousedown', function (e) {
+        let currentElement = e.target;
+        while (currentElement != null) {
+            if (currentElement.hasAttribute('data-wails-no-drag')) {
+                break;
+            } else if (currentElement.hasAttribute('data-wails-drag')) {
+                window.webkit.messageHandlers.windowDrag.postMessage(null);
+                break;
+            }
+            currentElement = currentElement.parentElement;
+        }
+    });
+
+    // Setup context menu hook
+    window.addEventListener('contextmenu', function (e) {
+        let currentElement = e.target;
+        let contextMenuId;
+        while (currentElement != null) {
+            contextMenuId = currentElement.dataset['wails-context-menu-id'];
+            if (contextMenuId != null) {
+                break;
+            }
+            currentElement = currentElement.parentElement;
+        }
+        if (contextMenuId != null || window.disableWailsDefaultContextMenu) {
+            e.preventDefault();
+        }
+        if( contextMenuId != null ) {
+            let contextData = currentElement.dataset['wails-context-menu-data'];
+            let message = {
+                id: contextMenuId,
+                data: contextData || "",
+            };
+            window.webkit.messageHandlers.contextMenu.postMessage(JSON.stringify(message));
+        }
+    });
+}

v2/internal/runtime/js/desktop/ipc.js

@@ -0,0 +1,41 @@
+/*
+ _       __      _ __
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import * as Platform from 'platform';
+
+// IPC Listeners
+var listeners = [];
+
+/**
+ * Adds a listener to IPC messages
+ * @param {function} callback
+ */
+export function AddIPCListener(callback) {
+	listeners.push(callback);
+}
+
+/**
+ * SendMessage sends the given message to the backend
+ *
+ * @param {string} message
+ */
+export function SendMessage(message) {
+
+	// Call Platform specific invoke method
+	Platform.SendMessage(message);
+
+	// Also send to listeners
+	if (listeners.length > 0) {
+		for (var i = 0; i < listeners.length; i++) {
+			listeners[i](message);
+		}
+	}
+}

v2/internal/runtime/js/desktop/linux.js

@@ -0,0 +1,41 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Initialises platform specific code
+ */
+
+export const System = {
+    ...common,
+    Platform: () => "linux",
+}
+
+export function SendMessage(message) {
+    window.webkit.messageHandlers.external.postMessage(message);
+}
+
+export function Init() {
+
+    // Setup drag handler
+    // Based on code from: https://github.com/patr0nus/DeskGap
+    window.addEventListener('mousedown', function (e) {
+        var currentElement = e.target;
+        while (currentElement != null) {
+            if (currentElement.hasAttribute('data-wails-no-drag')) {
+                break;
+            } else if (currentElement.hasAttribute('data-wails-drag')) {
+                window.webkit.messageHandlers.windowDrag.postMessage(null);
+                break;
+            }
+            currentElement = currentElement.parentElement;
+        }
+    });
+}