v2.0.0-alpha.74

v2/cmd/wails/internal/commands/build/README.md

@@ -21,6 +21,7 @@ The build command processes the Wails project and generates an application binar
 | -upx | Compress final binary with UPX (if installed) | |
 | -upxflags "custom flags" | Flags to pass to upx | |
 | -v int | Verbosity level (0 - silent, 1 - default, 2 - verbose) | 1 |
+| -delve | If true, runs delve on the compiled binary | false |
 
 ## The Build Process
 
@@ -44,11 +45,4 @@ The build process is as follows:
   - If the `-upx` flag was provided, `upx` is invoked to compress the binary. Custom flags may be provided using the `-upxflags` flag.
   - If the `package` flag is given for a non Windows target, the application is bundled for the platform. On Mac, this creates a `.app` with the processed icons, the `Info.plist` in `build/darwin` and the compiled binary.
 
-### Server Target
-
-TBD
-
-### Hybrid Target
-
-TBD
 

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

@@ -4,11 +4,16 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"runtime"
 	"strings"
 	"text/tabwriter"
 	"time"
 
+	"github.com/wailsapp/wails/v2/internal/system"
+
+	"github.com/wailsapp/wails/v2/internal/shell"
+
 	"github.com/leaanthony/clir"
 	"github.com/leaanthony/slicer"
 	"github.com/wailsapp/wails/v2/pkg/clilogger"
@@ -72,6 +77,9 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 	webview2 := "download"
 	command.StringFlag("webview2", "WebView2 installer strategy: download,embed,browser,error.", &webview2)
 
+	runDelve := false
+	command.BoolFlag("delve", "Runs the built binary in delve for debugging", &runDelve)
+
 	command.Action(func() error {
 
 		quiet := verbosity == 0
@@ -116,6 +124,12 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 			compress = false
 		}
 
+		// Lookup compiler path
+		compilerPath, err := exec.LookPath(compilerCommand)
+		if err != nil {
+			return fmt.Errorf("unable to find compiler: %s", compilerCommand)
+		}
+
 		// Tags
 		userTags := []string{}
 		for _, tag := range strings.Split(tags, " ") {
@@ -144,6 +158,11 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 			}
 		}
 
+		// If we want to use delve we need to compile in DEBUG mode
+		if runDelve {
+			mode = build.Debug
+		}
+
 		// Create BuildOptions
 		buildOptions := &build.Options{
 			Logger:              logger,
@@ -160,16 +179,23 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 			CompressFlags:       compressFlags,
 			UserTags:            userTags,
 			WebView2Strategy:    wv2rtstrategy,
+			RunDelve:            runDelve,
 		}
 
 		// Calculate platform and arch
 		platformSplit := strings.Split(platform, "/")
 		buildOptions.Platform = platformSplit[0]
-		buildOptions.Arch = runtime.GOARCH
+		if system.IsAppleSilicon() {
+			buildOptions.Arch = "arm64"
+		} else {
+			buildOptions.Arch = runtime.GOARCH
+		}
 		if len(platformSplit) == 2 {
 			buildOptions.Arch = platformSplit[1]
 		}
 
+		println("Build arch =", buildOptions.Arch)
+
 		// Start a new tabwriter
 		w := new(tabwriter.Writer)
 		w.Init(os.Stdout, 8, 8, 0, '\t', 0)
@@ -184,7 +210,7 @@ func AddBuildSubcommand(app *clir.Cli, w io.Writer) {
 		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, "Compiler: \t%s\n", compilerPath)
 		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)
