v2.0.0-alpha.65

In some bundler enviroments like vite the output on index.html uses link
tag with rel="modulepreload" to load javascript, add support to handle
this files on assetbundle, more info
https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/modulepreload

fix #620

Co-authored-by: amaury-tobias <amaury.tobiasqr@gmai.com>

CONTRIBUTORS.md

@@ -40,4 +40,5 @@ Wails is what it is because of the time and effort given by these great people.
   * [Balakrishna Prasad Ganne](https://github.com/aayush420)
   * [Charaf Rezrazi](https://github.com/Rezrazi)
   * [misitebao](https://github.com/misitebao)
-  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Elie Grenon](https://github.com/DrunkenPoney)
+  * [Amaury Tobias Quiroz](https://github.com/amaury-tobias)

runtime/js/.eslintrc

@@ -3,12 +3,12 @@
         "browser": true,
         "es6": true,
         "amd": true,
-        "node": true,
+        "node": true
     },
     "extends": "eslint:recommended",
     "parserOptions": {
         "ecmaVersion": 2016,
-        "sourceType": "module",
+        "sourceType": "module"
     },
     "rules": {
         "indent": [

runtime/js/core/browser.js

@@ -26,7 +26,7 @@ export function OpenURL(url) {
  * Opens the given filename using the system's default file handler
  *
  * @export
- * @param {sting} filename
+ * @param {string} filename
  * @returns
  */
 export function OpenFile(filename) {

runtime/js/core/calls.js

@@ -62,7 +62,7 @@ if (window.crypto) {
 export function Call(bindingName, data, timeout) {
 
 	// Timeout infinite by default
-	if (timeout == null || timeout == undefined) {
+	if (timeout == null) {
 		timeout = 0;
 	}
 

runtime/js/core/ipc.js

@@ -45,7 +45,7 @@ function Invoke(message) {
  *
  * @export
  * @param {string} type
- * @param {string} payload
+ * @param {Object} payload
  * @param {string=} callbackID
  */
 export function SendMessage(type, payload, callbackID) {

runtime/js/runtime/.npmignore

@@ -1 +1 @@
-bridge.js
+index.js

scripts/build.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 echo "**** Checking if Wails passes unit tests ****"
-if ! go test ./...
+if ! go test ./lib/... ./runtime/... ./cmd/...
 then
     echo ""
     echo "ERROR: Unit tests failed!"

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

@@ -3,8 +3,10 @@ package build
 import (
 	"fmt"
 	"io"
+	"os"
 	"runtime"
 	"strings"
+	"text/tabwriter"
 	"time"
 
 	"github.com/leaanthony/clir"
@@ -22,10 +24,6 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 
 	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)
@@ -37,28 +35,41 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 	compilerCommand := "go"
 	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
 
+	compress := false
+	command.BoolFlag("compress", "Compress final binary", &compress)
+
 	// 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)
+	// Verbosity
+	verbosity := 1
+	command.IntFlag("v", "Verbosity level (0 - silent, 1 - default, 2 - verbose)", &verbosity)
 
 	// ldflags to pass to `go`
 	ldflags := ""
 	command.StringFlag("ldflags", "optional ldflags", &ldflags)
 
-	// Log to file
-	logFile := ""
-	command.StringFlag("l", "Log to file", &logFile)
+	// tags to pass to `go`
+	tags := ""
+	command.StringFlag("tags", "tags to pass to Go compiler (quoted and space separated)", &tags)
 
 	// Retain assets
 	keepAssets := false
 	command.BoolFlag("k", "Keep generated assets", &keepAssets)
 
+	// Retain assets
+	outputFilename := ""
+	command.StringFlag("o", "Output filename", &outputFilename)
+
+	// Clean build directory
+	cleanBuildDirectory := false
+	command.BoolFlag("clean", "Clean the build directory before building", &cleanBuildDirectory)
+
 	command.Action(func() error {
 
+		quiet := verbosity == 0
+
 		// Create logger
 		logger := clilogger.New(w)
 		logger.Mute(quiet)
@@ -72,28 +83,92 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 			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
 		}
 
+		// Check platform
+		validPlatformArch := slicer.String([]string{
+			"darwin",
+			"darwin/amd64",
+			"darwin/arm64",
+			"darwin/universal",
+			//"linux/amd64",
+			//"linux/arm-7",
+			//"windows/amd64",
+		})
+		if !validPlatformArch.Contains(platform) {
+			return fmt.Errorf("platform %s is not supported", platform)
+		}
+
+		if compress && platform == "darwin/universal" {
+			println("Warning: compress flag unsupported for universal binaries. Ignoring.")
+			compress = false
+		}
+
+		// Tags
+		userTags := []string{}
+		for _, tag := range strings.Split(tags, " ") {
+			thisTag := strings.TrimSpace(tag)
+			if thisTag != "" {
+				userTags = append(userTags, thisTag)
+			}
+		}
+
 		// Create BuildOptions
 		buildOptions := &build.Options{
-			Logger:     logger,
-			OutputType: outputType,
-			Mode:       mode,
-			Pack:       pack,
-			Platform:   platform,
-			LDFlags:    ldflags,
-			Compiler:   compilerCommand,
-			KeepAssets: keepAssets,
+			Logger:              logger,
+			OutputType:          outputType,
+			OutputFile:          outputFilename,
+			CleanBuildDirectory: cleanBuildDirectory,
+			Mode:                mode,
+			Pack:                pack,
+			LDFlags:             ldflags,
+			Compiler:            compilerCommand,
+			KeepAssets:          keepAssets,
+			Verbosity:           verbosity,
+			Compress:            compress,
+			UserTags:            userTags,
 		}
 
+		// Calculate platform and arch
+		platformSplit := strings.Split(platform, "/")
+		buildOptions.Platform = platformSplit[0]
+		buildOptions.Arch = runtime.GOARCH
+		if len(platformSplit) == 2 {
+			buildOptions.Arch = platformSplit[1]
+		}
+
+		// Start a new tabwriter
+		w := new(tabwriter.Writer)
+		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
+
+		buildModeText := "debug"
+		if production {
+			buildModeText = "production"
+		}
+
+		// Write out the system information
+		fmt.Fprintf(w, "\n")
+		fmt.Fprintf(w, "App Type: \t%s\n", buildOptions.OutputType)
+		fmt.Fprintf(w, "Platform: \t%s\n", buildOptions.Platform)
+		fmt.Fprintf(w, "Arch: \t%s\n", buildOptions.Arch)
+		fmt.Fprintf(w, "Compiler: \t%s\n", buildOptions.Compiler)
+		fmt.Fprintf(w, "Compress: \t%t\n", buildOptions.Compress)
+		fmt.Fprintf(w, "Build Mode: \t%s\n", buildModeText)
+		fmt.Fprintf(w, "Package: \t%t\n", buildOptions.Pack)
+		fmt.Fprintf(w, "Clean Build Dir: \t%t\n", buildOptions.CleanBuildDirectory)
+		fmt.Fprintf(w, "KeepAssets: \t%t\n", buildOptions.KeepAssets)
+		fmt.Fprintf(w, "LDFlags: \t\"%s\"\n", buildOptions.LDFlags)
+		fmt.Fprintf(w, "Tags: \t[%s]\n", strings.Join(buildOptions.UserTags, ","))
+		if len(buildOptions.OutputFile) > 0 {
+			fmt.Fprintf(w, "Output File: \t%s\n", buildOptions.OutputFile)
+		}
+		fmt.Fprintf(w, "\n")
+		w.Flush()
+
 		return doBuild(buildOptions)
 	})
 }

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

@@ -5,33 +5,42 @@ import (
 	"io"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"syscall"
 	"time"
 
+	"github.com/wailsapp/wails/v2/internal/colour"
+
 	"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"
 )
 
+func LogGreen(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.Green(text))
+}
+
+func LogRed(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.Red(text))
+}
+
+func LogDarkYellow(message string, args ...interface{}) {
+	text := fmt.Sprintf(message, args...)
+	println(colour.DarkYellow(text))
+}
+
 // 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)
@@ -42,15 +51,17 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// extensions to trigger rebuilds
 	extensions := "go"
-	command.StringFlag("m", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+	command.StringFlag("e", "Extensions to trigger rebuilds (comma separated) eg go,js,css,html", &extensions)
+
+	// extensions to trigger rebuilds
+	showWarnings := false
+	command.BoolFlag("w", "Show warnings", &showWarnings)
+
+	loglevel := ""
+	command.StringFlag("loglevel", "Loglevel to use - Trace, Debug, Info, Warning, Error", &loglevel)
 
 	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()
@@ -64,7 +75,6 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		defer watcher.Close()
 
 		var debugBinaryProcess *process.Process = nil
-		var buildFrontend bool = true
 		var extensionsThatTriggerARebuild = strings.Split(extensions, ",")
 
 		// Setup signal handler
@@ -75,8 +85,13 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 		// Do initial build
 		logger.Println("Building application for development...")
-		debugBinaryProcess = restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
-
+		newProcess, err := restartApp(logger, "dev", ldflags, compilerCommand, debugBinaryProcess, loglevel)
+		if newProcess != nil {
+			debugBinaryProcess = newProcess
+		}
+		if err != nil {
+			return err
+		}
 		go debounce(100*time.Millisecond, watcher.Events, debounceQuit, func(event fsnotify.Event) {
 			// logger.Println("event: %+v", event)
 
@@ -89,7 +104,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 						if err != nil {
 							logger.Fatal("%s", err.Error())
 						}
-						logger.Println("Watching directory: %s", event.Name)
+						LogGreen("[New Directory] Watching new directory: %s", event.Name)
 					}
 				}
 				return
@@ -98,38 +113,33 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 			// 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")
+					if strings.HasSuffix(event.Name, pattern) {
+						rebuild = true
 						break
 					}
 				}
 
 				if !rebuild {
-					logger.Println("Filename change: %s did not match extension list %s", event.Name, extensions)
+					if showWarnings {
+						LogDarkYellow("[File 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)
-				}
+				LogGreen("[Attempting rebuild] %s updated", event.Name)
 
 				// Do a rebuild
 
 				// Try and build the app
-				newBinaryProcess := restartApp(logger, outputType, ldflags, compilerCommand, buildFrontend, debugBinaryProcess)
-
+				newBinaryProcess, err := restartApp(logger, "dev", ldflags, compilerCommand, debugBinaryProcess, loglevel)
+				if err != nil {
+					fmt.Printf("Error during build: %s", err.Error())
+					return
+				}
 				// If we have a new process, save it
 				if newBinaryProcess != nil {
 					debugBinaryProcess = newBinaryProcess
@@ -139,23 +149,28 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		})
 
 		// Get project dir
-		dir, err := os.Getwd()
+		projectDir, err := os.Getwd()
 		if err != nil {
 			return err
 		}
 
 		// Get all subdirectories
-		dirs, err := fs.GetSubdirectories(dir)
+		dirs, err := fs.GetSubdirectories(projectDir)
 		if err != nil {
 			return err
 		}
 
+		LogGreen("Watching (sub)/directory: %s", projectDir)
+
 		// 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)
+			// Ignore build directory
+			if strings.HasPrefix(dir, filepath.Join(projectDir, "build")) {
+				return
+			}
 			err = watcher.Add(dir)
 			if err != nil {
 				logger.Fatal(err.Error())
@@ -167,7 +182,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 		for quit == false {
 			select {
 			case <-quitChannel:
-				println()
+				LogGreen("\nCaught quit")
 				// Notify debouncer to quit
 				debounceQuit <- true
 				quit = true
@@ -182,7 +197,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 			}
 		}
 
-		logger.Println("Development mode exited")
+		LogGreen("Development mode exited")
 
 		return nil
 	})
@@ -209,15 +224,15 @@ exit:
 	}
 }
 
-func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool, debugBinaryProcess *process.Process) *process.Process {
+func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, debugBinaryProcess *process.Process, loglevel string) (*process.Process, error) {
 
-	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand, buildFrontend)
+	appBinary, err := buildApp(logger, outputType, ldflags, compilerCommand)
 	println()
 	if err != nil {
-		logger.Println("[ERROR] Build Failed: %s", err.Error())
-		return nil
+		LogRed("Build error - continuing to run current version")
+		LogDarkYellow(err.Error())
+		return nil, nil
 	}
-	logger.Println("Build new binary: %s", appBinary)
 
 	// Kill existing binary if need be
 	if debugBinaryProcess != nil {
@@ -233,7 +248,7 @@ func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string,
 	// TODO: Generate `backend.js`
 
 	// Start up new binary
-	newProcess := process.NewProcess(logger, appBinary)
+	newProcess := process.NewProcess(logger, appBinary, "-loglevel", loglevel)
 	err = newProcess.Start()
 	if err != nil {
 		// Remove binary
@@ -244,13 +259,13 @@ func restartApp(logger *clilogger.CLILogger, outputType string, ldflags string,
 		logger.Fatal("Unable to start application: %s", err.Error())
 	}
 
-	return newProcess
+	return newProcess, nil
 }
 
-func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string, buildFrontend bool) (string, error) {
+func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, compilerCommand string) (string, error) {
 
 	// Create random output file
-	outputFile := fmt.Sprintf("debug-%d", time.Now().Unix())
+	outputFile := fmt.Sprintf("dev-%d", time.Now().Unix())
 
 	// Create BuildOptions
 	buildOptions := &build.Options{
@@ -262,7 +277,7 @@ func buildApp(logger *clilogger.CLILogger, outputType string, ldflags string, co
 		LDFlags:        ldflags,
 		Compiler:       compilerCommand,
 		OutputFile:     outputFile,
-		IgnoreFrontend: !buildFrontend,
+		IgnoreFrontend: true,
 	}
 
 	return build.Build(buildOptions)

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

@@ -48,9 +48,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 		// 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())

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

@@ -9,7 +9,7 @@ import (
 	"github.com/wailsapp/wails/v2/pkg/parser"
 )
 
-// AddSubcommand adds the `dev` command for the Wails application
+// AddSubcommand adds the `generate` command for the Wails application
 func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	command := app.NewSubCommand("generate", "Code Generation Tools")
@@ -19,7 +19,7 @@ func AddSubcommand(app *clir.Cli, w io.Writer) error {
 
 	// Quiet Init
 	quiet := false
-	backendAPI.BoolFlag("q", "Supress output to console", &quiet)
+	backendAPI.BoolFlag("q", "Suppress output to console", &quiet)
 
 	backendAPI.Action(func() error {
 
@@ -85,7 +85,4 @@ func logPackage(pkg *parser.Package, logger *clilogger.CLILogger) {
 		}
 	}
 	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

@@ -6,9 +6,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/initialise/templates"
+
 	"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"
 )

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

@@ -1,14 +1,16 @@
 package templates
 
 import (
+	"embed"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	gofs "io/fs"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 
+	"github.com/leaanthony/debme"
 	"github.com/leaanthony/gosod"
 	"github.com/leaanthony/slicer"
 	"github.com/olekukonko/tablewriter"
@@ -16,6 +18,12 @@ import (
 	"github.com/wailsapp/wails/v2/pkg/clilogger"
 )
 
+//go:embed templates
+var templates embed.FS
+
+//go:embed ides/*
+var ides embed.FS
+
 // Cahce for the templates
 // We use this because we need different views of the same data
 var templateCache []Template = nil
@@ -59,20 +67,21 @@ type Template struct {
 	HelpURL     string `json:"helpurl"`
 
 	// Other data
-	Directory string `json:"-"`
+	FS gofs.FS `json:"-"`
 }
 
-func parseTemplate(directory string) (Template, error) {
-	templateJSON := filepath.Join(directory, "template.json")
+func parseTemplate(template gofs.FS) (Template, error) {
 	var result Template
-	data, err := ioutil.ReadFile(templateJSON)
+	data, err := gofs.ReadFile(template, "template.json")
 	if err != nil {
 		return result, err
 	}
-
-	result.Directory = directory
 	err = json.Unmarshal(data, &result)
-	return result, err
+	if err != nil {
+		return result, err
+	}
+	result.FS = template
+	return result, nil
 }
 
 // TemplateShortNames returns a slicer of short template names
@@ -134,11 +143,13 @@ func getTemplateByShortname(shortname string) (Template, error) {
 // Loads the template cache
 func loadTemplateCache() error {
 
-	// Get local template directory
-	templateDir := fs.RelativePath("templates")
+	templatesFS, err := debme.FS(templates, "templates")
+	if err != nil {
+		return err
+	}
 
 	// Get directories
-	files, err := ioutil.ReadDir(templateDir)
+	files, err := templatesFS.ReadDir(".")
 	if err != nil {
 		return err
 	}
@@ -148,8 +159,11 @@ func loadTemplateCache() error {
 
 	for _, file := range files {
 		if file.IsDir() {
-			templateDir := filepath.Join(templateDir, file.Name())
-			template, err := parseTemplate(templateDir)
+			templateFS, err := templatesFS.FS(file.Name())
+			if err != nil {
+				return err
+			}
+			template, err := parseTemplate(templateFS)
 			if err != nil {
 				// Cannot parse this template, continue
 				continue
@@ -163,7 +177,6 @@ func loadTemplateCache() error {
 
 // Install the given template
 func Install(options *Options) error {
-
 	// Get cwd
 	cwd, err := os.Getwd()
 	if err != nil {
@@ -211,19 +224,16 @@ func Install(options *Options) error {
 	}
 
 	// Use Gosod to install the template
-	installer, err := gosod.TemplateDir(template.Directory)
-	if err != nil {
-		return err
-	}
+	installer := gosod.New(template.FS)
 
 	// Ignore template.json files
-	installer.IgnoreFilename("template.json")
+	installer.IgnoreFile("template.json")
 
 	// Setup the data.
 	// We use the directory name for the binary name, like Go
 	BinaryName := filepath.Base(options.TargetDir)
 	NPMProjectName := strings.ToLower(strings.ReplaceAll(BinaryName, " ", ""))
-	localWailsDirectory := fs.RelativePath("../..")
+	localWailsDirectory := fs.RelativePath("../../../../../..")
 	templateData := &Data{
 		ProjectName:    options.ProjectName,
 		BinaryName:     filepath.Base(options.TargetDir),
@@ -295,14 +305,14 @@ func generateIDEFiles(options *Options) error {
 func generateVSCodeFiles(options *Options) error {
 
 	targetDir := filepath.Join(options.TargetDir, ".vscode")
-	sourceDir := fs.RelativePath(filepath.Join("./ides/vscode"))
-
-	// Use Gosod to install the template
-	installer, err := gosod.TemplateDir(sourceDir)
+	source, err := debme.FS(ides, "ides/vscode")
 	if err != nil {
 		return err
 	}
 
+	// Use gosod to install the template
+	installer := gosod.New(source)
+
 	binaryName := filepath.Base(options.TargetDir)
 	if runtime.GOOS == "windows" {
 		// yay windows

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/basic.tmpl.go

@@ -11,21 +11,20 @@ type Basic struct {
 	runtime *wails.Runtime
 }
 
-// newBasic creates a new Basic application struct
-func newBasic() *Basic {
+// NewBasic creates a new Basic application struct
+func NewBasic() *Basic {
 	return &Basic{}
 }
 
-// WailsInit is called at application startup
-func (b *Basic) WailsInit(runtime *wails.Runtime) error {
+// startup is called at application startup
+func (b *Basic) startup(runtime *wails.Runtime) {
 	// Perform your setup here
 	b.runtime = runtime
 	runtime.Window.SetTitle("{{.ProjectName}}")
-	return nil
 }
 
-// WailsShutdown is called at application termination
-func (b *Basic) WailsShutdown() {
+// shutdown is called at application termination
+func (b *Basic) shutdown() {
 	// Perform your teardown here
 }
 

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/frontend/src/index.html

@@ -4,7 +4,7 @@
   <link rel="stylesheet" href="/main.css">
 </head>
 
-<body>
+<body data-wails-drag>
   <div id="logo"></div>
   <div id="input">
     <input id="name" type="text"></input>

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/frontend/src/main.js

@@ -1,12 +1,12 @@
 // Get input + focus
-var nameElement = document.getElementById("name");
+let nameElement = document.getElementById("name");
 nameElement.focus();
 
-// Stup the greet function
+// Setup the greet function
 window.greet = function () {
 
   // Get name
-  var name = nameElement.value;
+  let name = nameElement.value;
 
   // Call Basic.Greet(name)
   window.backend.main.Basic.Greet(name).then((result) => {

v2/cmd/wails/internal/commands/initialise/templates/templates/vanilla/go.mod.tmpl

@@ -1,6 +1,6 @@
 module test
 
-go 1.13
+go 1.16
 
 require (
 	github.com/wailsapp/wails/v2 v2.0.0-alpha