@@ -219,5 +245,40 @@ func doBuild(buildOptions *build.Options) error {
 	buildOptions.Logger.Println(fmt.Sprintf("Built '%s' in %s.", outputFilename, elapsed.Round(time.Millisecond).String()))
 	buildOptions.Logger.Println("")
 
+	if buildOptions.RunDelve {
+		// Check delve exists
+		delveExists := shell.CommandExists("dlv")
+		if !delveExists {
+			return fmt.Errorf("cannot launch delve (Is it installed?)")
+		}
+
+		// Get cwd
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+
+		// Launch delve
+		buildOptions.Logger.Println("Launching Delve on port 2345...")
+		cmdArgs := slicer.String([]string{"--listen=:2345", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", outputFilename})
+		if buildOptions.Verbosity == build.VERBOSE {
+			buildOptions.Logger.Println("\tRunning: dlv %s", cmdArgs.Join(" "))
+		}
+		stdout, stderr, err := shell.RunCommand(cwd, "dlv", cmdArgs.AsSlice()...)
+		if buildOptions.Verbosity == build.VERBOSE || err != nil {
+			trimstdout := strings.TrimSpace(stdout)
+			if trimstdout != "" {
+				buildOptions.Logger.Println(trimstdout)
+			}
+			trimstderr := strings.TrimSpace(stderr)
+			if trimstderr != "" {
+				buildOptions.Logger.Println(trimstderr)
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+
 	return nil
 }

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

@@ -1,123 +0,0 @@
-package debug
-
-import (
-	"fmt"
-	"github.com/wailsapp/wails/v2/internal/shell"
-	"io"
-	"os"
-	"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"
-)
-
-// AddSubcommand adds the `debug` command for the Wails application
-func AddSubcommand(app *clir.Cli, w io.Writer) error {
-
-	outputType := "desktop"
-
-	validTargetTypes := slicer.String([]string{"desktop", "hybrid", "server"})
-
-	command := app.NewSubCommand("debug", "Builds the application then runs delve on the binary")
-
-	// Setup target type flag
-	description := "Type of application to build. Valid types: " + validTargetTypes.Join(",")
-	command.StringFlag("t", description, &outputType)
-
-	compilerCommand := "go"
-	command.StringFlag("compiler", "Use a different go compiler to build, eg go1.15beta1", &compilerCommand)
-
-	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)
-
-	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
-
-		// Create BuildOptions
-		buildOptions := &build.Options{
-			Logger:     logger,
-			OutputType: outputType,
-			Mode:       mode,
-			Pack:       false,
-			Platform:   runtime.GOOS,
-			LDFlags:    ldflags,
-			Compiler:   compilerCommand,
-			KeepAssets: false,
-		}
-
-		outputFilename, err := doDebugBuild(buildOptions)
-		if err != nil {
-			return err
-		}
-
-		// Check delve exists
-		delveExists := shell.CommandExists("dlv")
-		if !delveExists {
-			return fmt.Errorf("cannot launch delve (Is it installed?)")
-		}
-
-		// Get cwd
-		cwd, err := os.Getwd()
-		if err != nil {
-			return err
-		}
-
-		// Launch delve
-		println("Launching Delve on port 2345...")
-		command := shell.CreateCommand(cwd, "dlv", "--listen=:2345", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", outputFilename)
-		return command.Run()
-	})
-
-	return nil
-}
-
-// doDebugBuild is our main build command
-func doDebugBuild(buildOptions *build.Options) (string, 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 outputFilename, nil
-}

v2/cmd/wails/internal/commands/generate/README.md

@@ -0,0 +1,18 @@
+# Generate
+
+The `generate` command provides the ability to generate various Wails related components.
+
+## Usage
+
+`wails generate [subcommand] [options]`
+
+## Template
+
+`wails generate template -name <name> [-frontend] [-q]`
+
+Generate a starter template for you to customise.
+
+| Flag           | Details      | 
+| :------------- | :----------- | 
+| -frontend  | Copies all the files from the current directory into the template's `frontend` directory. Useful for converting frontend projects created by boilerplate generators. |
+| -q | Suppress output | 

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

@@ -2,7 +2,8 @@ package generate
 
 import (
 	"io"
-	"time"
+
+	"github.com/wailsapp/wails/v2/cmd/wails/internal/commands/generate/template"
 
 	"github.com/leaanthony/clir"
 	"github.com/wailsapp/wails/v2/pkg/clilogger"
@@ -14,50 +15,9 @@ 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")
+	//AddModuleCommand(app, command, w)
+	template.AddSubCommand(app, command, w)
 
-	// Quiet Init
-	quiet := false
-	backendAPI.BoolFlag("q", "Suppress 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
 }
 

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

@@ -0,0 +1,58 @@
+package generate
+
+import (
+	"io"
+	"time"
+
+	"github.com/leaanthony/clir"
+	"github.com/wailsapp/wails/v2/pkg/clilogger"
+	"github.com/wailsapp/wails/v2/pkg/parser"
+)
+
+func AddModuleCommand(app *clir.Cli, parent *clir.Command, w io.Writer) {
+
+	// Backend API
+	backendAPI := parent.NewSubCommand("module", "Generates a JS module for the frontend to interface with the backend")
+
+	// Quiet Init
+	quiet := false
+	backendAPI.BoolFlag("q", "Suppress 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
+
+	})
+}

v2/cmd/wails/internal/commands/generate/template/base/NEXTSTEPS.md.template

@@ -0,0 +1,38 @@
+# Next Steps
+
+Congratulations on generating your template!
+
+## Completing your template
+
+The next steps to complete the template are:
+
+  1. Complete the fields in the `template.json` file. 
+  2. Update `README.md`.
+  3. Edit `wails.tmpl.json` and ensure all fields are correct, especially:
+     - `html` - path to your `index.html`
+     - `frontend:install` - The command to install your frontend dependencies
+     - `frontend:build` - The command to build your frontend
+  4. Remove any `public` or `dist` directories.
+  5. Delete this file.
+
+## Testing your template
+
+You can test your template by running this command:
+
+`wails init -name test -t {{.TemplateDir}}`
+
+### Checklist 
+Once generated, do the following tests:
+  - Change into the new project directory and run `wails build`. A working binary should be generated in the `build/bin` project directory.
+  - Run `wails dev`. This will compile your backend and run it. You should be able to go into the frontend directory and run `npm run dev` (or whatever your dev command is) and this should run correctly. You should be able to then open a browser to your local dev server and the application should work.
+
+## Publishing your template
+
+You can publish a template to a git repository and use it as follows:
+
+`wails init -name test -t https://your/git/url`
+
+EG: 
+
+`wails init -name test -t https://github.com/leaanthony/testtemplate`
+

v2/cmd/wails/internal/commands/generate/template/base/README.md

@@ -0,0 +1,16 @@
+# README
+
+## About
+
+About your template
+
+## Building 
+
+To build this project in debug mode, use `wails build`. For production, use `wails build -production`.
+To generate a platform native package, add the `-package` flag.
+
+## Live Development
+
+To run in live development mode, run `wails dev` in the project directory. In another terminal, go into the `frontend` 
+directory and run `npm run dev`. The frontend dev server will run on http://localhost:5000. Connect to this
+in your browser and connect to your application. 

v2/cmd/wails/internal/commands/generate/template/base/app.tmpl.go

@@ -6,29 +6,29 @@ import (
 	"github.com/wailsapp/wails/v2"
 )
 
-// Basic application struct
-type Basic struct {
+// App struct
+type App struct {
 	runtime *wails.Runtime
 }
 
-// NewBasic creates a new Basic application struct
-func NewBasic() *Basic {
-	return &Basic{}
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
 }
 
 // startup is called at application startup
-func (b *Basic) startup(runtime *wails.Runtime) {
+func (b *App) startup(runtime *wails.Runtime) {
 	// Perform your setup here
 	b.runtime = runtime
 	runtime.Window.SetTitle("{{.ProjectName}}")
 }
 
 // shutdown is called at application termination
-func (b *Basic) shutdown() {
+func (b *App) shutdown() {
 	// Perform your teardown here
 }
 
 // Greet returns a greeting for the given name
-func (b *Basic) Greet(name string) string {
+func (b *App) Greet(name string) string {
 	return fmt.Sprintf("Hello %s!", name)
 }

v2/cmd/wails/internal/commands/generate/template/base/frontend/package.tmpl.json

@@ -0,0 +1,27 @@
+{
+  "name": "vanilla",
+  "version": "1.0.0",
+  "description": "Vanilla Wails v2 template",
+  "main": "src/main.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "start": "sirv dist"
+  },
+  "author": "{{.AuthorName}}",
+  "license": "ISC",
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^19.0.0",
+    "@rollup/plugin-image": "^2.0.6",
+    "@rollup/plugin-node-resolve": "^13.0.0",
+    "@rollup/plugin-url": "^6.0.0",
+    "@wails/runtime": "^1.3.20",
+    "rollup": "^2.50.4",
+    "rollup-plugin-copy": "^3.4.0",
+    "rollup-plugin-livereload": "^2.0.0",
+    "rollup-plugin-postcss": "^4.0.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "sirv-cli": "^1.0.12"
+  }
+}

v2/cmd/wails/internal/commands/generate/template/base/frontend/rollup.config.js

@@ -0,0 +1,103 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import livereload from 'rollup-plugin-livereload';
+import { terser } from 'rollup-plugin-terser';
+import postcss from 'rollup-plugin-postcss';
+import image from '@rollup/plugin-image';
+import url from '@rollup/plugin-url';
+import copy from 'rollup-plugin-copy';
+
+const production = !process.env.ROLLUP_WATCH;
+
+export default {
+    input: 'src/main.js',
+    output: {
+        sourcemap: true,
+        format: 'iife',
+        name: 'app',
+        file: 'dist/main.js'
+    },
+    onwarn: handleRollupWarning,
+    plugins: [
+
+        image(),
+
+        copy({
+            targets: [
+                { src: 'src/index.html', dest: 'dist' },
+                { src: 'src/main.css', dest: 'dist' },
+            ]
+        }),
+
+        // Embed binary files
+        url({
+            include: ['**/*.woff', '**/*.woff2'],
+            limit: Infinity,
+        }),
+
+        // If you have external dependencies installed from
+        // npm, you'll most likely need these plugins. In
+        // some cases you'll need additional configuration -
+        // consult the documentation for details:
+        // https://github.com/rollup/plugins/tree/master/packages/commonjs
+        resolve({
+            browser: true,
+        }),
+        commonjs(),
+
+        // PostCSS preprocessing
+        postcss({
+            extensions: ['.css', '.scss'],
+            extract: true,
+            minimize: false,
+            use: [
+                ['sass', {
+                    includePaths: [
+                        './src',
+                        './node_modules'
+                    ]
+                }]
+            ],
+        }),
+
+        // In dev mode, call `npm run start` once
+        // the bundle has been generated
+        !production && serve(),
+
+        // Watch the `public` directory and refresh the
+        // browser on changes when not in production
+        !production && livereload('dist'),
+
+        // If we're building for production (npm run build
+        // instead of npm run dev), minify
+        production && terser()
+    ],
+    watch: {
+        clearScreen: false
+    }
+};
+
+function handleRollupWarning(warning) {
+    console.error('ERROR: ' + warning.toString());
+}
+
+function serve() {
+    let server;
+
+    function toExit() {
+        if (server) server.kill(0);
+    }
+
+    return {
+        writeBundle() {
+            if (server) return;
+            server = require('child_process').spawn('npm', ['run', 'start', '--', '--dev'], {
+                stdio: ['ignore', 'inherit', 'inherit'],
+                shell: true
+            });
+
+            process.on('SIGTERM', toExit);
+            process.on('exit', toExit);
+        }
+    };
+}

v2/cmd/wails/internal/commands/generate/template/base/frontend/src/index.html

@@ -0,0 +1,18 @@
+<html>
+
+<head>
+  <link rel="stylesheet" href="/main.css">
+</head>
+
+<body data-wails-drag>
+  <div id="logo"></div>
+  <div id="input" data-wails-no-drag>
+    <input id="name" type="text">
+    <button onclick="greet()">Greet</button>
+  </div>
+  <div id="result"></div>
+
+  <script src="/main.js"></script>
+</body>
+
+</html>

v2/cmd/wails/internal/commands/generate/template/base/frontend/src/main.js

@@ -0,0 +1,21 @@
+
+import {ready} from '@wails/runtime';
+
+ready( () => {
+  // Get input + focus
+  let nameElement = document.getElementById("name");
+  nameElement.focus();
+
+  // Setup the greet function
+  window.greet = function () {
+
+    // Get name
+    let name = nameElement.value;
+
+    // Call Basic.Greet(name)
+    window.backend.main.Basic.Greet(name).then((result) => {
+      // Update result with data back from Basic.Greet()
+      document.getElementById("result").innerText = result;
+    });
+  };
+});

v2/cmd/wails/internal/commands/generate/template/base/go.mod.tmpl

@@ -0,0 +1,9 @@
+module test
+
+go 1.16
+
+require (
+	github.com/wailsapp/wails/v2 v2.0.0-alpha
+)
+
+replace github.com/wailsapp/wails/v2 v2.0.0-alpha => {{.WailsDirectory}}

v2/cmd/wails/internal/commands/generate/template/base/main.tmpl.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"log"
+
+	"github.com/wailsapp/wails/v2/pkg/options/windows"
+
+	"github.com/wailsapp/wails/v2"
+	"github.com/wailsapp/wails/v2/pkg/logger"
+	"github.com/wailsapp/wails/v2/pkg/menu"
+	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/options/mac"
+)
+
+func main() {
+
+	// Create application with options
+	app := NewApp()
+
+	err := wails.Run(&options.App{
+		Title:             "{{.ProjectName}}",
+		Width:             800,
+		Height:            600,
+		MinWidth:          400,
+		MinHeight:         400,
+		MaxWidth:          1280,
+		MaxHeight:         1024,
+		DisableResize:     false,
+		Fullscreen:        false,
+		Frameless:         false,
+		StartHidden:       false,
+		HideWindowOnClose: false,
+		DevTools:          false,
+		RGBA:              0x000000FF,
+		Windows: &windows.Options{
+			WebviewIsTransparent:          true,
+			WindowBackgroundIsTranslucent: true,
+			DisableWindowIcon:             true,
+		},
+		Mac: &mac.Options{
+			WebviewIsTransparent:          true,
+			WindowBackgroundIsTranslucent: true,
+			TitleBar:                      mac.TitleBarHiddenInset(),
+			Menu:                          menu.DefaultMacMenu(),
+		},
+		LogLevel: logger.DEBUG,
+		Startup:  app.startup,
+		Shutdown: app.shutdown,
+		Bind: []interface{}{
+			app,
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+}

v2/cmd/wails/internal/commands/generate/template/base/template.json.template

@@ -0,0 +1,7 @@
+{
+  "name": "Long name",
+  "shortname": "{{.Name}}",
+  "author": "",
+  "description": "Description of the template",
+  "helpurl": "URL for help with the template, eg homepage"
+}

v2/cmd/wails/internal/commands/generate/template/base/wails.tmpl.json

@@ -0,0 +1,11 @@
+{
+    "name": "{{.ProjectName}}",
+    "outputfilename": "{{.BinaryName}}",
+    "html": "frontend/dist/index.html",
+    "frontend:build": "npm run build",
+    "frontend:install": "npm install",
+    "author": {
+        "name": "{{.AuthorName}}",
+        "email": "{{.AuthorEmail}}"
+    }
+}

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

@@ -0,0 +1,188 @@
+package template
+
+import (
+	"embed"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/leaanthony/debme"
+
+	"github.com/leaanthony/gosod"
+	"github.com/wailsapp/wails/v2/internal/fs"
+
+	"github.com/leaanthony/clir"
+	"github.com/tidwall/sjson"
+)
+
+//go:embed base
+var base embed.FS
+
+func AddSubCommand(app *clir.Cli, parent *clir.Command, w io.Writer) {
+
+	// command
+	command := parent.NewSubCommand("template", "Generates a wails template")
+
+	name := ""
+	command.StringFlag("name", "The name of the template", &name)
+
+	migrate := false
+	command.BoolFlag("migrate", "This indicates that the current directory is a frontend project and should be used by the template", &migrate)
+
+	// Quiet Init
+	quiet := false
+	command.BoolFlag("q", "Suppress output to console", &quiet)
+
+	command.Action(func() error {
+
+		// If the current directory is not empty, we create a new directory
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+		templateDir := cwd
+		empty, err := fs.DirIsEmpty(templateDir)
+		if err != nil {
+			return err
+		}
+		if !empty {
+			templateDir = filepath.Join(cwd, name)
+			println("Creating new template directory:", name)
+			err = fs.Mkdir(templateDir)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Create base template
+		baseTemplate, err := debme.FS(base, "base")
+		if err != nil {
+			return err
+		}
+		g := gosod.New(baseTemplate)
+		g.SetTemplateFilters([]string{".template"})
+
+		err = os.Chdir(templateDir)
+		if err != nil {
+			return err
+		}
+
+		type templateData struct {
+			Name        string
+			Description string
+			TemplateDir string
+		}
+
+		println("Extracting base template files...")
+
+		err = g.Extract(templateDir, &templateData{
+			Name:        name,
+			TemplateDir: templateDir,
+		})
+		if err != nil {
+			return err
+		}
+
+		// If we aren't migrating the files, just exit
+		if migrate == false {
+			return nil
+		}
+
+		// Remove frontend directory
+		frontendDir := filepath.Join(templateDir, "frontend")
+		err = os.RemoveAll(frontendDir)
+		if err != nil {
+			return err
+		}
+
+		// Move the files into a new frontend directory
+		println("Migrating files to frontend directory...")
+		err = fs.MoveDirExtended(cwd, frontendDir, []string{name})
+		if err != nil {
+			return err
+		}
+
+		// Process package.json
+		err = processPackageJSON(frontendDir)
+		if err != nil {
+			return err
+		}
+
+		// Process package-lock.json
+		err = processPackageLockJSON(frontendDir)
+		if err != nil {
+			return err
+		}
+
+		// Remove node_modules - ignore error, eg it doesn't exist
+		_ = os.RemoveAll(filepath.Join(frontendDir, "node_modules"))
+
+		return nil
+
+	})
+}
+
+func processPackageJSON(frontendDir string) error {
+	var err error
+
+	packageJSON := filepath.Join(frontendDir, "package.json")
+	if !fs.FileExists(packageJSON) {
+		println("No package.json found - cannot process.")
+		return nil
+	}
+
+	data, err := os.ReadFile(packageJSON)
+	if err != nil {
+		return err
+	}
+	json := string(data)
+
+	// We will ignore these errors - it's not critical
+	println("Updating package.json data...")
+	json, _ = sjson.Set(json, "name", "{{.ProjectName}}")
+	json, _ = sjson.Set(json, "author", "{{.AuthorName}}")
+
+	err = os.WriteFile(packageJSON, []byte(json), 0644)
+	if err != nil {
+		return err
+	}
+	baseDir := filepath.Dir(packageJSON)
+	println("Renaming package.json -> package.tmpl.json...")
+	err = os.Rename(packageJSON, filepath.Join(baseDir, "package.tmpl.json"))
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func processPackageLockJSON(frontendDir string) error {
+	var err error
+
+	filename := filepath.Join(frontendDir, "package-lock.json")
+	if !fs.FileExists(filename) {
+		println("No package-lock.json found - cannot process.")
+		return nil
+	}
+
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+	json := string(data)
+
+	// We will ignore these errors - it's not critical
+	println("Updating package-lock.json data...")
+	json, _ = sjson.Set(json, "name", "{{.ProjectName}}")
+
+	err = os.WriteFile(filename, []byte(json), 0644)
+	if err != nil {
+		return err
+	}
+	baseDir := filepath.Dir(filename)
+	println("Renaming package-lock.json -> package-lock.tmpl.json...")
+	err = os.Rename(filename, filepath.Join(baseDir, "package-lock.tmpl.json"))
+	if err != nil {
+		return err
+	}
+	return nil
+}