fix comment

Improve build/serve

.gitignore

@@ -10,3 +10,8 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+examples/**/example*
+!examples/**/*.*
+cmd/wails/wails
+.DS_Store

app.go

@@ -0,0 +1,138 @@
+package wails
+
+import (
+	"github.com/wailsapp/wails/cmd"
+)
+
+// -------------------------------- Compile time Flags ------------------------------
+
+// BuildMode indicates what mode we are in
+var BuildMode = "prod"
+
+// ----------------------------------------------------------------------------------
+
+// App defines the main application struct
+type App struct {
+	config         *AppConfig      // The Application configuration object
+	cli            *cmd.Cli        // In debug mode, we have a cli
+	renderer       Renderer        // The renderer is what we will render the app to
+	logLevel       string          // The log level of the app
+	ipc            *ipcManager     // Handles the IPC calls
+	log            *CustomLogger   // Logger
+	bindingManager *bindingManager // Handles binding of Go code to renderer
+	eventManager   *eventManager   // Handles all the events
+	runtime        *Runtime        // The runtime object for registered structs
+
+	// This is a list of all the JS/CSS that needs injecting
+	// It will get injected in order
+	jsCache  []string
+	cssCache []string
+}
+
+// CreateApp creates the application window with the given configuration
+// If none given, the defaults are used
+func CreateApp(optionalConfig ...*AppConfig) *App {
+	var userConfig *AppConfig
+	if len(optionalConfig) > 0 {
+		userConfig = optionalConfig[0]
+	}
+
+	result := &App{
+		logLevel:       "info",
+		renderer:       &webViewRenderer{},
+		ipc:            newIPCManager(),
+		bindingManager: newBindingManager(),
+		eventManager:   newEventManager(),
+		log:            newCustomLogger("App"),
+	}
+
+	appconfig, err := newAppConfig(userConfig)
+	if err != nil {
+		result.log.Fatalf("Cannot use custom HTML: %s", err.Error())
+	}
+	result.config = appconfig
+
+	// Set up the CLI if not in release mode
+	if BuildMode != "prod" {
+		result.cli = result.setupCli()
+	} else {
+		// Disable Inspector in release mode
+		result.config.DisableInspector = true
+	}
+
+	return result
+}
+
+// Run the app
+func (a *App) Run() error {
+	if BuildMode != "prod" {
+		return a.cli.Run()
+	}
+
+	a.logLevel = "error"
+	return a.start()
+}
+
+func (a *App) start() error {
+
+	// Set the log level
+	setLogLevel(a.logLevel)
+
+	// Log starup
+	a.log.Info("Starting")
+
+	// Check if we are to run in headless mode
+	if BuildMode == "bridge" {
+		a.renderer = &Headless{}
+	}
+
+	// Initialise the renderer
+	err := a.renderer.Initialise(a.config, a.ipc, a.eventManager)
+	if err != nil {
+		return err
+	}
+
+	// Start event manager and give it our renderer
+	a.eventManager.start(a.renderer)
+
+	// Start the IPC Manager and give it the event manager and binding manager
+	a.ipc.start(a.eventManager, a.bindingManager)
+
+	// Create the runtime
+	a.runtime = newRuntime(a.eventManager, a.renderer)
+
+	// Start binding manager and give it our renderer
+	err = a.bindingManager.start(a.renderer, a.runtime)
+	if err != nil {
+		return err
+	}
+
+	// Inject CSS
+	a.renderer.AddCSSList(a.cssCache)
+
+	// Inject JS
+	a.renderer.AddJSList(a.jsCache)
+
+	// Run the renderer
+	a.renderer.Run()
+
+	return nil
+}
+
+// Bind allows the user to bind the given object
+// with the application
+func (a *App) Bind(object interface{}) {
+	a.bindingManager.bind(object)
+}
+
+// AddJS adds a piece of Javascript to a cache that
+// gets injected at runtime
+func (a *App) AddJS(js string) {
+	a.jsCache = append(a.jsCache, js)
+}
+
+// AddCSS adds a CSS string to a cache that
+// gets injected at runtime
+func (a *App) AddCSS(js string) {
+	a.cssCache = append(a.cssCache, js)
+}

app_cli.go

@@ -0,0 +1,31 @@
+package wails
+
+import (
+	"fmt"
+
+	"github.com/wailsapp/wails/cmd"
+)
+
+// setupCli creates a new cli handler for the application
+func (app *App) setupCli() *cmd.Cli {
+
+	// Create a new cli
+	result := cmd.NewCli(app.config.Title, "Debug build")
+
+	// Setup cli to handle loglevel and headless flags
+	result.
+		StringFlag("loglevel", "Sets the log level [debug|info|error|panic|fatal]. Default debug", &app.logLevel).
+		// BoolFlag("headless", "Runs the app in headless mode", &app.headless).
+		Action(app.start)
+
+	// Banner
+	result.PreRun(func(cli *cmd.Cli) error {
+		log := cmd.NewLogger()
+		log.PrintBanner()
+		fmt.Println()
+		log.YellowUnderline(app.config.Title + " - Debug Build")
+		return nil
+	})
+
+	return result
+}

app_config.go

@@ -0,0 +1,99 @@
+package wails
+
+import (
+	"strings"
+
+	"github.com/dchest/htmlmin"
+	"github.com/gobuffalo/packr"
+)
+
+var assets = packr.NewBox("./assets/default")
+
+// AppConfig is the configuration structure used when creating a Wails App object
+type AppConfig struct {
+	Width, Height    int
+	Title            string
+	defaultHTML      string
+	HTML             string
+	JS               string
+	CSS              string
+	Colour           string
+	Resizable        bool
+	DisableInspector bool
+	isHTMLFragment   bool
+}
+
+func (a *AppConfig) merge(in *AppConfig) error {
+	if in.CSS != "" {
+		a.CSS = in.CSS
+	}
+	if in.Title != "" {
+		a.Title = in.Title
+	}
+	if in.HTML != "" {
+		minified, err := htmlmin.Minify([]byte(in.HTML), &htmlmin.Options{
+			MinifyScripts: true,
+		})
+		if err != nil {
+			return err
+		}
+		inlineHTML := string(minified)
+		inlineHTML = strings.Replace(inlineHTML, "'", "\\'", -1)
+		inlineHTML = strings.Replace(inlineHTML, "\n", " ", -1)
+		a.HTML = strings.TrimSpace(inlineHTML)
+
+		// Deduce whether this is a full html page or a fragment
+		// The document is determined to be a fragment if an HMTL
+		// tag exists and is located before the first div tag
+		HTMLTagIndex := strings.Index(a.HTML, "<html")
+		DivTagIndex := strings.Index(a.HTML, "<div")
+
+		if HTMLTagIndex == -1 {
+			a.isHTMLFragment = true
+		} else {
+			if DivTagIndex < HTMLTagIndex {
+				a.isHTMLFragment = true
+			}
+		}
+	}
+
+	if in.Colour != "" {
+		a.Colour = in.Colour
+	}
+
+	if in.JS != "" {
+		a.JS = in.JS
+	}
+
+	if in.Width != 0 {
+		a.Width = in.Width
+	}
+	if in.Height != 0 {
+		a.Height = in.Height
+	}
+	a.Resizable = in.Resizable
+	a.DisableInspector = in.DisableInspector
+
+	return nil
+}
+
+// Creates the default configuration
+func newAppConfig(userConfig *AppConfig) (*AppConfig, error) {
+	result := &AppConfig{
+		Width:     800,
+		Height:    600,
+		Resizable: true,
+		Title:     "My Wails App",
+		Colour:    "#FFF", // White by default
+		HTML:      BoxString(&defaultAssets, "default.html"),
+	}
+
+	if userConfig != nil {
+		err := result.merge(userConfig)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return result, nil
+}

assets/default/default.html

@@ -0,0 +1 @@
+<div id="app"></div>

assets/default/wails.js

@@ -0,0 +1,337 @@
+// Wails runtime JS
+
+(function () {
+	window.wails = window.wails || {};
+	window.backend = {};
+
+	/****************** Utility Functions ************************/
+
+	// -------------- Random --------------
+	// AwesomeRandom
+	function cryptoRandom() {
+		var array = new Uint32Array(1);
+		return window.crypto.getRandomValues(array)[0];
+	}
+
+	// LOLRandom
+	function basicRandom() {
+		return Math.random() * 9007199254740991;
+	}
+
+	// Pick one based on browser capability
+	var randomFunc;
+	if (window.crypto) {
+		randomFunc = cryptoRandom;
+	} else {
+		randomFunc = basicRandom;
+	}
+
+	// -------------- Identifiers ---------------
+
+	function isValidIdentifier(name) {
+		// Don't xss yourself :-)
+		try {
+			new Function("var " + name);
+			return true
+		} catch (e) {
+			return false
+		}
+	}
+
+	// -------------- JS ----------------
+	function addScript(js, callbackID) {
+		var script = document.createElement("script");
+		script.text = js;
+		document.body.appendChild(script);
+		window.wails.events.emit(callbackID);
+	}
+
+	// -------------- CSS ---------------
+	// 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)
+	}
+
+	/************************* Bindings *************************/
+
+	var bindingsBasePath = window.backend;
+
+	// Creates the path given in the bindings path
+	function addBindingPath(pathSections) {
+		// Start at the base path
+		var currentPath = bindingsBasePath
+		// for each section of the given path
+		for (var section of pathSections) {
+
+			// Is section a valid javascript identifier?
+			if (!isValidIdentifier(section)) {
+				var errMessage = section + " is not a valid javascript identifier."
+				var err = new Error(errMessage)
+				return [null, err]
+			}
+
+			// Add if doesn't exist
+			if (!currentPath[section]) {
+				currentPath[section] = {}
+			}
+			// update current path to new path
+			currentPath = currentPath[section]
+		}
+		return [currentPath, null]
+	}
+
+	function newBinding(bindingName) {
+
+		// Get all the sections of the binding
+		var bindingSections = bindingName.split('.').splice(1);
+
+		// Get the actual function/method call name
+		var callName = bindingSections.pop();
+
+		let pathToBinding;
+		let err;
+
+		// Add path to binding
+		[pathToBinding, err] = addBindingPath(bindingSections)
+
+		if (err != null) {
+			// We need to return an error
+			return err
+		}
+
+		// Add binding call
+		pathToBinding[callName] = function () {
+
+			// No timeout by default
+			var timeout = 0;
+
+			// Actual function
+			function dynamic() {
+				var args = [].slice.call(arguments)
+				return call(bindingName, 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;
+		}();
+	}
+
+	/************************************************************/
+
+	/*************************** Calls **************************/
+
+	var callbacks = {};
+
+	// 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.
+
+	function call(bindingName, data, 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 = bindingName + "-" + randomFunc();
+			} while (callbacks[callbackID])
+
+			// Set timeout
+			if (timeout > 0) {
+				var timeoutHandle = setTimeout(function () {
+					reject(Error("Call to " + bindingName + " timed out. Request ID: " + callbackID))
+				}, timeout);
+			}
+
+			// Store callback
+			callbacks[callbackID] = {
+				timeoutHandle: timeoutHandle,
+				reject: reject,
+				resolve: resolve
+			}
+			try {
+				var payloaddata = JSON.stringify(data)
+				// Create the message
+				message = {
+					type: "call",
+					callbackid: callbackID,
+					payload: {
+						bindingName: bindingName,
+						data: payloaddata,
+					}
+				}
+
+				// Make the call
+				var payload = JSON.stringify(message)
+				external.invoke(payload);
+			} catch (e) {
+				console.error(e)
+			}
+		})
+	}
+
+
+	// Called by the backend to return data to a previously called
+	// binding invocation
+	function callback(incomingMessage) {
+		// Parse the message
+		var message
+		try {
+			message = JSON.parse(incomingMessage)
+		} catch (e) {
+			wails.log.debug("Invalid JSON passed to callback: " + e.message)
+			wails.log.debug("Message: " + incomingMessage)
+			return
+		}
+		callbackID = message.callbackid
+		callbackData = callbacks[callbackID]
+		if (!callbackData) {
+			console.error("Callback '" + callbackID + "' not registed!!!")
+			return
+		}
+		clearTimeout(callbackData.timeoutHandle)
+		delete callbacks[callbackID]
+		if (message.error) {
+			return callbackData.reject(message.error)
+		}
+		return callbackData.resolve(message.data)
+	}
+
+	/************************************************************/
+
+
+	/************************** Events **************************/
+
+	var eventListeners = {};
+
+	// Registers event listeners
+	function on(eventName, callback) {
+		eventListeners[eventName] = eventListeners[eventName] || [];
+		eventListeners[eventName].push(callback);
+	}
+
+	// notify informs frontend listeners that an event was emitted with the given data
+	function notify(eventName, data) {
+		if (eventListeners[eventName]) {
+			eventListeners[eventName].forEach(element => {
+				var parsedData = []
+				// Parse data if we have it
+				if (data) {
+					try {
+						parsedData = JSON.parse(data);
+					} catch (e) {
+						wails.log.error("Invalid JSON data sent to notify. Event name = " + eventName)
+					}
+				}
+				element.apply(null, parsedData);
+			});
+		}
+	}
+
+	// emit an event with the given name and data
+	function emit(eventName) {
+
+		// Calculate the data
+		var data = JSON.stringify([].slice.apply(arguments).slice(1));
+
+		// Notify backend
+		message = {
+			type: "event",
+			payload: {
+				name: eventName,
+				data: data,
+			}
+		}
+		external.invoke(JSON.stringify(message));
+	}
+
+	// Events calls
+	window.wails.events = { emit: emit, on: on };
+
+	/************************************************************/
+
+	/************************* Logging **************************/
+
+	// Sends a log message to the backend with the given
+	// level + message
+	function sendLogMessage(level, message) {
+
+		// Log Message
+		message = {
+			type: "log",
+			payload: {
+				level: level,
+				message: message,
+			}
+		}
+		external.invoke(JSON.stringify(message));
+	}
+
+	function logDebug(message) {
+		sendLogMessage("debug", message);
+	}
+	function logInfo(message) {
+		sendLogMessage("info", message);
+	}
+	function logWarning(message) {
+		sendLogMessage("warning", message);
+	}
+	function logError(message) {
+		sendLogMessage("error", message);
+	}
+	function logFatal(message) {
+		sendLogMessage("fatal", message);
+	}
+
+	window.wails.log = {
+		debug: logDebug,
+		info: logInfo,
+		warning: logWarning,
+		error: logError,
+		fatal: logFatal,
+	};
+
+	/************************** Exports *************************/
+
+	window.wails._ = {
+		newBinding: newBinding,
+		callback: callback,
+		notify: notify,
+		sendLogMessage: sendLogMessage,
+		callbacks: callbacks,
+		injectCSS: injectCSS,
+		addScript: addScript,
+	}
+
+	/************************************************************/
+
+	// Notify backend that the runtime has finished loading
+	window.wails.events.emit("wails:loaded");
+
+})()

assets/default/wailsbridge.js

@@ -0,0 +1,214 @@
+/*
+    Wails Bridge (c) 2019-present Lea Anthony
+
+    This library creates a bridge between your application
+    and the frontend, allowing you to develop your app using 
+    standard tooling (browser extensions, live reload, etc). 
+
+    Usage:
+    ```
+    import Bridge from "./wailsbridge";
+    Bridge.Start(startApp);
+    ```
+
+    The given callback (startApp in the example) will be called
+    when the bridge has successfully initialised. It passes the
+    window.wails object back, in case it is not accessible directly.
+*/
+
+// Bridge object
+window.wailsbridge = {
+  reconnectOverlay: null,
+  reconnectTimer: 300,
+  wsURL: "ws://localhost:34115/bridge",
+  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) {
+    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";
+  }
+
+  // Bridge external.invoke
+  window.external = {
+    invoke: function(msg) {
+      window.wailsbridge.websocket.send(msg);
+    }
+  };
+
+  // Adds a script to the Dom.
+  // Removes it if second parameter is true.
+  function addScript(script, remove) {
+    var s = document.createElement("script");
+    s.textContent = script;
+    document.head.appendChild(s);
+
+    // Remove internal messages from the DOM
+    if (remove) {
+      s.parentNode.removeChild(s);
+    }
+  }
+
+  // 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) {
+    // As a bridge we ignore js and css injections
+
+    switch (message.data[0]) {
+      // Wails library - inject!
+      case "w":
+        addScript(message.data.slice(1));
+
+        // Now wails runtime is loaded, wails for the ready event
+        // and callback to the main app
+        window.wails.events.on("wails:loaded", function() {
+          window.wailsbridge.log("Wails Ready");
+          if (window.wailsbridge.callback) {
+            window.wailsbridge.log("Notifying application");
+            window.wailsbridge.callback(window.wails);
+          }
+        });
+        window.wailsbridge.log("Loaded Wails Runtime");
+        break;
+      // Notifications
+      case "n":
+        addScript(message.data.slice(1), true);
+        break;
+      // Binding
+      case "b":
+        var binding = message.data.slice(1);
+        //log("Binding: " + binding)
+        window.wails._.newBinding(binding);
+        break;
+      // Call back
+      case "c":
+        var callbackData = message.data.slice(1);
+        log("Callback = " + callbackData);
+        window.wails._.callback(callbackData);
+        break;
+    }
+  }
+
+  // Start by showing the overlay...
+  showReconnectOverlay();
+
+  // ...and attempt to connect
+  connect();
+}
+
+export default {
+  // The main function
+  // Passes the main Wails object to the callback if given.
+  Start: function(callback) {
+    // Save the callback
+    window.wailsbridge.callback = callback;
+
+    // Start Bridge
+    startBridge();
+  }
+};

assets/default/wailsbridge.prod.js

@@ -0,0 +1,17 @@
+/*
+    Wails Bridge (c) 2019-present Lea Anthony
+
+    This prod version is to get around having to rewrite your code
+    for production. When doing a release build, this file will be used 
+    instead of the full version.
+*/
+
+export default {
+  // The main function
+  // Passes the main Wails object to the callback if given.
+  Start: function(callback) {
+    if (callback) {
+      callback();
+    }
+  }
+};

binding_function.go

@@ -0,0 +1,160 @@
+package wails
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"runtime"
+)
+
+type boundFunction struct {
+	fullName           string
+	function           reflect.Value
+	functionType       reflect.Type
+	inputs             []reflect.Type
+	returnTypes        []reflect.Type
+	log                *CustomLogger
+	hasErrorReturnType bool
+}
+
+// Creates a new bound function based on the given method + type
+func newBoundFunction(object interface{}) (*boundFunction, error) {
+
+	objectValue := reflect.ValueOf(object)
+	objectType := reflect.TypeOf(object)
+
+	name := runtime.FuncForPC(objectValue.Pointer()).Name()
+
+	result := &boundFunction{
+		fullName:     name,
+		function:     objectValue,
+		functionType: objectType,
+		log:          newCustomLogger(name),
+	}
+
+	err := result.processParameters()
+
+	return result, err
+}
+
+func (b *boundFunction) processParameters() error {
+
+	// Param processing
+	functionType := b.functionType
+
+	// Input parameters
+	inputParamCount := functionType.NumIn()
+	if inputParamCount > 0 {
+		b.inputs = make([]reflect.Type, inputParamCount)
+		// We start at 1 as the first param is the struct
+		for index := 0; index < inputParamCount; index++ {
+			param := functionType.In(index)
+			name := param.Name()
+			kind := param.Kind()
+			b.inputs[index] = param
+			typ := param
+			index := index
+			b.log.DebugFields("Input param", Fields{
+				"index": index,
+				"name":  name,
+				"kind":  kind,
+				"typ":   typ,
+			})
+		}
+	}
+
+	// Process return/output declarations
+	returnParamsCount := functionType.NumOut()
+	// Guard against bad number of return types
+	switch returnParamsCount {
+	case 0:
+	case 1:
+		// Check if it's an error type
+		param := functionType.Out(0)
+		paramName := param.Name()
+		if paramName == "error" {
+			b.hasErrorReturnType = true
+		}
+		// Save return type
+		b.returnTypes = append(b.returnTypes, param)
+	case 2:
+		// Check the second return type is an error
+		secondParam := functionType.Out(1)
+		secondParamName := secondParam.Name()
+		if secondParamName != "error" {
+			return fmt.Errorf("last return type of method '%s' must be an error (got %s)", b.fullName, secondParamName)
+		}
+
+		// Check the second return type is an error
+		firstParam := functionType.Out(0)
+		firstParamName := firstParam.Name()
+		if firstParamName == "error" {
+			return fmt.Errorf("first return type of method '%s' must not be an error", b.fullName)
+		}
+		b.hasErrorReturnType = true
+
+		// Save return types
+		b.returnTypes = append(b.returnTypes, firstParam)
+		b.returnTypes = append(b.returnTypes, secondParam)
+
+	default:
+		return fmt.Errorf("cannot register method '%s' with %d return parameters. Please use up to 2", b.fullName, returnParamsCount)
+	}
+
+	return nil
+}
+
+// call the method with the given data
+func (b *boundFunction) call(data string) ([]reflect.Value, error) {
+
+	// The data will be an array of values so we will decode the
+	// input data into
+	var jsArgs []interface{}
+	d := json.NewDecoder(bytes.NewBufferString(data))
+	// d.UseNumber()
+	err := d.Decode(&jsArgs)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid data passed to method call: %s", err.Error())
+	}
+
+	// Check correct number of inputs
+	if len(jsArgs) != len(b.inputs) {
+		return nil, fmt.Errorf("Invalid number of parameters given to %s. Expected %d but got %d", b.fullName, len(b.inputs), len(jsArgs))
+	}
+
+	// Set up call
+	args := make([]reflect.Value, len(b.inputs))
+	for index := 0; index < len(b.inputs); index++ {
+
+		// Set the input values
+		value, err := b.setInputValue(index, b.inputs[index], jsArgs[index])
+		if err != nil {
+			return nil, err
+		}
+		args[index] = value
+	}
+	b.log.Debugf("Unmarshalled Args: %+v\n", jsArgs)
+	b.log.Debugf("Converted Args: %+v\n", args)
+	results := b.function.Call(args)
+
+	b.log.Debugf("results = %+v", results)
+	return results, nil
+}
+
+// Attempts to set the method input <typ> for parameter <index> with the given value <val>
+func (b *boundFunction) setInputValue(index int, typ reflect.Type, val interface{}) (result reflect.Value, err error) {
+
+	// Catch type conversion panics thrown by convert
+	defer func() {
+		if r := recover(); r != nil {
+			// Modify error
+			err = fmt.Errorf("%s for parameter %d of function %s", r.(string)[23:], index+1, b.fullName)
+		}
+	}()
+
+	// Do the conversion
+	result = reflect.ValueOf(val).Convert(typ)
+
+	return result, err
+}

binding_manager.go

@@ -0,0 +1,282 @@
+package wails
+
+import (
+	"fmt"
+	"reflect"
+	"unicode"
+)
+
+/**
+
+binding:
+ Name() // Full name (package+name)
+ Call(params)
+
+**/
+
+type bindingManager struct {
+	methods          map[string]*boundMethod
+	functions        map[string]*boundFunction
+	initMethods      []*boundMethod
+	log              *CustomLogger
+	renderer         Renderer
+	runtime          *Runtime // The runtime object to pass to bound structs
+	objectsToBind    []interface{}
+	bindPackageNames bool // Package name should be considered when binding
+}
+
+func newBindingManager() *bindingManager {
+	result := &bindingManager{
+		methods:   make(map[string]*boundMethod),
+		functions: make(map[string]*boundFunction),
+		log:       newCustomLogger("Bind"),
+	}
+	return result
+}
+
+// Sets flag to indicate package names should be considered when binding
+func (b *bindingManager) BindPackageNames() {
+	b.bindPackageNames = true
+}
+
+func (b *bindingManager) start(renderer Renderer, runtime *Runtime) error {
+	b.log.Info("Starting")
+	b.renderer = renderer
+	b.runtime = runtime
+	err := b.initialise()
+	if err != nil {
+		b.log.Errorf("Binding error: %s", err.Error())
+		return err
+	}
+	err = b.callWailsInitMethods()
+	return err
+}
+
+func (b *bindingManager) initialise() error {
+
+	var err error
+	// var binding *boundMethod
+
+	b.log.Info("Binding Go Functions/Methods")
+
+	// Create bindings for objects
+	for _, object := range b.objectsToBind {
+
+		// Safeguard against nils
+		if object == nil {
+			return fmt.Errorf("attempted to bind nil object")
+		}
+
+		// Determine kind of object
+		objectType := reflect.TypeOf(object)
+		objectKind := objectType.Kind()
+
+		switch objectKind {
+		case reflect.Ptr:
+			err = b.bindMethod(object)
+		case reflect.Func:
+			// spew.Dump(result.objectType.String())
+			err = b.bindFunction(object)
+		default:
+			err = fmt.Errorf("cannot bind object of type '%s'", objectKind.String())
+		}
+
+		// Return error if set
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// bind the given struct method
+func (b *bindingManager) bindMethod(object interface{}) error {
+
+	objectType := reflect.TypeOf(object)
+	baseName := objectType.String()
+
+	// Strip pointer if there
+	if baseName[0] == '*' {
+		baseName = baseName[1:]
+	}
+
+	b.log.Debugf("Processing struct: %s", baseName)
+
+	// Iterate over method definitions
+	for i := 0; i < objectType.NumMethod(); i++ {
+
+		// Get method definition
+		methodDef := objectType.Method(i)
+		methodName := methodDef.Name
+		fullMethodName := baseName + "." + methodName
+		method := reflect.ValueOf(object).MethodByName(methodName)
+
+		// Skip unexported methods
+		if !unicode.IsUpper([]rune(methodName)[0]) {
+			continue
+		}
+
+		// Create a new boundMethod
+		newMethod, err := newBoundMethod(methodName, fullMethodName, method, objectType)
+		if err != nil {
+			return err
+		}
+
+		// Check if it's a wails init function
+		if newMethod.isWailsInit {
+			b.log.Debugf("Detected WailsInit function: %s", fullMethodName)
+			b.initMethods = append(b.initMethods, newMethod)
+		} else {
+			// Save boundMethod
+			b.log.Infof("Bound Method: %s()", fullMethodName)
+			b.methods[fullMethodName] = newMethod
+
+			// Inform renderer of new binding
+			b.renderer.NewBinding(fullMethodName)
+		}
+	}
+
+	return nil
+}
+
+// bind the given function object
+func (b *bindingManager) bindFunction(object interface{}) error {
+
+	newFunction, err := newBoundFunction(object)
+	if err != nil {
+		return err
+	}
+
+	// Save method
+	b.log.Infof("Bound Function: %s()", newFunction.fullName)
+	b.functions[newFunction.fullName] = newFunction
+
+	// Register with Renderer
+	b.renderer.NewBinding(newFunction.fullName)
+
+	return nil
+}
+
+// Save the given object to be bound at start time
+func (b *bindingManager) bind(object interface{}) {
+	// Store binding
+	b.objectsToBind = append(b.objectsToBind, object)
+}
+
+func (b *bindingManager) processFunctionCall(callData *callData) (interface{}, error) {
+	// Return values
+	var result []reflect.Value
+	var err error
+
+	function := b.functions[callData.BindingName]
+	if function == nil {
+		return nil, fmt.Errorf("Invalid function name '%s'", callData.BindingName)
+	}
+	result, err = function.call(callData.Data)
+	if err != nil {
+		return nil, err
+	}
+
+	// Do we have an error return type?
+	if function.hasErrorReturnType {
+		// We do - last result is an error type
+		// Check if the last result was nil
+		b.log.Debugf("# of return types: %d", len(function.returnTypes))
+		b.log.Debugf("# of results: %d", len(result))
+		errorResult := result[len(function.returnTypes)-1]
+		if !errorResult.IsNil() {
+			// It wasn't - we have an error
+			return nil, errorResult.Interface().(error)
+		}
+	}
+	return result[0].Interface(), nil
+}
+
+func (b *bindingManager) processMethodCall(callData *callData) (interface{}, error) {
+	// Return values
+	var result []reflect.Value
+	var err error
+
+	// do we have this method?
+	method := b.methods[callData.BindingName]
+	if method == nil {
+		return nil, fmt.Errorf("Invalid method name '%s'", callData.BindingName)
+	}
+
+	result, err = method.call(callData.Data)
+	if err != nil {
+		return nil, err
+	}
+
+	// Do we have an error return type?
+	if method.hasErrorReturnType {
+		// We do - last result is an error type
+		// Check if the last result was nil
+		b.log.Debugf("# of return types: %d", len(method.returnTypes))
+		b.log.Debugf("# of results: %d", len(result))
+		errorResult := result[len(method.returnTypes)-1]
+		if !errorResult.IsNil() {
+			// It wasn't - we have an error
+			return nil, errorResult.Interface().(error)
+		}
+	}
+	if result != nil {
+		return result[0].Interface(), nil
+	}
+	return nil, nil
+}
+
+// process an incoming call request
+func (b *bindingManager) processCall(callData *callData) (result interface{}, err error) {
+	b.log.Debugf("Wanting to call %s", callData.BindingName)
+
+	// Determine if this is function call or method call by the number of
+	// dots in the binding name
+	dotCount := 0
+	for _, character := range callData.BindingName {
+		if character == '.' {
+			dotCount++
+		}
+	}
+
+	// We need to catch reflect related panics and return
+	// a decent error message
+	// TODO: DEBUG THIS!
+
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("%s", r.(string))
+		}
+	}()
+
+	switch dotCount {
+	case 1:
+		result, err = b.processFunctionCall(callData)
+	case 2:
+		result, err = b.processMethodCall(callData)
+	default:
+		result = nil
+		err = fmt.Errorf("Invalid binding name '%s'", callData.BindingName)
+	}
+	return
+}
+
+// callWailsInitMethods calls all of the WailsInit methods that were
+// registered with the runtime object
+func (b *bindingManager) callWailsInitMethods() error {
+	// Create reflect value for runtime object
+	runtimeValue := reflect.ValueOf(b.runtime)
+	params := []reflect.Value{runtimeValue}
+
+	// Iterate initMethods
+	for _, initMethod := range b.initMethods {
+		// Call
+		result := initMethod.method.Call(params)
+		// Check errors
+		err := result[0].Interface()
+		if err != nil {
+			return err.(error)
+		}
+	}
+	return nil
+}

binding_method.go

@@ -0,0 +1,211 @@
+package wails
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+)
+
+type boundMethod struct {
+	Name               string
+	fullName           string
+	method             reflect.Value
+	inputs             []reflect.Type
+	returnTypes        []reflect.Type
+	log                *CustomLogger
+	hasErrorReturnType bool // Indicates if there is an error return type
+	isWailsInit        bool
+}
+
+// Creates a new bound method based on the given method + type
+func newBoundMethod(name string, fullName string, method reflect.Value, objectType reflect.Type) (*boundMethod, error) {
+	result := &boundMethod{
+		Name:     name,
+		method:   method,
+		fullName: fullName,
+	}
+
+	// Setup logger
+	result.log = newCustomLogger(result.fullName)
+
+	// Check if Parameters are valid
+	err := result.processParameters()
+
+	// Are we a WailsInit method?
+	if result.Name == "WailsInit" {
+		err = result.processWailsInit()
+	}
+
+	return result, err
+}
+
+func (b *boundMethod) processParameters() error {
+
+	// Param processing
+	methodType := b.method.Type()
+
+	// Input parameters
+	inputParamCount := methodType.NumIn()
+	if inputParamCount > 0 {
+		b.inputs = make([]reflect.Type, inputParamCount)
+		// We start at 1 as the first param is the struct
+		for index := 0; index < inputParamCount; index++ {
+			param := methodType.In(index)
+			name := param.Name()
+			kind := param.Kind()
+			b.inputs[index] = param
+			typ := param
+			index := index
+			b.log.DebugFields("Input param", Fields{
+				"index": index,
+				"name":  name,
+				"kind":  kind,
+				"typ":   typ,
+			})
+		}
+	}
+
+	// Process return/output declarations
+	returnParamsCount := methodType.NumOut()
+	// Guard against bad number of return types
+	switch returnParamsCount {
+	case 0:
+	case 1:
+		// Check if it's an error type
+		param := methodType.Out(0)
+		paramName := param.Name()
+		if paramName == "error" {
+			b.hasErrorReturnType = true
+		}
+		// Save return type
+		b.returnTypes = append(b.returnTypes, param)
+	case 2:
+		// Check the second return type is an error
+		secondParam := methodType.Out(1)
+		secondParamName := secondParam.Name()
+		if secondParamName != "error" {
+			return fmt.Errorf("last return type of method '%s' must be an error (got %s)", b.Name, secondParamName)
+		}
+
+		// Check the second return type is an error
+		firstParam := methodType.Out(0)
+		firstParamName := firstParam.Name()
+		if firstParamName == "error" {
+			return fmt.Errorf("first return type of method '%s' must not be an error", b.Name)
+		}
+		b.hasErrorReturnType = true
+
+		// Save return types
+		b.returnTypes = append(b.returnTypes, firstParam)
+		b.returnTypes = append(b.returnTypes, secondParam)
+
+	default:
+		return fmt.Errorf("cannot register method '%s' with %d return parameters. Please use up to 2", b.Name, returnParamsCount)
+	}
+
+	return nil
+}
+
+// call the method with the given data
+func (b *boundMethod) call(data string) ([]reflect.Value, error) {
+
+	// The data will be an array of values so we will decode the
+	// input data into
+	var jsArgs []interface{}
+	d := json.NewDecoder(bytes.NewBufferString(data))
+	// d.UseNumber()
+	err := d.Decode(&jsArgs)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid data passed to method call: %s", err.Error())
+	}
+
+	// Check correct number of inputs
+	if len(jsArgs) != len(b.inputs) {
+		return nil, fmt.Errorf("Invalid number of parameters given to %s. Expected %d but got %d", b.fullName, len(b.inputs), len(jsArgs))
+	}
+
+	// Set up call
+	args := make([]reflect.Value, len(b.inputs))
+	for index := 0; index < len(b.inputs); index++ {
+
+		// Set the input values
+		value, err := b.setInputValue(index, b.inputs[index], jsArgs[index])
+		if err != nil {
+			return nil, err
+		}
+		args[index] = value
+	}
+	b.log.Debugf("Unmarshalled Args: %+v\n", jsArgs)
+	b.log.Debugf("Converted Args: %+v\n", args)
+	results := b.method.Call(args)
+
+	b.log.Debugf("results = %+v", results)
+	return results, nil
+}
+
+// Attempts to set the method input <typ> for parameter <index> with the given value <val>
+func (b *boundMethod) setInputValue(index int, typ reflect.Type, val interface{}) (result reflect.Value, err error) {
+
+	// Catch type conversion panics thrown by convert
+	defer func() {
+		if r := recover(); r != nil {
+			// Modify error
+			fmt.Printf("Recovery message: %+v\n", r)
+			err = fmt.Errorf("%s for parameter %d of method %s", r.(string)[23:], index+1, b.fullName)
+		}
+	}()
+
+	// Do the conversion
+	// Handle nil values
+	if val == nil {
+		switch typ.Kind() {
+		case reflect.Chan,
+			reflect.Func,
+			reflect.Interface,
+			reflect.Map,
+			reflect.Ptr,
+			reflect.Slice:
+			logger.Debug("Converting nil to type")
+			result = reflect.ValueOf(val).Convert(typ)
+		default:
+			logger.Debug("Cannot convert nil to type, returning error")
+			return reflect.Zero(typ), fmt.Errorf("Unable to use null value for parameter %d of method %s", index+1, b.fullName)
+		}
+	} else {
+		result = reflect.ValueOf(val).Convert(typ)
+	}
+
+	return result, err
+}
+
+func (b *boundMethod) processWailsInit() error {
+	// We must have only 1 input, it must be *wails.Runtime
+	if len(b.inputs) != 1 {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected 1 input, but got %d", len(b.inputs))
+	}
+
+	// It must be *wails.Runtime
+	inputName := b.inputs[0].String()
+	b.log.Debugf("WailsInit input type: %s", inputName)
+	if inputName != "*wails.Runtime" {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected input to be wails.Runtime, but got %s", inputName)
+	}
+
+	// We must have only 1 output, it must be error
+	if len(b.returnTypes) != 1 {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected 1 return type, but got %d", len(b.returnTypes))
+	}
+
+	// It must be *wails.Runtime
+	outputName := b.returnTypes[0].String()
+	b.log.Debugf("WailsInit output type: %s", outputName)
+	if outputName != "error" {
+		return fmt.Errorf("Invalid WailsInit() definition. Expected input to be error, but got %s", outputName)
+	}
+
+	// We are indeed a wails Init method
+	b.isWailsInit = true
+
+	return nil
+}

cmd/cli.go

@@ -105,6 +105,7 @@ func NewCommand(name string, description string, app *Cli, parentCommandPath str
 		Shortdescription: description,
 		SubCommandsMap:   make(map[string]*Command),
 		App:              app,
+		log:              NewLogger(),
 	}
 
 	// Set up command path
@@ -181,6 +182,7 @@ func (c *Command) Run(args []string) error {
 
 	// Nothing left we can do
 	c.PrintHelp()
+
 	return nil
 }
 

cmd/frameworks.go

@@ -1,69 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"path"
-	"path/filepath"
-	"runtime"
-)
-
-// FrameworkMetadata contains information about a given framework
-type FrameworkMetadata struct {
-	Name        string `json:"name"`
-	BuildTag    string `json:"buildtag"`
-	Description string `json:"description"`
-}
-
-// Utility function for creating new FrameworkMetadata structs
-func loadFrameworkMetadata(pathToMetadataJSON string) (*FrameworkMetadata, error) {
-	result := &FrameworkMetadata{}
-	configData, err := ioutil.ReadFile(pathToMetadataJSON)
-	if err != nil {
-		return nil, err
-	}
-	// Load and unmarshall!
-	err = json.Unmarshal(configData, result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-// GetFrameworks returns information about all the available frameworks
-func GetFrameworks() ([]*FrameworkMetadata, error) {
-
-	var err error
-
-	// Calculate framework base dir
-	_, filename, _, _ := runtime.Caller(1)
-	frameworksBaseDir := filepath.Join(path.Dir(filename), "frameworks")
-
-	// Get the subdirectories
-	fs := NewFSHelper()
-	frameworkDirs, err := fs.GetSubdirs(frameworksBaseDir)
-	if err != nil {
-		return nil, err
-	}
-
-	// Prepare result
-	result := []*FrameworkMetadata{}
-
-	// Iterate framework directories, looking for metadata.json files
-	for _, frameworkDir := range frameworkDirs {
-		var frameworkMetadata FrameworkMetadata
-		metadataFile := filepath.Join(frameworkDir, "metadata.json")
-		jsonData, err := ioutil.ReadFile(metadataFile)
-		if err != nil {
-			return nil, err
-		}
-		err = json.Unmarshal(jsonData, &frameworkMetadata)
-		if err != nil {
-			return nil, err
-		}
-		result = append(result, &frameworkMetadata)
-	}
-
-	// Read in framework metadata
-	return result, nil
-}

cmd/frameworks/bootstrap4default.go

@@ -1,16 +0,0 @@
-// +build frameworkbootstrap4
-
-package frameworks
-
-import (
-	"github.com/gobuffalo/packr"
-)
-
-func init() {
-	assets := packr.NewBox("./bootstrap4default/assets")
-	FrameworkToUse = &Framework{
-		Name: "Bootstrap 4",
-		JS:   assets.String("bootstrap.bundle.min.js"),
-		CSS:  assets.String("bootstrap.min.css"),
-	}
-}

cmd/frameworks/bootstrap4default/main.go

@@ -1,17 +0,0 @@
-// +build frameworkbootstrap4
-
-package bootstrap4
-
-import (
-	"github.com/gobuffalo/packr"
-	"github.com/wailsapp/wails/frameworks"
-)
-
-func init() {
-	assets := packr.NewBox("./assets")
-	frameworks.FrameworkToUse = &frameworks.Framework{
-		Name: "Bootstrap 4",
-		JS:   assets.String("bootstrap.bundle.min.js"),
-		CSS:  assets.String("bootstrap.min.css"),
-	}
-}

cmd/frameworks/bootstrap4default/metadata.json

@@ -1,5 +0,0 @@
-{
-  "Name": "Bootstrap 4",
-  "Description": "Standard Bootstrap 4 with default theme",
-  "BuildTag": "frameworkbootstrap4"
-}

cmd/frameworks/bootstrap4lux.go

@@ -1,16 +0,0 @@
-// +build frameworkbootstrap4lux
-
-package frameworks
-
-import (
-	"github.com/gobuffalo/packr"
-)
-
-func init() {
-	assets := packr.NewBox("./bootstrap4lux/assets")
-	FrameworkToUse = &Framework{
-		Name: "Bootstrap 4 (Lux)",
-		JS:   assets.String("bootstrap.bundle.min.js"),
-		CSS:  assets.String("bootstrap.min.css"),
-	}
-}

cmd/frameworks/bootstrap4lux/main.go

@@ -1,17 +0,0 @@
-// +build frameworkbootstrap4lux
-
-package bootstrap4
-
-import (
-	"github.com/gobuffalo/packr"
-	"github.com/wailsapp/wails/frameworks"
-)
-
-func init() {
-	assets := packr.NewBox("./assets")
-	frameworks.FrameworkToUse = &frameworks.Framework{
-		Name: "Bootstrap 4 (Lux)",
-		JS:   assets.String("bootstrap.bundle.min.js"),
-		CSS:  assets.String("bootstrap.min.css"),
-	}
-}

cmd/frameworks/bootstrap4lux/metadata.json

@@ -1,5 +0,0 @@
-{
-  "Name": "Bootstrap 4 (Lux)",
-  "Description": "Bootstrap with Lux theme",
-  "BuildTag": "frameworkbootstrap4lux"
-}

cmd/frameworks/main.go

@@ -1,13 +0,0 @@
-package frameworks
-
-// Framework has details about a specific framework
-type Framework struct {
-	Name    string
-	JS      string
-	CSS     string
-	Options string
-}
-
-// FrameworkToUse is the framework we will use when building
-// Set by `wails init`, used by `wails build`
-var FrameworkToUse *Framework

cmd/helpers.go

@@ -0,0 +1,225 @@
+package cmd
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"runtime"
+	"time"
+
+	"github.com/leaanthony/slicer"
+	"github.com/leaanthony/spinner"
+)
+
+// ValidateFrontendConfig checks if the frontend config is valid
+func ValidateFrontendConfig(projectOptions *ProjectOptions) error {
+	if projectOptions.FrontEnd.Dir == "" {
+		return fmt.Errorf("Frontend directory not set in project.json")
+	}
+	if projectOptions.FrontEnd.Build == "" {
+		return fmt.Errorf("Frontend build command not set in project.json")
+	}
+	if projectOptions.FrontEnd.Install == "" {
+		return fmt.Errorf("Frontend install command not set in project.json")
+	}
+	if projectOptions.FrontEnd.Bridge == "" {
+		return fmt.Errorf("Frontend bridge config not set in project.json")
+	}
+
+	return nil
+}
+
+// InstallGoDependencies will run go get in the current directory
+func InstallGoDependencies() error {
+	depSpinner := spinner.New("Installing Dependencies...")
+	depSpinner.SetSpinSpeed(50)
+	depSpinner.Start()
+	err := NewProgramHelper().RunCommand("go get")
+	if err != nil {
+		depSpinner.Error()
+		return err
+	}
+	depSpinner.Success()
+	return nil
+}
+
+// BuildApplication will attempt to build the project based on the given inputs
+func BuildApplication(binaryName string, forceRebuild bool, buildMode string) error {
+	compileMessage := "Packing + Compiling project"
+	if buildMode == "debug" {
+		compileMessage += " (Debug Mode)"
+	}
+
+	packSpinner := spinner.New(compileMessage + "...")
+	packSpinner.SetSpinSpeed(50)
+	packSpinner.Start()
+
+	buildCommand := slicer.String()
+	buildCommand.AddSlice([]string{"packr", "build"})
+
+	if binaryName != "" {
+		buildCommand.Add("-o")
+		buildCommand.Add(binaryName)
+	}
+
+	// If we are forcing a rebuild
+	if forceRebuild {
+		buildCommand.Add("-a")
+	}
+
+	buildCommand.AddSlice([]string{"-ldflags", "-X github.com/wailsapp/wails.BuildMode=" + buildMode})
+	err := NewProgramHelper().RunCommandArray(buildCommand.AsSlice())
+	if err != nil {
+		packSpinner.Error()
+		return err
+	}
+	packSpinner.Success()
+	return nil
+}
+
+// PackageApplication will attempt to package the application in a pltform dependent way
+func PackageApplication(projectOptions *ProjectOptions) error {
+	// Package app
+	packageSpinner := spinner.New("Packaging Application")
+	packageSpinner.SetSpinSpeed(50)
+	packageSpinner.Start()
+	err := NewPackageHelper().Package(projectOptions)
+	if err != nil {
+		packageSpinner.Error()
+		return err
+	}
+	packageSpinner.Success()
+	return nil
+}
+
+// BuildFrontend runs the given build command
+func BuildFrontend(buildCommand string) error {
+	buildFESpinner := spinner.New("Building frontend...")
+	buildFESpinner.SetSpinSpeed(50)
+	buildFESpinner.Start()
+	err := NewProgramHelper().RunCommand(buildCommand)
+	if err != nil {
+		buildFESpinner.Error()
+		return err
+	}
+	buildFESpinner.Success()
+	return nil
+}
+
+// CheckPackr checks if packr is installed and if not, attempts to fetch it
+func CheckPackr() (err error) {
+	programHelper := NewProgramHelper()
+	if !programHelper.IsInstalled("packr") {
+		buildSpinner := spinner.New()
+		buildSpinner.SetSpinSpeed(50)
+		buildSpinner.Start("Installing packr...")
+		err := programHelper.InstallGoPackage("github.com/gobuffalo/packr/...")
+		if err != nil {
+			buildSpinner.Error()
+			return err
+		}
+		buildSpinner.Success()
+	}
+	return nil
+}
+
+// InstallFrontendDeps attempts to install the frontend dependencies based on the given options
+func InstallFrontendDeps(projectDir string, projectOptions *ProjectOptions, forceRebuild bool) error {
+
+	// Install frontend deps
+	err := os.Chdir(projectOptions.FrontEnd.Dir)
+	if err != nil {
+		return err
+	}
+
+	// Check if frontend deps have been updated
+	feSpinner := spinner.New("Installing frontend dependencies (This may take a while)...")
+	feSpinner.SetSpinSpeed(50)
+	feSpinner.Start()
+
+	requiresNPMInstall := true
+
+	// Read in package.json MD5
+	fs := NewFSHelper()
+	packageJSONMD5, err := fs.FileMD5("package.json")
+	if err != nil {
+		return err
+	}
+
+	const md5sumFile = "package.json.md5"
+
+	// If we aren't forcing the install and the md5sum file exists
+	if !forceRebuild && fs.FileExists(md5sumFile) {
+		// Yes - read contents
+		savedMD5sum, err := fs.LoadAsString(md5sumFile)
+		// File exists
+		if err == nil {
+			// Compare md5
+			if savedMD5sum == packageJSONMD5 {
+				// Same - no need for reinstall
+				requiresNPMInstall = false
+				feSpinner.Success("Skipped frontend dependencies (-f to force rebuild)")
+			}
+		}
+	}
+
+	// Md5 sum package.json
+	// Different? Build
+	if requiresNPMInstall || forceRebuild {
+		// Install dependencies
+		err = NewProgramHelper().RunCommand(projectOptions.FrontEnd.Install)
+		if err != nil {
+			feSpinner.Error()
+			return err
+		}
+		feSpinner.Success()
+
+		// Update md5sum file
+		ioutil.WriteFile(md5sumFile, []byte(packageJSONMD5), 0644)
+	}
+
+	bridgeFile := "wailsbridge.prod.js"
+
+	// Copy bridge to project
+	_, filename, _, _ := runtime.Caller(1)
+	bridgeFileSource := filepath.Join(path.Dir(filename), "..", "..", "assets", "default", bridgeFile)
+	bridgeFileTarget := filepath.Join(projectDir, projectOptions.FrontEnd.Dir, projectOptions.FrontEnd.Bridge, "wailsbridge.js")
+	err = fs.CopyFile(bridgeFileSource, bridgeFileTarget)
+	if err != nil {
+		return err
+	}
+
+	// Build frontend
+	err = BuildFrontend(projectOptions.FrontEnd.Build)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// ServeProject attempts to serve up the current project so that it may be connected to
+// via the Wails bridge
+func ServeProject(projectOptions *ProjectOptions, logger *Logger) error {
+	go func() {
+		time.Sleep(2 * time.Second)
+		logger.Green(">>>>> To connect, you will need to run '" + projectOptions.FrontEnd.Serve + "' in the '" + projectOptions.FrontEnd.Dir + "' directory <<<<<")
+	}()
+	location, err := filepath.Abs(projectOptions.BinaryName)
+	if err != nil {
+		return err
+	}
+
+	logger.Yellow("Serving Application: " + location)
+	cmd := exec.Command(location)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err = cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

cmd/log.go

@@ -9,52 +9,89 @@ import (
 
 // Logger struct
 type Logger struct {
+	errorOnly bool
 }
 
 // NewLogger creates a new logger!
 func NewLogger() *Logger {
-	return &Logger{}
+	return &Logger{errorOnly: false}
+}
+
+// SetErrorOnly onyl outputs messages if they are an error
+func (l *Logger) SetErrorOnly(errorOnly bool) {
+	l.errorOnly = errorOnly
 }
 
 // Yellow - Outputs yellow text
 func (l *Logger) Yellow(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
 	color.New(color.FgHiYellow).PrintfFunc()(format+"\n", a...)
 }
 
 // Yellowf - Outputs yellow text without the newline
 func (l *Logger) Yellowf(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
+
 	color.New(color.FgHiYellow).PrintfFunc()(format, a...)
 }
 
 // Green - Outputs Green text
 func (l *Logger) Green(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
+
 	color.New(color.FgHiGreen).PrintfFunc()(format+"\n", a...)
 }
 
 // White - Outputs White text
 func (l *Logger) White(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
+
 	color.New(color.FgHiWhite).PrintfFunc()(format+"\n", a...)
 }
 
 // WhiteUnderline - Outputs White text with underline
 func (l *Logger) WhiteUnderline(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
+
 	l.White(format, a...)
 	l.White(l.underline(format))
 }
 
 // YellowUnderline - Outputs Yellow text with underline
 func (l *Logger) YellowUnderline(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
+
 	l.Yellow(format, a...)
 	l.Yellow(l.underline(format))
 }
 
 // underline returns a string of a line, the length of the message given to it
 func (l *Logger) underline(message string) string {
+	if l.errorOnly {
+		return ""
+	}
+
 	return strings.Repeat("-", len(message))
 }
 
 // Red - Outputs Red text
 func (l *Logger) Red(format string, a ...interface{}) {
+	if l.errorOnly {
+		return
+	}
+
 	color.New(color.FgHiRed).PrintfFunc()(format+"\n", a...)
 }
 

cmd/package.go

@@ -0,0 +1,197 @@
+package cmd
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/jackmordaunt/icns"
+)
+
+// PackageHelper helps with the 'wails package' command
+type PackageHelper struct {
+	fs     *FSHelper
+	log    *Logger
+	system *SystemHelper
+}
+
+// NewPackageHelper creates a new PackageHelper!
+func NewPackageHelper() *PackageHelper {
+	return &PackageHelper{
+		fs:     NewFSHelper(),
+		log:    NewLogger(),
+		system: NewSystemHelper(),
+	}
+}
+
+type plistData struct {
+	Title     string
+	Exe       string
+	PackageID string
+	Version   string
+	Author    string
+	Date      string
+}
+
+func newPlistData(title, exe, packageID, version, author string) *plistData {
+	now := time.Now().Format(time.RFC822)
+	return &plistData{
+		Title:     title,
+		Exe:       exe,
+		Version:   version,
+		PackageID: packageID,
+		Author:    author,
+		Date:      now,
+	}
+}
+
+func defaultString(val string, defaultVal string) string {
+	if val != "" {
+		return val
+	}
+	return defaultVal
+}
+
+func (b *PackageHelper) getPackageFileBaseDir() string {
+	// Calculate template base dir
+	_, filename, _, _ := runtime.Caller(1)
+	return filepath.Join(path.Dir(filename), "packages", runtime.GOOS)
+}
+
+// Package the application into a platform specific package
+func (b *PackageHelper) Package(po *ProjectOptions) error {
+	// Check we have the exe
+	if !b.fs.FileExists(po.BinaryName) {
+		return fmt.Errorf("cannot bundle non-existant binary file '%s'. Please build with 'wails build' first", po.BinaryName)
+	}
+	switch runtime.GOOS {
+	case "darwin":
+		return b.packageOSX(po)
+	case "windows":
+		return fmt.Errorf("windows is not supported at this time. Please see https://github.com/wailsapp/wails/issues/3")
+	case "linux":
+		return fmt.Errorf("linux is not supported at this time. Please see https://github.com/wailsapp/wails/issues/2")
+	default:
+		return fmt.Errorf("platform '%s' not supported for bundling yet", runtime.GOOS)
+	}
+}
+
+// Package the application for OSX
+func (b *PackageHelper) packageOSX(po *ProjectOptions) error {
+
+	system := NewSystemHelper()
+	config, err := system.LoadConfig()
+	if err != nil {
+		return err
+	}
+
+	name := defaultString(po.Name, "WailsTest")
+	exe := defaultString(po.BinaryName, name)
+	version := defaultString(po.Version, "0.1.0")
+	author := defaultString(config.Name, "Anonymous")
+	packageID := strings.Join([]string{"wails", name, version}, ".")
+	plistData := newPlistData(name, exe, packageID, version, author)
+	appname := po.Name + ".app"
+
+	// Check binary exists
+	source := path.Join(b.fs.Cwd(), exe)
+	if !b.fs.FileExists(source) {
+		// We need to build!
+		return fmt.Errorf("Target '%s' not available. Has it been compiled yet?", exe)
+	}
+
+	// Remove the existing package
+	os.RemoveAll(appname)
+
+	exeDir := path.Join(b.fs.Cwd(), appname, "/Contents/MacOS")
+	b.fs.MkDirs(exeDir, 0755)
+	resourceDir := path.Join(b.fs.Cwd(), appname, "/Contents/Resources")
+	b.fs.MkDirs(resourceDir, 0755)
+	tmpl := template.New("infoPlist")
+	plistFile := filepath.Join(b.getPackageFileBaseDir(), "info.plist")
+	infoPlist, err := ioutil.ReadFile(plistFile)
+	if err != nil {
+		return err
+	}
+	tmpl.Parse(string(infoPlist))
+
+	// Write the template to a buffer
+	var tpl bytes.Buffer
+	err = tmpl.Execute(&tpl, plistData)
+	if err != nil {
+		return err
+	}
+	filename := path.Join(b.fs.Cwd(), appname, "Contents", "Info.plist")
+	err = ioutil.WriteFile(filename, tpl.Bytes(), 0644)
+	if err != nil {
+		return err
+	}
+
+	// Copy executable
+	target := path.Join(exeDir, exe)
+	err = b.fs.CopyFile(source, target)
+	if err != nil {
+		return err
+	}
+
+	err = os.Chmod(target, 0755)
+	if err != nil {
+		return err
+	}
+	err = b.packageIcon(resourceDir)
+	return err
+}
+
+func (b *PackageHelper) packageIcon(resourceDir string) error {
+
+	// TODO: Read this from project.json
+	const appIconFilename = "appicon.png"
+
+	srcIcon := path.Join(b.fs.Cwd(), appIconFilename)
+
+	// Check if appicon.png exists
+	if !b.fs.FileExists(srcIcon) {
+
+		// Install default icon
+		iconfile := filepath.Join(b.getPackageFileBaseDir(), "icon.png")
+		iconData, err := ioutil.ReadFile(iconfile)
+		if err != nil {
+			return err
+		}
+		err = ioutil.WriteFile(srcIcon, iconData, 0644)
+		if err != nil {
+			return err
+		}
+	}
+
+	tgtBundle := path.Join(resourceDir, "iconfile.icns")
+	imageFile, err := os.Open(srcIcon)
+	if err != nil {
+		return err
+	}
+	defer imageFile.Close()
+	srcImg, _, err := image.Decode(imageFile)
+	if err != nil {
+		return err
+
+	}
+	dest, err := os.Create(tgtBundle)
+	if err != nil {
+		return err
+
+	}
+	defer dest.Close()
+	if err := icns.Encode(dest, srcImg); err != nil {
+		return err
+
+	}
+	return nil
+}

cmd/packages/darwin/info.plist

@@ -0,0 +1,11 @@
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+	<key>CFBundleName</key><string>{{.Title}}</string>
+	<key>CFBundleExecutable</key><string>{{.Exe}}</string>
+	<key>CFBundleIdentifier</key><string>{{.PackageID}}</string>
+	<key>CFBundleVersion</key><string>{{.Version}}</string>
+	<key>CFBundleGetInfoString</key><string>Built by {{.Author}} at {{.Date}} using Wails (https://wails.app)</string>
+	<key>CFBundleShortVersionString</key><string>{{.Version}}</string>
+	<key>CFBundleIconFile</key><string>iconfile</string>
+	<key>NSHighResolutionCapable</key><string>true</string>
+</dict></plist>

cmd/program.go

@@ -2,17 +2,23 @@ package cmd
 
 import (
 	"bytes"
+	"fmt"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"syscall"
 )
 
 // ProgramHelper - Utility functions around installed applications
-type ProgramHelper struct{}
+type ProgramHelper struct {
+	shell *ShellHelper
+}
 
 // NewProgramHelper - Creates a new ProgramHelper
 func NewProgramHelper() *ProgramHelper {
-	return &ProgramHelper{}
+	return &ProgramHelper{
+		shell: NewShellHelper(),
+	}
 }
 
 // IsInstalled tries to determine if the given binary name is installed
@@ -83,3 +89,37 @@ func (p *Program) Run(vars ...string) (stdout, stderr string, exitCode int, err
 	}
 	return
 }
+
+// InstallGoPackage installs the given Go package
+func (p *ProgramHelper) InstallGoPackage(packageName string) error {
+	args := strings.Split("get -u "+packageName, " ")
+	_, stderr, err := p.shell.Run("go", args...)
+	if err != nil {
+		fmt.Println(stderr)
+	}
+	return err
+}
+
+// RunCommand runs the given command
+func (p *ProgramHelper) RunCommand(command string) error {
+	args := strings.Split(command, " ")
+	return p.RunCommandArray(args)
+}
+
+// RunCommandArray runs the command specified in the array
+func (p *ProgramHelper) RunCommandArray(args []string) error {
+	program := args[0]
+	// TODO: Run FindProgram here and get the full path to the exe
+	program, err := exec.LookPath(program)
+	if err != nil {
+		fmt.Printf("ERROR: Looks like '%s' isn't installed. Please install and try again.", program)
+		return err
+	}
+	args = args[1:]
+	// fmt.Printf("RunCommandArray = %s %+v\n", program, args)
+	_, stderr, err := p.shell.Run(program, args...)
+	if err != nil {
+		fmt.Println(stderr)
+	}
+	return err
+}

cmd/project.go

@@ -19,6 +19,8 @@ type frontend struct {
 	Dir     string `json:"dir"`
 	Install string `json:"install"`
 	Build   string `json:"build"`
+	Bridge  string `json:"bridge"`
+	Serve   string `json:"serve"`
 }
 
 type framework struct {
@@ -151,17 +153,16 @@ func InputQuestion(name, message string, defaultValue string, required bool) *su
 
 // ProjectOptions holds all the options available for a project
 type ProjectOptions struct {
-	Name            string     `json:"name"`
-	Description     string     `json:"description"`
-	Author          *author    `json:"author,omitempty"`
-	Version         string     `json:"version"`
-	OutputDirectory string     `json:"-"`
-	UseDefaults     bool       `json:"-"`
-	Template        string     `json:"-"`
-	BinaryName      string     `json:"binaryname"`
-	FrontEnd        *frontend  `json:"frontend,omitempty"`
-	NPMProjectName  string     `json:"-"`
-	Framework       *framework `json:"framework,omitempty"`
+	Name            string    `json:"name"`
+	Description     string    `json:"description"`
+	Author          *author   `json:"author,omitempty"`
+	Version         string    `json:"version"`
+	OutputDirectory string    `json:"-"`
+	UseDefaults     bool      `json:"-"`
+	Template        string    `json:"-"`
+	BinaryName      string    `json:"binaryname"`
+	FrontEnd        *frontend `json:"frontend,omitempty"`
+	NPMProjectName  string    `json:"-"`
 	system          *SystemHelper
 	log             *Logger
 	templates       *TemplateHelper
@@ -177,40 +178,14 @@ func (po *ProjectOptions) Defaults() {
 func (po *ProjectOptions) PromptForInputs() error {
 
 	var questions []*survey.Question
-	fs := NewFSHelper()
 
-	if po.Name == "" {
-		questions = append(questions, InputQuestion("Name", "The name of the project", "My Project", true))
-	} else {
-		fmt.Println("Project Name: " + po.Name)
-	}
+	processProjectName(po.Name, &questions)
 
-	if po.BinaryName == "" {
-		var binaryNameComputed string
-		if po.Name != "" {
-			binaryNameComputed = strings.ToLower(po.Name)
-			binaryNameComputed = strings.Replace(binaryNameComputed, " ", "-", -1)
-			binaryNameComputed = strings.Replace(binaryNameComputed, string(filepath.Separator), "-", -1)
-			binaryNameComputed = strings.Replace(binaryNameComputed, ":", "-", -1)
-		}
-		questions = append(questions, InputQuestion("BinaryName", "The output binary name", binaryNameComputed, true))
-	} else {
-		fmt.Println("Output binary Name: " + po.BinaryName)
-	}
+	processBinaryName(po.BinaryName, po.Name, &questions)
 
-	if po.OutputDirectory != "" {
-		projectPath, err := filepath.Abs(po.OutputDirectory)
-		if err != nil {
-			return err
-		}
-
-		if fs.DirExists(projectPath) {
-			return fmt.Errorf("directory '%s' already exists", projectPath)
-		}
-
-		fmt.Println("Project Directory: " + po.OutputDirectory)
-	} else {
-		questions = append(questions, InputQuestion("OutputDirectory", "Project directory name", "", true))
+	err := processOutputDirectory(po.OutputDirectory, &questions)
+	if err != nil {
+		return err
 	}
 
 	templateDetails, err := po.templates.GetTemplateDetails()
@@ -249,39 +224,7 @@ func (po *ProjectOptions) PromptForInputs() error {
 	}
 
 	// Setup NPM Project name
-	po.NPMProjectName = strings.Replace(po.Name, " ", "_", -1)
-
-	// If we selected custom, prompt for framework
-	if po.Template == "custom - Choose your own CSS Framework" {
-		// Ask for the framework
-		var frameworkName string
-		frameworks, err := GetFrameworks()
-		frameworkNames := []string{}
-		metadataMap := make(map[string]*FrameworkMetadata)
-		for _, frameworkMetadata := range frameworks {
-			frameworkDetails := fmt.Sprintf("%s - %s", frameworkMetadata.Name, frameworkMetadata.Description)
-			metadataMap[frameworkDetails] = frameworkMetadata
-			frameworkNames = append(frameworkNames, frameworkDetails)
-		}
-		if err != nil {
-			return err
-		}
-		var frameworkQuestion []*survey.Question
-		frameworkQuestion = append(frameworkQuestion, SelectQuestion("Framework", "Select framework", frameworkNames, frameworkNames[0], true))
-		err = survey.Ask(frameworkQuestion, &frameworkName)
-		if err != nil {
-			return err
-		}
-		// Get metadata
-		metadata := metadataMap[frameworkName]
-
-		// Add to project config
-		po.Framework = &framework{
-			Name:     metadata.Name,
-			BuildTag: metadata.BuildTag,
-		}
-
-	}
+	po.NPMProjectName = strings.ToLower(strings.Replace(po.Name, " ", "_", -1))
 
 	// Fix template name
 	if po.templateNameMap[po.Template] != "" {
@@ -290,21 +233,10 @@ func (po *ProjectOptions) PromptForInputs() error {
 
 	// Populate template details
 	templateMetadata := templateDetails[po.Template].Metadata
-	if templateMetadata["frontenddir"] != nil {
-		po.FrontEnd = &frontend{}
-		po.FrontEnd.Dir = templateMetadata["frontenddir"].(string)
-	}
-	if templateMetadata["install"] != nil {
-		if po.FrontEnd == nil {
-			return fmt.Errorf("install set in template metadata but not frontenddir")
-		}
-		po.FrontEnd.Install = templateMetadata["install"].(string)
-	}
-	if templateMetadata["build"] != nil {
-		if po.FrontEnd == nil {
-			return fmt.Errorf("build set in template metadata but not frontenddir")
-		}
-		po.FrontEnd.Build = templateMetadata["build"].(string)
+
+	err = processTemplateMetadata(templateMetadata, po)
+	if err != nil {
+		return err
 	}
 
 	return nil
@@ -337,3 +269,84 @@ func (po *ProjectOptions) LoadConfig(projectDir string) error {
 	}
 	return json.Unmarshal(rawBytes, po)
 }
+
+func computeBinaryName(projectName string) string {
+	if projectName == "" {
+		return ""
+	}
+	var binaryNameComputed = strings.ToLower(projectName)
+	binaryNameComputed = strings.Replace(binaryNameComputed, " ", "-", -1)
+	binaryNameComputed = strings.Replace(binaryNameComputed, string(filepath.Separator), "-", -1)
+	binaryNameComputed = strings.Replace(binaryNameComputed, ":", "-", -1)
+	return binaryNameComputed
+}
+
+func processOutputDirectory(outputDirectory string, questions *[]*survey.Question) error {
+
+	if outputDirectory != "" {
+		projectPath, err := filepath.Abs(outputDirectory)
+		if err != nil {
+			return err
+		}
+
+		if NewFSHelper().DirExists(projectPath) {
+			return fmt.Errorf("directory '%s' already exists", projectPath)
+		}
+
+		fmt.Println("Project Directory: " + outputDirectory)
+	} else {
+		*questions = append(*questions, InputQuestion("OutputDirectory", "Project directory name", "", true))
+	}
+	return nil
+}
+
+func processProjectName(name string, questions *[]*survey.Question) {
+	if name == "" {
+		*questions = append(*questions, InputQuestion("Name", "The name of the project", "My Project", true))
+	} else {
+		fmt.Println("Project Name: " + name)
+	}
+}
+
+func processBinaryName(binaryName string, name string, questions *[]*survey.Question) {
+	if binaryName == "" {
+		var binaryNameComputed = computeBinaryName(name)
+		*questions = append(*questions, InputQuestion("BinaryName", "The output binary name", binaryNameComputed, true))
+	} else {
+		fmt.Println("Output binary Name: " + binaryName)
+	}
+}
+
+func processTemplateMetadata(templateMetadata map[string]interface{}, po *ProjectOptions) error {
+	if templateMetadata["frontenddir"] != nil {
+		po.FrontEnd = &frontend{}
+		po.FrontEnd.Dir = templateMetadata["frontenddir"].(string)
+	}
+	if templateMetadata["install"] != nil {
+		if po.FrontEnd == nil {
+			return fmt.Errorf("install set in template metadata but not frontenddir")
+		}
+		po.FrontEnd.Install = templateMetadata["install"].(string)
+	}
+	if templateMetadata["build"] != nil {
+		if po.FrontEnd == nil {
+			return fmt.Errorf("build set in template metadata but not frontenddir")
+		}
+		po.FrontEnd.Build = templateMetadata["build"].(string)
+	}
+
+	if templateMetadata["bridge"] != nil {
+		if po.FrontEnd == nil {
+			return fmt.Errorf("bridge set in template metadata but not frontenddir")
+		}
+		po.FrontEnd.Bridge = templateMetadata["bridge"].(string)
+	}
+
+	if templateMetadata["serve"] != nil {
+		if po.FrontEnd == nil {
+			return fmt.Errorf("serve set in template metadata but not frontenddir")
+		}
+		po.FrontEnd.Serve = templateMetadata["serve"].(string)
+	}
+	return nil
+}

cmd/shell.go

@@ -0,0 +1,27 @@
+package cmd
+
+import (
+	"bytes"
+	"os/exec"
+)
+
+// ShellHelper helps with Shell commands
+type ShellHelper struct {
+}
+
+// NewShellHelper creates a new ShellHelper!
+func NewShellHelper() *ShellHelper {
+	return &ShellHelper{}
+}
+
+// Run the given command
+func (sh *ShellHelper) Run(command string, vars ...string) (stdout, stderr string, err error) {
+	cmd := exec.Command(command, vars...)
+	var stdo, stde bytes.Buffer
+	cmd.Stdout = &stdo
+	cmd.Stderr = &stde
+	err = cmd.Run()
+	stdout = string(stdo.Bytes())
+	stderr = string(stde.Bytes())
+	return
+}

cmd/system.go

@@ -220,6 +220,15 @@ func (sc *SystemConfig) load(filename string) error {
 	return nil
 }
 
+// CheckDependenciesSilent checks for dependencies but
+// only outputs if there's an error
+func CheckDependenciesSilent(logger *Logger) (bool, error) {
+	logger.SetErrorOnly(true)
+	result, err := CheckDependencies(logger)
+	logger.SetErrorOnly(false)
+	return result, err
+}
+
 // CheckDependencies will look for Wails dependencies on the system
 // Errors are reported in error and the bool return value is whether
 // the dependencies are all installed.
@@ -281,6 +290,7 @@ func CheckDependencies(logger *Logger) (bool, error) {
 			}
 		}
 	}
+	logger.White("")
 
 	return !errors, err
 }

cmd/templates.go

@@ -10,12 +10,12 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-
-	"github.com/alecthomas/template"
+	"text/template"
 )
 
 const templateSuffix = ".template"
 
+// TemplateHelper helps with creating projects
 type TemplateHelper struct {
 	system      *SystemHelper
 	fs          *FSHelper
@@ -25,12 +25,14 @@ type TemplateHelper struct {
 	metadataFilename string
 }
 
+// Template defines a single template
 type Template struct {
 	Name     string
 	Dir      string
 	Metadata map[string]interface{}
 }
 
+// NewTemplateHelper creates a new template helper
 func NewTemplateHelper() *TemplateHelper {
 	result := TemplateHelper{
 		system:           NewSystemHelper(),
@@ -45,6 +47,7 @@ func NewTemplateHelper() *TemplateHelper {
 	return &result
 }
 
+// GetTemplateNames returns a map of all available templates
 func (t *TemplateHelper) GetTemplateNames() (map[string]string, error) {
 	templateDirs, err := t.fs.GetSubdirs(t.templateDir)
 	if err != nil {
@@ -53,6 +56,8 @@ func (t *TemplateHelper) GetTemplateNames() (map[string]string, error) {
 	return templateDirs, nil
 }
 
+// GetTemplateDetails returns a map of Template structs containing details
+// of the found templates
 func (t *TemplateHelper) GetTemplateDetails() (map[string]*Template, error) {
 	templateDirs, err := t.fs.GetSubdirs(t.templateDir)
 	if err != nil {
@@ -81,6 +86,7 @@ func (t *TemplateHelper) GetTemplateDetails() (map[string]*Template, error) {
 	return result, nil
 }
 
+// LoadMetadata loads the template's 'metadata.json' file
 func (t *TemplateHelper) LoadMetadata(dir string) (map[string]interface{}, error) {
 	templateFile := filepath.Join(dir, t.metadataFilename)
 	result := make(map[string]interface{})
@@ -95,6 +101,7 @@ func (t *TemplateHelper) LoadMetadata(dir string) (map[string]interface{}, error
 	return result, err
 }
 
+// TemplateExists returns true if the given template name exists
 func (t *TemplateHelper) TemplateExists(templateName string) (bool, error) {
 	templates, err := t.GetTemplateNames()
 	if err != nil {
@@ -104,6 +111,8 @@ func (t *TemplateHelper) TemplateExists(templateName string) (bool, error) {
 	return exists, nil
 }
 
+// InstallTemplate installs the template given in the project options to the
+// project path given
 func (t *TemplateHelper) InstallTemplate(projectPath string, projectOptions *ProjectOptions) error {
 
 	// Get template files

cmd/templates/basic/main.go

@@ -1,19 +0,0 @@
-package main
-
-import (
-	wails "github.com/wailsapp/wails"
-)
-
-var html = `<h1> Basic Template </h1>`
-
-func main() {
-
-	// Initialise the app
-	app := wails.CreateApp(&wails.AppConfig{
-		Width:  1024,
-		Height: 768,
-		Title:  "My Project",
-		HTML:   html,
-	})
-	app.Run()
-}

cmd/templates/basic/template.json

@@ -1,7 +0,0 @@
-{
-  "name": "Basic",
-  "shortdescription": "A basic template",
-  "description": "A basic template using vanilla JS",
-  "author": "Lea Anthony<lea.anthony@gmail.com>",
-  "created": "2018-10-18"
-}

cmd/templates/custom/main.go

@@ -1,19 +0,0 @@
-package main
-
-import (
-	wails "github.com/wailsapp/wails"
-)
-
-var html = `<h1> Custom Project </h1>`
-
-func main() {
-
-	// Initialise the app
-	app := wails.CreateApp(&wails.AppConfig{
-		Width:  800,
-		Height: 600,
-		Title:  "My Project",
-		HTML:   html,
-	})
-	app.Run()
-}

cmd/templates/custom/template.json

@@ -1,7 +0,0 @@
-{
-  "name": "Custom",
-  "shortdescription": "Choose your own CSS Framework",
-  "description": "A basic template allowing use of CSS Frameworks",
-  "author": "Lea Anthony<lea.anthony@gmail.com>",
-  "created": "2018-10-22"
-}

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

@@ -1,5 +1,6 @@
 {
-  "name": "frontend",
+  "name": "{{.NPMProjectName}}",
+  "author": "{{.Author.Name}}<{{.Author.Email}}>",
   "version": "0.1.0",
   "private": true,
   "scripts": {
@@ -14,4 +15,4 @@
     "@vue/cli-service": "^3.1.4",
     "vue-template-compiler": "^2.5.17"
   }
-}
+}

cmd/templates/vuewebpack/frontend/src/assets/css/main.css

@@ -12,8 +12,8 @@ html {
   overflow: hidden;
   /* https://leaverou.github.io/css3patterns/#carbon */
   background: linear-gradient(27deg, #151515 5px, transparent 5px) 0 5px,
-    linear-gradient(207deg, #151515 5px, transparent 5px) 10px 0px,
-    linear-gradient(27deg, #222 5px, transparent 5px) 0px 10px,
+    linear-gradient(207deg, #151515 5px, transparent 5px) 10px 0,
+    linear-gradient(27deg, #222 5px, transparent 5px) 0 10px,
     linear-gradient(207deg, #222 5px, transparent 5px) 10px 5px,
     linear-gradient(90deg, #1b1b1b 10px, transparent 10px),
     linear-gradient(
@@ -46,10 +46,8 @@ html {
       format("woff2"),
     /* Super Modern Browsers */
       url("../fonts/roboto/roboto-v18-latin-regular.woff") format("woff"),
-    /* Modern Browsers */
-      url("../fonts/roboto/roboto-v18-latin-regular.ttf")
+    /* Modern Browsers */ url("../fonts/roboto/roboto-v18-latin-regular.ttf")
       format("truetype"),
     /* Safari, Android, iOS */
-      url("../fonts/roboto/roboto-v18-latin-regular.svg#Roboto")
-      format("svg"); /* Legacy iOS */
-}
+      url("../fonts/roboto/roboto-v18-latin-regular.svg#Roboto") format("svg"); /* Legacy iOS */
+}

cmd/templates/vuewebpack/frontend/src/assets/css/quote.css

@@ -18,8 +18,12 @@ body {
   border-color: #117;
 }
 
-p { margin-bottom: 1.5em; }
-p:last-child { margin-bottom: 0; }
+p {
+  margin-bottom: 1.5em;
+}
+p:last-child {
+  margin-bottom: 0;
+}
 
 blockquote {
   display: block;
@@ -32,9 +36,9 @@ blockquote {
   color: #117;
 }
 blockquote:before {
-  content: '\201C';
+  content: "\201C";
   position: absolute;
-  top: 0em;
+  top: 0;
   left: 50%;
   transform: translate(-50%, -50%);
   background: #fff;
@@ -54,22 +58,22 @@ blockquote:after {
 
 /* https://fdossena.com/?p=html5cool/buttons/i.frag */
 button {
-  display:inline-block;
-  padding:0.35em 1.2em;
-  border:0.1em solid #000;
-  margin:0 0.3em 0.3em 0;
-  border-radius:0.12em;
+  display: inline-block;
+  padding: 0.35em 1.2em;
+  border: 0.1em solid #000;
+  margin: 0 0.3em 0.3em 0;
+  border-radius: 0.12em;
   box-sizing: border-box;
-  text-decoration:none;
-  font-family:'Roboto',sans-serif;
-  font-weight:300;
+  text-decoration: none;
+  font-family: "Roboto", sans-serif;
+  font-weight: 300;
   font-size: 1em;
-  color:#000;
-  text-align:center;
+  color: #000;
+  text-align: center;
   transition: all 0.2s;
 }
-button:hover{
-  color:#FFF;
-  background-color:#000;
+button:hover {
+  color: #fff;
+  background-color: #000;
   cursor: pointer;
-}
+}

cmd/templates/vuewebpack/frontend/src/components/Quote.vue

@@ -8,6 +8,7 @@
 
 <script>
 import "../assets/css/quote.css";
+import { eventBus } from "../main";
 
 export default {
   data() {
@@ -18,14 +19,17 @@ export default {
   methods: {
     getNewQuote: function() {
       var self = this;
-      wails.$.main.QuotesCollection.GetQuote().then(result => {
-        console.log(result);
+      backend.QuotesCollection.GetQuote().then(result => {
         self.quote = result;
       });
     }
   },
   created() {
-    this.getNewQuote();
+    if( !backend ) {
+    eventBus.$on("ready", this.getNewQuote);
+    } else {
+      this.getNewQuote();
+    }
   }
 };
 </script>

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

@@ -1,8 +1,13 @@
-import Vue from 'vue'
-import App from './App.vue'
-
-Vue.config.productionTip = false
+import Vue from "vue";
+export const eventBus = new Vue();
 
+import App from "./App.vue";
 new Vue({
-  render: h => h(App),
-}).$mount('#app')
+  render: h => h(App)
+}).$mount("#app");
+
+import Bridge from "./wailsbridge";
+Bridge.OnReady(() => {
+  eventBus.$emit("ready");
+});
+Bridge.Start();

cmd/templates/vuewebpack/go.mod.template

@@ -0,0 +1 @@
+module {{.BinaryName}}

cmd/templates/vuewebpack/main.go.template

@@ -12,9 +12,9 @@ func main() {
 	app := wails.CreateApp(&wails.AppConfig{
 		Width:  1024,
 		Height: 768,
-		Title:  "Vue Simple",
-		JS:     assets.String("app.js"),
-		CSS:    assets.String("app.css"),
+		Title:  "{{.Name}}",
+		JS:     wails.BoxString(&assets, "app.js"),
+		CSS:    wails.BoxString(&assets, "app.css"),
 	})
 	app.Bind(newQuotesCollection())
 	app.Run()

cmd/templates/vuewebpack/template.json

@@ -6,5 +6,7 @@
   "created": "2018-12-01",
   "frontenddir": "frontend",
   "install": "npm install",
-  "build": "npm run build"
-}
+  "build": "npm run build",
+  "serve": "npm run serve",
+  "bridge": "src"
+}

cmd/version.go

@@ -2,4 +2,4 @@ package cmd
 
 // Version - Wails version
 // ...oO(There must be a better way)
-const Version = "v0.5.0"
+const Version = "v0.7.2"

cmd/wails/0_setup.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"runtime"
 
+	"github.com/leaanthony/spinner"
 	"github.com/wailsapp/wails/cmd"
 )
 
@@ -29,61 +30,39 @@ Create your first project by running 'wails init'.`
 		if runtime.GOOS != "windows" {
 			successMessage = "🚀 " + successMessage
 		}
-		switch runtime.GOOS {
-		case "darwin":
-			logger.Yellow("Detected Platform: OSX")
-		case "windows":
-			logger.Yellow("Detected Platform: Windows")
-		case "linux":
-			logger.Yellow("Detected Platform: Linux")
-		default:
-			return fmt.Errorf("Platform %s is currently not supported", runtime.GOOS)
-		}
-
-		logger.Yellow("Checking for prerequisites...")
-		// Check we have a cgo capable environment
-
-		requiredPrograms, err := cmd.GetRequiredPrograms()
+		// Platform check
+		err = platformCheck()
 		if err != nil {
 			return err
 		}
-		errors := false
-		programHelper := cmd.NewProgramHelper()
-		for _, program := range *requiredPrograms {
-			bin := programHelper.FindProgram(program.Name)
-			if bin == nil {
-				errors = true
-				logger.Red("Program '%s' not found. %s", program.Name, program.Help)
-			} else {
-				logger.Green("Program '%s' found: %s", program.Name, bin.Path)
-			}
+
+		// Check we have a cgo capable environment
+		logger.Yellow("Checking for prerequisites...")
+		errors, err := checkRequiredPrograms()
+		if err != nil {
+			return err
 		}
 
 		// Linux has library deps
-		if runtime.GOOS == "linux" {
-			// Check library prerequisites
-			requiredLibraries, err := cmd.GetRequiredLibraries()
+		errors, err = checkLibraries()
+		if err != nil {
+			return err
+		}
+
+		// packr
+		err = cmd.CheckPackr()
+
+		programHelper := cmd.NewProgramHelper()
+		if !programHelper.IsInstalled("packr") {
+			buildSpinner := spinner.New()
+			buildSpinner.SetSpinSpeed(50)
+			buildSpinner.Start("Installing packr...")
+			err := programHelper.InstallGoPackage("github.com/gobuffalo/packr/...")
 			if err != nil {
+				buildSpinner.Error()
 				return err
 			}
-			distroInfo := cmd.GetLinuxDistroInfo()
-			for _, library := range *requiredLibraries {
-				switch distroInfo.Distribution {
-				case cmd.Ubuntu:
-					installed, err := cmd.DpkgInstalled(library.Name)
-					if err != nil {
-						return err
-					}
-					if !installed {
-						errors = true
-						logger.Red("Library '%s' not found. %s", library.Name, library.Help)
-					} else {
-						logger.Green("Library '%s' installed.", library.Name)
-					}
-				default:
-					return fmt.Errorf("unable to check libraries on distribution '%s'. Please ensure that the '%s' equivalent is installed", distroInfo.DistributorID, library.Name)
-				}
-			}
+			buildSpinner.Success()
 		}
 
 		logger.White("")
@@ -95,3 +74,65 @@ Create your first project by running 'wails init'.`
 		return err
 	})
 }
+
+func platformCheck() error {
+	switch runtime.GOOS {
+	case "darwin":
+		logger.Yellow("Detected Platform: OSX")
+	case "windows":
+		logger.Yellow("Detected Platform: Windows")
+	case "linux":
+		logger.Yellow("Detected Platform: Linux")
+	default:
+		return fmt.Errorf("Platform %s is currently not supported", runtime.GOOS)
+	}
+	return nil
+}
+
+func checkLibraries() (errors bool, err error) {
+	if runtime.GOOS == "linux" {
+		// Check library prerequisites
+		requiredLibraries, err := cmd.GetRequiredLibraries()
+		if err != nil {
+			return false, err
+		}
+		distroInfo := cmd.GetLinuxDistroInfo()
+		for _, library := range *requiredLibraries {
+			switch distroInfo.Distribution {
+			case cmd.Ubuntu:
+				installed, err := cmd.DpkgInstalled(library.Name)
+				if err != nil {
+					return false, err
+				}
+				if !installed {
+					errors = true
+					logger.Red("Library '%s' not found. %s", library.Name, library.Help)
+				} else {
+					logger.Green("Library '%s' installed.", library.Name)
+				}
+			default:
+				return false, fmt.Errorf("unable to check libraries on distribution '%s'. Please ensure that the '%s' equivalent is installed", distroInfo.DistributorID, library.Name)
+			}
+		}
+	}
+	return false, nil
+}
+
+func checkRequiredPrograms() (errors bool, err error) {
+	requiredPrograms, err := cmd.GetRequiredPrograms()
+	if err != nil {
+		return true, err
+	}
+	errors = false
+	programHelper := cmd.NewProgramHelper()
+	for _, program := range *requiredPrograms {
+		bin := programHelper.FindProgram(program.Name)
+		if bin == nil {
+			errors = true
+			logger.Red("Program '%s' not found. %s", program.Name, program.Help)
+		} else {
+			logger.Green("Program '%s' found: %s", program.Name, bin.Path)
+		}
+	}
+	return
+}

cmd/wails/2_init.go

@@ -34,13 +34,11 @@ Any flags that are required and not given will be prompted for.`
 			return err
 		}
 
-		success, err := cmd.CheckDependencies(logger)
+		success, err := cmd.CheckDependenciesSilent(logger)
 		if !success {
 			return err
 		}
 
-		logger.White("")
-
 		// Do we want to just force defaults?
 		if projectOptions.UseDefaults {
 			// Use defaults

cmd/wails/4_build.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/leaanthony/spinner"
+	"github.com/wailsapp/wails/cmd"
+)
+
+func init() {
+
+	var packageApp = false
+	var forceRebuild = false
+	var debugMode = false
+	buildSpinner := spinner.NewSpinner()
+	buildSpinner.SetSpinSpeed(50)
+
+	commandDescription := `This command will check to ensure all pre-requistes are installed prior to building. If not, it will attempt to install them. Building comprises of a number of steps: install frontend dependencies, build frontend, pack frontend, compile main application.`
+	initCmd := app.Command("build", "Builds your Wails project").
+		LongDescription(commandDescription).
+		BoolFlag("p", "Package application on successful build", &packageApp).
+		BoolFlag("f", "Force rebuild of application components", &forceRebuild).
+		BoolFlag("d", "Build in Debug mode", &debugMode)
+
+	initCmd.Action(func() error {
+		log := cmd.NewLogger()
+		message := "Building Application"
+		if forceRebuild {
+			message += " (force rebuild)"
+		}
+		log.WhiteUnderline(message)
+
+		// Project options
+		projectOptions := &cmd.ProjectOptions{}
+
+		// Check we are in project directory
+		// Check project.json loads correctly
+		fs := cmd.NewFSHelper()
+		err := projectOptions.LoadConfig(fs.Cwd())
+		if err != nil {
+			return err
+		}
+
+		// Validate config
+		// Check if we have a frontend
+		err = cmd.ValidateFrontendConfig(projectOptions)
+		if err != nil {
+			return err
+		}
+
+		// Program checker
+		program := cmd.NewProgramHelper()
+
+		if projectOptions.FrontEnd != nil {
+			// npm
+			if !program.IsInstalled("npm") {
+				return fmt.Errorf("it appears npm is not installed. Please install and run again")
+			}
+		}
+
+		// Check Packr is installed
+		err = cmd.CheckPackr()
+		if err != nil {
+			return err
+		}
+
+		// Save project directory
+		projectDir := fs.Cwd()
+
+		// Install deps
+		if projectOptions.FrontEnd != nil {
+			err = cmd.InstallFrontendDeps(projectDir, projectOptions, forceRebuild)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Move to project directory
+		err = os.Chdir(projectDir)
+		if err != nil {
+			return err
+		}
+
+		// Install dependencies
+		err = cmd.InstallGoDependencies()
+		if err != nil {
+			return err
+		}
+
+		// Build application
+		buildMode := "prod"
+		if debugMode {
+			buildMode = "debug"
+		}
+		err = cmd.BuildApplication(projectOptions.BinaryName, forceRebuild, buildMode)
+		if err != nil {
+			return err
+		}
+
+		// Package application
+		if packageApp {
+			err = cmd.PackageApplication(projectOptions)
+			if err != nil {
+				return err
+			}
+		}
+
+		logger.Yellow("Awesome! Project '%s' built!", projectOptions.Name)
+
+		return nil
+
+	})
+}

cmd/wails/6_serve.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/leaanthony/spinner"
+	"github.com/wailsapp/wails/cmd"
+)
+
+func init() {
+
+	var forceRebuild = false
+	buildSpinner := spinner.NewSpinner()
+	buildSpinner.SetSpinSpeed(50)
+
+	commandDescription := `This command builds then serves your application in bridge mode. Useful for developing your app in a browser.`
+	initCmd := app.Command("serve", "Run your Wails project in bridge mode.").
+		LongDescription(commandDescription).
+		BoolFlag("f", "Force rebuild of application components", &forceRebuild)
+
+	initCmd.Action(func() error {
+		log := cmd.NewLogger()
+		message := "Building Application"
+		if forceRebuild {
+			message += " (force rebuild)"
+		}
+		log.WhiteUnderline(message)
+
+		// Project options
+		projectOptions := &cmd.ProjectOptions{}
+
+		// Check we are in project directory
+		// Check project.json loads correctly
+		fs := cmd.NewFSHelper()
+		err := projectOptions.LoadConfig(fs.Cwd())
+		if err != nil {
+			return err
+		}
+
+		// Validate config
+		// Check if we have a frontend
+		err = cmd.ValidateFrontendConfig(projectOptions)
+		if err != nil {
+			return err
+		}
+
+		// Program checker
+		program := cmd.NewProgramHelper()
+
+		if projectOptions.FrontEnd != nil {
+			// npm
+			if !program.IsInstalled("npm") {
+				return fmt.Errorf("it appears npm is not installed. Please install and run again")
+			}
+		}
+
+		// Check Packr is installed
+		err = cmd.CheckPackr()
+		if err != nil {
+			return err
+		}
+
+		// Save project directory
+		projectDir := fs.Cwd()
+
+		// Install deps
+		if projectOptions.FrontEnd != nil {
+			err = cmd.InstallFrontendDeps(projectDir, projectOptions, forceRebuild)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Run packr in project directory
+		err = os.Chdir(projectDir)
+		if err != nil {
+			return err
+		}
+
+		// Install dependencies
+		err = cmd.InstallGoDependencies()
+		if err != nil {
+			return err
+		}
+
+		buildMode := "bridge"
+		err = cmd.BuildApplication(projectOptions.BinaryName, forceRebuild, buildMode)
+		if err != nil {
+			return err
+		}
+
+		logger.Yellow("Awesome! Project '%s' built!", projectOptions.Name)
+		return cmd.ServeProject(projectOptions, logger)
+	})
+}

event_manager.go

@@ -0,0 +1,148 @@
+package wails
+
+import (
+	"fmt"
+	"sync"
+)
+
+// eventManager handles and processes events
+type eventManager struct {
+	incomingEvents chan *eventData
+	listeners      map[string][]*eventListener
+	exit           bool
+	log            *CustomLogger
+	renderer       Renderer // Messages will be dispatched to the frontend
+}
+
+// newEventManager creates a new event manager with a 100 event buffer
+func newEventManager() *eventManager {
+	return &eventManager{
+		incomingEvents: make(chan *eventData, 100),
+		listeners:      make(map[string][]*eventListener),
+		exit:           false,
+		log:            newCustomLogger("Events"),
+	}
+}
+
+// PushEvent places the given event on to the event queue
+func (e *eventManager) PushEvent(eventData *eventData) {
+	e.incomingEvents <- eventData
+}
+
+// eventListener holds a callback function which is invoked when
+// the event listened for is emitted. It has a counter which indicates
+// how the total number of events it is interested in. A value of zero
+// means it does not expire (default).
+type eventListener struct {
+	callback func(...interface{}) // Function to call with emitted event data
+	counter  int                  // Expire after counter callbacks. 0 = infinite
+	expired  bool                 // Indicates if the listener has expired
+}
+
+// Creates a new event listener from the given callback function
+func (e *eventManager) addEventListener(eventName string, callback func(...interface{}), counter int) error {
+
+	// Sanity check inputs
+	if callback == nil {
+		return fmt.Errorf("nil callback bassed to addEventListener")
+	}
+
+	// Check event has been registered before
+	if e.listeners[eventName] == nil {
+		e.listeners[eventName] = []*eventListener{}
+	}
+
+	// Create the callback
+	listener := &eventListener{
+		callback: callback,
+		counter:  counter,
+	}
+
+	// Register listener
+	e.listeners[eventName] = append(e.listeners[eventName], listener)
+
+	// All good mate
+	return nil
+}
+
+func (e *eventManager) On(eventName string, callback func(...interface{})) {
+	// Add a persistent eventListener (counter = 0)
+	e.addEventListener(eventName, callback, 0)
+}
+
+// Emit broadcasts the given event to the subscribed listeners
+func (e *eventManager) Emit(eventName string, optionalData ...interface{}) {
+	e.incomingEvents <- &eventData{Name: eventName, Data: optionalData}
+}
+
+// Starts the event manager's queue processing
+func (e *eventManager) start(renderer Renderer) {
+
+	e.log.Info("Starting")
+
+	// Store renderer
+	e.renderer = renderer
+
+	// Set up waitgroup so we can wait for goroutine to start
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	// Run main loop in seperate goroutine
+	go func() {
+		wg.Done()
+		e.log.Info("Listening")
+		for e.exit == false {
+			// TODO: Listen for application exit
+			select {
+			case event := <-e.incomingEvents:
+				e.log.DebugFields("Got Event", Fields{
+					"data": event.Data,
+					"name": event.Name,
+				})
+
+				// Notify renderer
+				e.renderer.NotifyEvent(event)
+
+				// Notify Go listeners
+				var listenersToRemove []*eventListener
+
+				// Iterate listeners
+				for _, listener := range e.listeners[event.Name] {
+
+					// Call listener, perhaps with data
+					if event.Data == nil {
+						go listener.callback()
+					} else {
+						unpacked := event.Data.([]interface{})
+						go listener.callback(unpacked...)
+					}
+
+					// Update listen counter
+					if listener.counter > 0 {
+						listener.counter = listener.counter - 1
+						if listener.counter == 0 {
+							listener.expired = true
+						}
+					}
+				}
+
+				// Remove expired listners in place
+				if len(listenersToRemove) > 0 {
+					listeners := e.listeners[event.Name][:0]
+					for _, listener := range listeners {
+						if !listener.expired {
+							listeners = append(listeners, listener)
+						}
+					}
+				}
+			}
+		}
+	}()
+
+	// Wait for goroutine to start
+	wg.Wait()
+}
+
+func (e *eventManager) stop() {
+	e.exit = true
+}

go.mod

@@ -2,16 +2,22 @@ module github.com/wailsapp/wails
 
 require (
 	github.com/AlecAivazis/survey v1.7.1
-	github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc
+	github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc // indirect
+	github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc // indirect
+	github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac
+	github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947 // indirect
 	github.com/fatih/color v1.7.0
+	github.com/go-playground/colors v1.2.0
 	github.com/gobuffalo/packr v1.21.9
+	github.com/gorilla/websocket v1.4.0
+	github.com/jackmordaunt/icns v1.0.0
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/leaanthony/spinner v0.4.0
-	github.com/leaanthony/synx v0.0.0-20180923230033-60efbd9984b0 // indirect
-	github.com/leaanthony/wincursor v0.0.0-20180705115120-056510f32d15 // indirect
-	github.com/mattn/go-colorable v0.0.9 // indirect
-	github.com/mattn/go-isatty v0.0.4 // indirect
+	github.com/leaanthony/slicer v0.0.0-20190110113548-aa9ea12f976a
+	github.com/leaanthony/spinner v0.5.0
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
 	github.com/mitchellh/go-homedir v1.0.0
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
+	github.com/sirupsen/logrus v1.2.0
+	golang.org/x/net v0.0.0-20190107155100-1a61f4433d85 // indirect
 	gopkg.in/AlecAivazis/survey.v1 v1.7.1 // indirect
 )

go.sum

@@ -3,7 +3,6 @@ github.com/AlecAivazis/survey v1.7.1/go.mod h1:MVECab6WqEH1aXhj8nKIwF7HEAJAj2bhh
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 github.com/ajg/form v0.0.0-20160822230020-523a5da1a92f/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
@@ -14,6 +13,12 @@ github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8Nz
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc h1:VBS1z48BFEe00G81z8MKOtwX7f/ISkuH38NscT8iVPw=
+github.com/dchest/cssmin v0.0.0-20151210170030-fb8d9b44afdc/go.mod h1:ABJPuor7YlcsHmvJ1QxX38e2NcufLY3hm0yXv+cy9sI=
+github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac h1:DpMwFluHWoZpV9ex5XjkWO4HyCz5HLVI8XbHw0FhHi4=
+github.com/dchest/htmlmin v0.0.0-20150526090704-e254725e81ac/go.mod h1:XsAE+b4rOZc8gvgsgF+wU75mNBvBcyED1wdd9PBLlJ0=
+github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947 h1:Fm10/KNuoAyBm2P5P5H91Xy21hGcZnBdjR+cMdytv1M=
+github.com/dchest/jsmin v0.0.0-20160823214000-faeced883947/go.mod h1:Dv9D0NUlAsaQcGQZa5kc5mqR9ua72SmA8VXi4cd+cBw=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dustin/go-humanize v0.0.0-20180713052910-9f541cc9db5d/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -22,6 +27,8 @@ github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5Kwzbycv
 github.com/fatih/structs v1.0.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/go-playground/colors v1.2.0 h1:0EdjTXKrr2g1L/LQTYtIqabeHpZuGZz1U4osS1T8+5M=
+github.com/go-playground/colors v1.2.0/go.mod h1:miw1R2JIE19cclPxsXqNdzLZsk4DP4iF+m88bRc7kfM=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/gobuffalo/buffalo v0.12.8-0.20181004233540-fac9bb505aa8/go.mod h1:sLyT7/dceRXJUxSsE813JTQtA3Eb1vjxWfo/N//vXIY=
 github.com/gobuffalo/buffalo v0.13.0/go.mod h1:Mjn1Ba9wpIbpbrD+lIDMy99pQ0H0LiddMIIDGse7qT4=
@@ -179,17 +186,23 @@ github.com/gobuffalo/x v0.0.0-20181007152206-913e47c59ca7/go.mod h1:9rDPXaB3kXdK
 github.com/gofrs/uuid v3.1.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/pat v0.0.0-20180118222023-199c85a7f6d1/go.mod h1:YeAe0gNeiNT5hoiZRI4yiOky6jVdNvfO2N6Kav/HmxY=
 github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
 github.com/gorilla/sessions v1.1.2/go.mod h1:8KCfur6+4Mqcc6S0FEfKuN15Vl5MgXW92AE8ovaJD0w=
 github.com/gorilla/sessions v1.1.3/go.mod h1:8KCfur6+4Mqcc6S0FEfKuN15Vl5MgXW92AE8ovaJD0w=
+github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jackc/fake v0.0.0-20150926172116-812a484cc733/go.mod h1:WrMFNQdiFJ80sQsxDoMokWK1W5TQtxBFNpzWTD84ibQ=
 github.com/jackc/pgx v3.2.0+incompatible/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
+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/jmoiron/sqlx v0.0.0-20180614180643-0dae4fefe7c0/go.mod h1:IiEW3SEiiErVyFdH8NTuWjSifiEQKUoyK3LNqr2kCHU=
 github.com/joho/godotenv v1.2.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
 github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
@@ -204,14 +217,13 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/leaanthony/spinner v0.4.0 h1:y/7FqQqqObRKYI+33bg9DGhHIY7cQHicm+Vz0Uda0Ik=
-github.com/leaanthony/spinner v0.4.0/go.mod h1:2Mmv+8Brcw3NwPT1DdOLmW6+zWpSamDDFFsUvVHo2cc=
-github.com/leaanthony/spinner v0.5.0 h1:OJKn+0KP6ilHxwCEOv5Lo0wPM4PgWZWLJTeUprGJK0g=
-github.com/leaanthony/spinner v0.5.0/go.mod h1:2Mmv+8Brcw3NwPT1DdOLmW6+zWpSamDDFFsUvVHo2cc=
-github.com/leaanthony/synx v0.0.0-20180923230033-60efbd9984b0 h1:1bGojw4YacLY5bqQalojiQ7mSfQbe4WIWCEgPZagowU=
-github.com/leaanthony/synx v0.0.0-20180923230033-60efbd9984b0/go.mod h1:Iz7eybeeG8bdq640iR+CwYb8p+9EOsgMWghkSRyZcqs=
-github.com/leaanthony/wincursor v0.0.0-20180705115120-056510f32d15 h1:166LIty6ldcyOc7tbgfu5smsGATvEo0JZV6bnbzyEc4=
-github.com/leaanthony/wincursor v0.0.0-20180705115120-056510f32d15/go.mod h1:7TVwwrzSH/2Y9gLOGH+VhA+bZhoWXBRgbGNTMk+yimE=
+github.com/leaanthony/slicer v0.0.0-20190110113548-aa9ea12f976a h1:+nH6CKt4ZdMj+AabQrU0SLtZWYyQ1ovzLCA21se+raw=
+github.com/leaanthony/slicer v0.0.0-20190110113548-aa9ea12f976a/go.mod h1:VMB/HGvr3uR3MRpFWHWAm0w+DHQLzPHYe2pKfpFlQIQ=
+github.com/leaanthony/spinner v0.5.0 h1:HQykt/iTy7fmINEREtRbWrt+8j4MxC8dtvWBxEWM9oA=
+github.com/leaanthony/spinner v0.5.0/go.mod h1:8TSFz9SL1AUC4XSbEFYE6SfN5Mlus51qYluVGrie9ww=
+github.com/leaanthony/synx v0.1.0 h1:R0lmg2w6VMb8XcotOwAe5DLyzwjLrskNkwU7LLWsyL8=
+github.com/leaanthony/synx v0.1.0/go.mod h1:Iz7eybeeG8bdq640iR+CwYb8p+9EOsgMWghkSRyZcqs=
+github.com/leaanthony/wincursor v0.1.0/go.mod h1:7TVwwrzSH/2Y9gLOGH+VhA+bZhoWXBRgbGNTMk+yimE=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/markbates/deplist v1.0.4/go.mod h1:gRRbPbbuA8TmMiRvaOzUlRfzfjeCCBqX2A6arxN01MM=
@@ -237,6 +249,7 @@ github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRU
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
@@ -246,7 +259,10 @@ github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrk
 github.com/mitchellh/mapstructure v1.0.0/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/monoculum/formam v0.0.0-20180901015400-4e68be1d79ba/go.mod h1:RKgILGEJq24YyJ2ban8EO0RUVSJlF1pGsEvoLEACr/Q=
+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/nicksnyder/go-i18n v1.10.0/go.mod h1:HrK7VCrbOvQoUAQ7Vpy7i87N7JZZZ7R2xBGjv0j365Q=
+github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
@@ -256,6 +272,7 @@ github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/9
 github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/ribice/glice v0.0.0-20181011133736-685f13fa9b12/go.mod h1:A+ednilkKNW0CJGLsrLkq0D49M4EhlCi8gvnkwoZFn0=
 github.com/rogpeppe/go-internal v1.0.0 h1:o4VLZ5jqHE+HahLT6drNtSGTrrUA3wPBmtpgqtdbClo=
 github.com/rogpeppe/go-internal v1.0.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
@@ -271,6 +288,7 @@ github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.
 github.com/sirupsen/logrus v1.0.6/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
 github.com/sirupsen/logrus v1.1.0/go.mod h1:zrgwTnHtNr00buQ1vSptGe8m1f/BbgsPukg8qsT7A+A=
 github.com/sirupsen/logrus v1.1.1/go.mod h1:zrgwTnHtNr00buQ1vSptGe8m1f/BbgsPukg8qsT7A+A=
+github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
 github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
@@ -288,7 +306,6 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/unrolled/secure v0.0.0-20180918153822-f340ee86eb8b/go.mod h1:mnPT77IAdsi/kV7+Es7y+pXALeV3h7G6dQF6mNYjcLA=
 github.com/unrolled/secure v0.0.0-20181005190816-ff9db2ff917f/go.mod h1:mnPT77IAdsi/kV7+Es7y+pXALeV3h7G6dQF6mNYjcLA=
-github.com/wailsapp/wails v0.0.0-20181215232634-5de8efff325d h1:lk91T4sKD98eGcaz/xC6ER+3o9Kaun7Mk8e/cNZOPMc=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@@ -301,6 +318,7 @@ golang.org/x/crypto v0.0.0-20181025213731-e84da0312774/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20181106171534-e4dc69e5b2fd/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181112202954-3d3f9f413869/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181127143415-eb0de9b17e85/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 h1:mKdxBk7AujPs8kU4m80U72y/zjbZ3UcXC7dClwKbUI0=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180816102801-aaf60122140d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -315,6 +333,10 @@ golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181207154023-610586996380/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190107155100-1a61f4433d85 h1:3DfFuyqY+mca6oIDfim5rft3+Kl/CHLe7RdPrUMzwv0=
+golang.org/x/net v0.0.0-20190107155100-1a61f4433d85/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180816055513-1c9583448a9c/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -334,6 +356,8 @@ golang.org/x/sys v0.0.0-20181106135930-3a76605856fd/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181206074257-70b957f3b65e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181228144115-9a3f9b0469bb h1:pf3XwC90UUdNPYWZdFjhGBE7DUFuK3Ct1zWmZ65QN30=
+golang.org/x/sys v0.0.0-20181228144115-9a3f9b0469bb/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181003024731-2f84ea8ef872/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

ipc_call.go

@@ -0,0 +1,38 @@
+package wails
+
+import (
+	"fmt"
+)
+
+type callData struct {
+	BindingName string `json:"bindingName"`
+	Data        string `json:"data,omitempty"`
+}
+
+func init() {
+	messageProcessors["call"] = processCallData
+}
+
+func processCallData(message *ipcMessage) (*ipcMessage, error) {
+
+	var payload callData
+
+	// Decode binding call data
+	payloadMap := message.Payload.(map[string]interface{})
+
+	// Check for binding name
+	if payloadMap["bindingName"] == nil {
+		return nil, fmt.Errorf("bindingName not given in call")
+	}
+	payload.BindingName = payloadMap["bindingName"].(string)
+
+	// Check for data
+	if payloadMap["data"] != nil {
+		payload.Data = payloadMap["data"].(string)
+	}
+
+	// Reassign payload to decoded data
+	message.Payload = &payload
+
+	return message, nil
+}

ipc_event.go

@@ -0,0 +1,40 @@
+package wails
+
+import (
+	"encoding/json"
+)
+
+type eventData struct {
+	Name string      `json:"name"`
+	Data interface{} `json:"data"`
+}
+
+// Register the message handler
+func init() {
+	messageProcessors["event"] = processEventData
+}
+
+// This processes the given event message
+func processEventData(message *ipcMessage) (*ipcMessage, error) {
+
+	// TODO: Is it worth double checking this is actually an event message,
+	// even though that's done by the caller?
+	var payload eventData
+
+	// Decode event data
+	payloadMap := message.Payload.(map[string]interface{})
+	payload.Name = payloadMap["name"].(string)
+
+	// decode the payload data
+	var data []interface{}
+	err := json.Unmarshal([]byte(payloadMap["data"].(string)), &data)
+	if err != nil {
+		return nil, err
+	}
+	payload.Data = data
+
+	// Reassign payload to decoded data
+	message.Payload = &payload
+
+	return message, nil
+}

ipc_log.go

@@ -0,0 +1,27 @@
+package wails
+
+type logData struct {
+	Level   string `json:"level"`
+	Message string `json:"string"`
+}
+
+// Register the message handler
+func init() {
+	messageProcessors["log"] = processLogData
+}
+
+// This processes the given log message
+func processLogData(message *ipcMessage) (*ipcMessage, error) {
+
+	var payload logData
+
+	// Decode event data
+	payloadMap := message.Payload.(map[string]interface{})
+	payload.Level = payloadMap["level"].(string)
+	payload.Message = payloadMap["message"].(string)
+
+	// Reassign payload to decoded data
+	message.Payload = &payload
+
+	return message, nil
+}

ipc_manager.go

@@ -0,0 +1,162 @@
+package wails
+
+import (
+	"fmt"
+)
+
+type ipcManager struct {
+	renderer     Renderer // The renderer
+	messageQueue chan *ipcMessage
+	// quitChannel  chan struct{}
+	// signals      chan os.Signal
+	log            *CustomLogger
+	eventManager   *eventManager
+	bindingManager *bindingManager
+}
+
+func newIPCManager() *ipcManager {
+	result := &ipcManager{
+		messageQueue: make(chan *ipcMessage, 100),
+		// 		quitChannel:  make(chan struct{}),
+		// 		signals:      make(chan os.Signal, 1),
+		log: newCustomLogger("IPC"),
+	}
+	return result
+}
+
+// Sets the renderer, returns the dispatch function
+func (i *ipcManager) bindRenderer(renderer Renderer) {
+	i.renderer = renderer
+}
+
+func (i *ipcManager) start(eventManager *eventManager, bindingManager *bindingManager) {
+
+	// Store manager references
+	i.eventManager = eventManager
+	i.bindingManager = bindingManager
+
+	i.log.Info("Starting")
+	// signal.Notify(manager.signals, os.Interrupt)
+	go func() {
+		running := true
+		for running {
+			select {
+			case incomingMessage := <-i.messageQueue:
+				i.log.DebugFields("Processing message", Fields{
+					"1D": &incomingMessage,
+				})
+				switch incomingMessage.Type {
+				case "call":
+					callData := incomingMessage.Payload.(*callData)
+					i.log.DebugFields("Processing call", Fields{
+						"1D":          &incomingMessage,
+						"bindingName": callData.BindingName,
+						"data":        callData.Data,
+					})
+					go func() {
+						result, err := bindingManager.processCall(callData)
+						i.log.DebugFields("processed call", Fields{"result": result, "err": err})
+						if err != nil {
+							incomingMessage.ReturnError(err.Error())
+						} else {
+							incomingMessage.ReturnSuccess(result)
+						}
+						i.log.DebugFields("Finished processing call", Fields{
+							"1D": &incomingMessage,
+						})
+					}()
+				case "event":
+
+					// Extract event data
+					eventData := incomingMessage.Payload.(*eventData)
+
+					// Log
+					i.log.DebugFields("Processing event", Fields{
+						"name": eventData.Name,
+						"data": eventData.Data,
+					})
+
+					// Push the event to the event manager
+					i.eventManager.PushEvent(eventData)
+
+					// Log
+					i.log.DebugFields("Finished processing event", Fields{
+						"name": eventData.Name,
+					})
+				case "log":
+					logdata := incomingMessage.Payload.(*logData)
+					switch logdata.Level {
+					case "info":
+						logger.Info(logdata.Message)
+					case "debug":
+						logger.Debug(logdata.Message)
+					case "warning":
+						logger.Warning(logdata.Message)
+					case "error":
+						logger.Error(logdata.Message)
+					case "fatal":
+						logger.Fatal(logdata.Message)
+					default:
+						i.log.ErrorFields("Invalid log level sent", Fields{
+							"level":   logdata.Level,
+							"message": logdata.Message,
+						})
+					}
+				default:
+					i.log.Debugf("bad message sent to MessageQueue! Unknown type: %s", incomingMessage.Type)
+				}
+
+				// Log
+				i.log.DebugFields("Finished processing message", Fields{
+					"1D": &incomingMessage,
+				})
+				// 			case <-manager.quitChannel:
+				// 				Debug("[MessageQueue] Quit caught")
+				// 				running = false
+				// 			case <-manager.signals:
+				// 				Debug("[MessageQueue] Signal caught")
+				// 				running = false
+			}
+		}
+		i.log.Debug("Stopping")
+	}()
+}
+
+// Dispatch receives JSON encoded messages from the renderer.
+// It processes the message to ensure that it is valid and places
+// the processed message on the message queue
+func (i *ipcManager) Dispatch(message string) {
+
+	// Create a new IPC Message
+	incomingMessage, err := newIPCMessage(message, i.SendResponse)
+	if err != nil {
+		i.log.ErrorFields("Could not understand incoming message! ", map[string]interface{}{
+			"message": message,
+			"error":   err,
+		})
+		return
+	}
+
+	// Put message on queue
+	i.log.DebugFields("Message received", map[string]interface{}{
+		"type":    incomingMessage.Type,
+		"payload": incomingMessage.Payload,
+	})
+
+	// Put incoming message on the message queue
+	i.messageQueue <- incomingMessage
+}
+
+// SendResponse sends the given response back to the frontend
+func (i *ipcManager) SendResponse(response *ipcResponse) error {
+
+	// Serialise the Message
+	data, err := response.Serialise()
+	if err != nil {
+		fmt.Printf(err.Error())
+		return err
+	}
+
+	// Call back to the front end
+	return i.renderer.Callback(data)
+}

ipc_message.go

@@ -0,0 +1,93 @@
+package wails
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Message handler
+type messageProcessorFunc func(*ipcMessage) (*ipcMessage, error)
+
+var messageProcessors = make(map[string]messageProcessorFunc)
+
+// ipcMessage is the struct version of the Message sent from the frontend.
+// The payload has the specialised message data
+type ipcMessage struct {
+	Type         string      `json:"type"`
+	Payload      interface{} `json:"payload"`
+	CallbackID   string      `json:"callbackid,omitempty"`
+	sendResponse func(*ipcResponse) error
+}
+
+func parseMessage(incomingMessage string) (*ipcMessage, error) {
+	// Parse message
+	var message ipcMessage
+	err := json.Unmarshal([]byte(incomingMessage), &message)
+	return &message, err
+}
+
+func newIPCMessage(incomingMessage string, responseFunction func(*ipcResponse) error) (*ipcMessage, error) {
+
+	// Parse the Message
+	message, err := parseMessage(incomingMessage)
+	if err != nil {
+		return nil, err
+	}
+
+	// Check message type is valid
+	messageProcessor := messageProcessors[message.Type]
+	if messageProcessor == nil {
+		return nil, fmt.Errorf("unknown message type: %s", message.Type)
+	}
+
+	// Process message payload
+	message, err = messageProcessor(message)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set the response function
+	message.sendResponse = responseFunction
+
+	return message, nil
+}
+
+// hasCallbackID checks if the message can send an error back to the frontend
+func (m *ipcMessage) hasCallbackID() error {
+	if m.CallbackID == "" {
+		return fmt.Errorf("attempted to return error to message with no Callback ID")
+	}
+	return nil
+}
+
+// ReturnError returns an error back to the frontend
+func (m *ipcMessage) ReturnError(format string, args ...interface{}) error {
+
+	// Ignore ReturnError if no callback ID given
+	err := m.hasCallbackID()
+	if err != nil {
+		return err
+	}
+
+	// Create response
+	response := newErrorResponse(m.CallbackID, fmt.Sprintf(format, args...))
+
+	// Send response
+	return m.sendResponse(response)
+}
+
+// ReturnSuccess returns a success message back with the given data
+func (m *ipcMessage) ReturnSuccess(data interface{}) error {
+
+	// Ignore ReturnSuccess if no callback ID given
+	err := m.hasCallbackID()
+	if err != nil {
+		return err
+	}
+
+	// Create the response
+	response := newSuccessResponse(m.CallbackID, data)
+
+	// Send response
+	return m.sendResponse(response)
+}

ipc_response.go

@@ -0,0 +1,43 @@
+package wails
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+// ipcResponse contains the response data from an RPC call
+type ipcResponse struct {
+	CallbackID   string      `json:"callbackid"`
+	ErrorMessage string      `json:"error,omitempty"`
+	Data         interface{} `json:"data,omitempty"`
+}
+
+// newErrorResponse returns the given error message to the frontend with the callbackid
+func newErrorResponse(callbackID string, errorMessage string) *ipcResponse {
+	// Create response object
+	result := &ipcResponse{
+		CallbackID:   callbackID,
+		ErrorMessage: errorMessage,
+	}
+	return result
+}
+
+// newSuccessResponse returns the given data to the frontend with the callbackid
+func newSuccessResponse(callbackID string, data interface{}) *ipcResponse {
+
+	// Create response object
+	result := &ipcResponse{
+		CallbackID: callbackID,
+		Data:       data,
+	}
+
+	return result
+}
+
+// Serialise formats the response to a string
+func (i *ipcResponse) Serialise() (string, error) {
+	b, err := json.Marshal(i)
+	result := strings.Replace(string(b), "\\", "\\\\", -1)
+	result = strings.Replace(result, "'", "\\'", -1)
+	return result, err
+}

licenses/github.com/AlecAivazis/survey/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Alec Aivazis
+
+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.

licenses/github.com/dchest/cssmin/LICENSE

@@ -0,0 +1,29 @@
+Go Port:
+Copyright (c) 2013 Dmitry Chestnykh <dmitry@codingrobots.com>
+
+Original:
+Copyright (c) 2008 Ryan Grove <ryan@wonko.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of this project nor the names of its contributors may be
+    used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/github.com/dchest/htmlmin/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2013 Dmitry Chestnykh. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/github.com/fatih/color/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Fatih Arslan
+
+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.

licenses/github.com/go-playground/colors/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dean Karn
+
+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.
+

licenses/github.com/gobuffalo/envy/LICENSE.txt

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2018 Mark Bates
+
+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.

licenses/github.com/gobuffalo/packd/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mark Bates
+
+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.

licenses/github.com/gobuffalo/packr/LICENSE.txt

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2016 Mark Bates
+
+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.

licenses/github.com/gobuffalo/syncx/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mark Bates
+
+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.

licenses/github.com/gorilla/websocket/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 The Gorilla WebSocket Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+  Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/github.com/jackmordaunt/icns/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jack Mordaunt
+
+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.

licenses/github.com/kballard/go-shellquote/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2014 Kevin Ballard
+
+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.

licenses/github.com/konsorten/go-windows-terminal-sequences/LICENSE

@@ -0,0 +1,9 @@
+(The MIT License)
+
+Copyright (c) 2017 marvin + konsorten GmbH (open-source@konsorten.de)
+
+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.

licenses/github.com/leaanthony/slicer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Lea Anthony
+
+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.

licenses/github.com/leaanthony/spinner/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Lea Anthony
+
+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.

licenses/github.com/leaanthony/wincursor/LICENSE

@@ -1,7 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2011-2018 Twitter, Inc.
-Copyright (c) 2011-2018 The Bootstrap Authors
+Copyright (c) 2018-Present Lea Anthony
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

licenses/github.com/markbates/oncer/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mark Bates
+
+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.

licenses/github.com/mattn/go-colorable/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Yasuhiro Matsumoto
+
+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.

licenses/github.com/mattn/go-isatty/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>
+
+MIT License (Expat)
+
+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.

licenses/github.com/mgutz/ansi/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+Copyright (c) 2013 Mario L. Gutierrez
+
+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.
+

licenses/github.com/mitchellh/go-homedir/LICENSE

@@ -1,7 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2011-2018 Twitter, Inc.
-Copyright (c) 2011-2018 The Bootstrap Authors
+Copyright (c) 2013 Mitchell Hashimoto
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +18,4 @@ 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.
+THE SOFTWARE.

licenses/github.com/nfnt/resize/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012, Jan Schlicht <jan.schlicht@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

licenses/github.com/pkg/errors/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Dave Cheney <dave@cheney.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/github.com/sirupsen/logrus/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+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.

licenses/golang.org/x/crypto/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/golang.org/x/net/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/golang.org/x/sys/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

licenses/gopkg.in/AlecAivazis/survey.v1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Alec Aivazis
+
+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.

licenses/gopkg.in/AlecAivazis/survey.v1/terminal/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Takashi Kokubun
+
+MIT License
+
+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.

log.go

@@ -0,0 +1,42 @@
+package wails
+
+import (
+	"os"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// Global logger reference
+var logger = log.New()
+
+// Fields is used by the customLogger object to output
+// fields along with a message
+type Fields map[string]interface{}
+
+// Default options for the global logger
+func init() {
+	logger.SetOutput(os.Stdout)
+	logger.SetLevel(log.DebugLevel)
+}
+
+// Sets the log level to the given level
+func setLogLevel(level string) {
+	switch strings.ToLower(level) {
+	case "info":
+		logger.SetLevel(log.InfoLevel)
+	case "debug":
+		logger.SetLevel(log.DebugLevel)
+	case "warn":
+		logger.SetLevel(log.WarnLevel)
+	case "error":
+		logger.SetLevel(log.ErrorLevel)
+	case "fatal":
+		logger.SetLevel(log.FatalLevel)
+	case "panic":
+		logger.SetLevel(log.PanicLevel)
+	default:
+		logger.SetLevel(log.DebugLevel)
+		logger.Warnf("Log level '%s' not recognised. Setting to Debug.", level)
+	}
+}

log_custom.go

@@ -0,0 +1,103 @@
+package wails
+
+// CustomLogger is a wrapper object to logrus
+type CustomLogger struct {
+	prefix    string
+	errorOnly bool
+}
+
+func newCustomLogger(prefix string) *CustomLogger {
+	return &CustomLogger{
+		prefix: "[" + prefix + "] ",
+	}
+}
+
+// Info level message
+func (c *CustomLogger) Info(message string) {
+	logger.Info(c.prefix + message)
+}
+
+// Infof - formatted message
+func (c *CustomLogger) Infof(message string, args ...interface{}) {
+	logger.Infof(c.prefix+message, args...)
+}
+
+// InfoFields - message with fields
+func (c *CustomLogger) InfoFields(message string, fields Fields) {
+	logger.WithFields(map[string]interface{}(fields)).Info(c.prefix + message)
+}
+
+// Debug level message
+func (c *CustomLogger) Debug(message string) {
+	logger.Debug(c.prefix + message)
+}
+
+// Debugf - formatted message
+func (c *CustomLogger) Debugf(message string, args ...interface{}) {
+	logger.Debugf(c.prefix+message, args...)
+}
+
+// DebugFields - message with fields
+func (c *CustomLogger) DebugFields(message string, fields Fields) {
+	logger.WithFields(map[string]interface{}(fields)).Debug(c.prefix + message)
+}
+
+// Warn level message
+func (c *CustomLogger) Warn(message string) {
+	logger.Warn(c.prefix + message)
+}
+
+// Warnf - formatted message
+func (c *CustomLogger) Warnf(message string, args ...interface{}) {
+	logger.Warnf(c.prefix+message, args...)
+}
+
+// WarnFields - message with fields
+func (c *CustomLogger) WarnFields(message string, fields Fields) {
+	logger.WithFields(map[string]interface{}(fields)).Warn(c.prefix + message)
+}
+
+// Error level message
+func (c *CustomLogger) Error(message string) {
+	logger.Error(c.prefix + message)
+}
+
+// Errorf - formatted message
+func (c *CustomLogger) Errorf(message string, args ...interface{}) {
+	logger.Errorf(c.prefix+message, args...)
+}
+
+// ErrorFields - message with fields
+func (c *CustomLogger) ErrorFields(message string, fields Fields) {
+	logger.WithFields(map[string]interface{}(fields)).Error(c.prefix + message)
+}
+
+// Fatal level message
+func (c *CustomLogger) Fatal(message string) {
+	logger.Fatal(c.prefix + message)
+}
+
+// Fatalf - formatted message
+func (c *CustomLogger) Fatalf(message string, args ...interface{}) {
+	logger.Fatalf(c.prefix+message, args...)
+}
+
+// FatalFields - message with fields
+func (c *CustomLogger) FatalFields(message string, fields Fields) {
+	logger.WithFields(map[string]interface{}(fields)).Fatal(c.prefix + message)
+}
+
+// Panic level message
+func (c *CustomLogger) Panic(message string) {
+	logger.Panic(c.prefix + message)
+}
+
+// Panicf - formatted message
+func (c *CustomLogger) Panicf(message string, args ...interface{}) {
+	logger.Panicf(c.prefix+message, args...)
+}
+
+// PanicFields - message with fields
+func (c *CustomLogger) PanicFields(message string, fields Fields) {
+	logger.WithFields(map[string]interface{}(fields)).Panic(c.prefix + message)
+}

renderer.go

@@ -0,0 +1,30 @@
+package wails
+
+// Renderer is an interface describing a Wails target to render the app to
+type Renderer interface {
+	Initialise(*AppConfig, *ipcManager, *eventManager) error
+	Run() error
+
+	// Binding
+	NewBinding(bindingName string) error
+	Callback(data string) error
+
+	// Events
+	NotifyEvent(eventData *eventData) error
+
+	// Injection
+	AddJSList(js []string)
+	AddCSSList(css []string)
+
+	// Dialog Runtime
+	SelectFile() string
+	SelectDirectory() string
+	SelectSaveFile() string
+
+	// Window Runtime
+	SetColour(string) error
+	Fullscreen()
+	UnFullscreen()
+	SetTitle(title string)
+	Close()
+}

renderer_headless.go

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

renderer_webview.go

@@ -0,0 +1,369 @@
+package wails
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"sync"
+	"time"
+
+	"github.com/go-playground/colors"
+	"github.com/gobuffalo/packr"
+	"github.com/wailsapp/wails/webview"
+)
+
+// Window defines the main application window
+// Default values in []
+type webViewRenderer struct {
+	window       webview.WebView // The webview object
+	ipc          *ipcManager
+	log          *CustomLogger
+	config       *AppConfig
+	eventManager *eventManager
+	bindingCache []string
+	frameworkJS  string
+	frameworkCSS string
+
+	// This is a list of all the JS/CSS that needs injecting
+	// It will get injected in order
+	jsCache  []string
+	cssCache []string
+}
+
+// Initialise sets up the WebView
+func (w *webViewRenderer) Initialise(config *AppConfig, ipc *ipcManager, eventManager *eventManager) error {
+
+	// Store reference to eventManager
+	w.eventManager = eventManager
+
+	// Set up logger
+	w.log = newCustomLogger("WebView")
+
+	// Set up the dispatcher function
+	w.ipc = ipc
+	ipc.bindRenderer(w)
+
+	// Save the config
+	w.config = config
+
+	// Create the WebView instance
+	w.window = webview.NewWebview(webview.Settings{
+		Width:     config.Width,
+		Height:    config.Height,
+		Title:     config.Title,
+		Resizable: config.Resizable,
+		URL:       config.defaultHTML,
+		Debug:     !config.DisableInspector,
+		ExternalInvokeCallback: func(_ webview.WebView, message string) {
+			w.ipc.Dispatch(message)
+		},
+	})
+
+	// SignalManager.OnExit(w.Exit)
+
+	// Set colour
+	err := w.SetColour(config.Colour)
+	if err != nil {
+		return err
+	}
+
+	w.log.Info("Initialised")
+	return nil
+}
+
+func (w *webViewRenderer) SetColour(colour string) error {
+	color, err := colors.Parse(colour)
+	if err != nil {
+		return err
+	}
+	rgba := color.ToRGBA()
+	alpha := uint8(255 * rgba.A)
+	w.window.Dispatch(func() {
+		w.window.SetColor(rgba.R, rgba.G, rgba.B, alpha)
+	})
+
+	return nil
+}
+
+// evalJS evaluates the given js in the WebView
+// I should rename this to evilJS lol
+func (w *webViewRenderer) evalJS(js string) error {
+	outputJS := fmt.Sprintf("%.45s", js)
+	if len(js) > 45 {
+		outputJS += "..."
+	}
+	w.log.DebugFields("Eval", Fields{"js": outputJS})
+	//
+	w.window.Dispatch(func() {
+		w.window.Eval(js)
+	})
+	return nil
+}
+
+// evalJSSync evaluates the given js in the WebView synchronously
+// Do not call this from the main thread or you'll nuke your app because
+// you won't get the callback.
+func (w *webViewRenderer) evalJSSync(js string) error {
+
+	minified, err := escapeJS(js)
+	if err != nil {
+		return err
+	}
+
+	outputJS := fmt.Sprintf("%.45s", js)
+	if len(js) > 45 {
+		outputJS += "..."
+	}
+	w.log.DebugFields("EvalSync", Fields{"js": outputJS})
+
+	ID := fmt.Sprintf("syncjs:%d:%d", time.Now().Unix(), rand.Intn(9999))
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	go func() {
+		exit := false
+		// We are done when we recieve the Callback ID
+		w.log.Debug("SyncJS: sending with ID = " + ID)
+		w.eventManager.On(ID, func(...interface{}) {
+			w.log.Debug("SyncJS: Got callback ID = " + ID)
+			wg.Done()
+			exit = true
+		})
+		command := fmt.Sprintf("wails._.addScript('%s', '%s')", minified, ID)
+		w.window.Dispatch(func() {
+			w.window.Eval(command)
+		})
+		for exit == false {
+			time.Sleep(time.Millisecond * 1)
+		}
+	}()
+
+	wg.Wait()
+
+	return nil
+}
+
+// injectCSS adds the given CSS to the WebView
+func (w *webViewRenderer) injectCSS(css string) {
+	w.window.Dispatch(func() {
+		w.window.InjectCSS(css)
+	})
+}
+
+// Quit the window
+func (w *webViewRenderer) Exit() {
+	w.window.Exit()
+}
+
+// Run the window main loop
+func (w *webViewRenderer) Run() error {
+
+	w.log.Info("Run()")
+
+	// Runtime assets
+	assets := packr.NewBox("./assets/default")
+
+	wailsRuntime := BoxString(&assets, "wails.js")
+	w.evalJS(wailsRuntime)
+
+	// Ping the wait channel when the wails runtime is loaded
+	w.eventManager.On("wails:loaded", func(...interface{}) {
+
+		// Run this in a different go routine to free up the main process
+		go func() {
+
+			// Inject Bindings
+			for _, binding := range w.bindingCache {
+				w.evalJSSync(binding)
+			}
+
+			// Inject Framework
+			if w.frameworkJS != "" {
+				w.evalJSSync(w.frameworkJS)
+			}
+			if w.frameworkCSS != "" {
+				w.injectCSS(w.frameworkCSS)
+			}
+
+			// Inject user CSS
+			if w.config.CSS != "" {
+				outputCSS := fmt.Sprintf("%.45s", w.config.CSS)
+				if len(outputCSS) > 45 {
+					outputCSS += "..."
+				}
+				w.log.DebugFields("Inject User CSS", Fields{"css": outputCSS})
+				w.injectCSS(w.config.CSS)
+			} else {
+				// Use default wails css
+				w.log.Debug("Injecting Default Wails CSS")
+				defaultCSS := BoxString(&defaultAssets, "wails.css")
+
+				w.injectCSS(defaultCSS)
+			}
+
+			// Inject all the CSS files that have been added
+			for _, css := range w.cssCache {
+				w.injectCSS(css)
+			}
+
+			// Inject all the JS files that have been added
+			for _, js := range w.jsCache {
+				w.evalJSSync(js)
+			}
+
+			// Inject user JS
+			if w.config.JS != "" {
+				outputJS := fmt.Sprintf("%.45s", w.config.JS)
+				if len(outputJS) > 45 {
+					outputJS += "..."
+				}
+				w.log.DebugFields("Inject User JS", Fields{"js": outputJS})
+				w.evalJSSync(w.config.JS)
+			}
+
+			// Emit that everything is loaded and ready
+			w.eventManager.Emit("wails:ready")
+		}()
+	})
+
+	// Kick off main window loop
+	w.window.Run()
+
+	return nil
+}
+
+// Binds the given method name with the front end
+func (w *webViewRenderer) NewBinding(methodName string) error {
+	objectCode := fmt.Sprintf("window.wails._.newBinding('%s');", methodName)
+	w.bindingCache = append(w.bindingCache, objectCode)
+	return nil
+}
+
+func (w *webViewRenderer) SelectFile() string {
+	var result string
+
+	// We need to run this on the main thread, however Dispatch is
+	// non-blocking so we launch this in a goroutine and wait for
+	// dispatch to finish before returning the result
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		w.window.Dispatch(func() {
+			result = w.window.Dialog(webview.DialogTypeOpen, 0, "Select File", "")
+			wg.Done()
+		})
+	}()
+	wg.Wait()
+	return result
+}
+
+func (w *webViewRenderer) SelectDirectory() string {
+	var result string
+	// We need to run this on the main thread, however Dispatch is
+	// non-blocking so we launch this in a goroutine and wait for
+	// dispatch to finish before returning the result
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		w.window.Dispatch(func() {
+			result = w.window.Dialog(webview.DialogTypeOpen, webview.DialogFlagDirectory, "Select Directory", "")
+			wg.Done()
+		})
+	}()
+	wg.Wait()
+	return result
+}
+
+func (w *webViewRenderer) SelectSaveFile() string {
+	var result string
+	// We need to run this on the main thread, however Dispatch is
+	// non-blocking so we launch this in a goroutine and wait for
+	// dispatch to finish before returning the result
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		w.window.Dispatch(func() {
+			result = w.window.Dialog(webview.DialogTypeSave, 0, "Save file", "")
+			wg.Done()
+		})
+	}()
+	wg.Wait()
+	return result
+}
+
+// AddJS adds a piece of Javascript to a cache that
+// gets injected at runtime
+func (w *webViewRenderer) AddJSList(jsCache []string) {
+	w.jsCache = jsCache
+}
+
+// AddCSSList sets the cssCache to the given list of strings
+func (w *webViewRenderer) AddCSSList(cssCache []string) {
+	w.cssCache = cssCache
+}
+
+// Callback sends a callback to the frontend
+func (w *webViewRenderer) Callback(data string) error {
+	callbackCMD := fmt.Sprintf("window.wails._.callback('%s');", data)
+	return w.evalJS(callbackCMD)
+}
+
+func (w *webViewRenderer) NotifyEvent(event *eventData) error {
+
+	// Look out! Nils about!
+	var err error
+	if event == nil {
+		err = fmt.Errorf("Sent nil event to renderer.webViewRenderer")
+		logger.Error(err)
+		return err
+	}
+
+	// Default data is a blank array
+	data := []byte("[]")
+
+	// Process event data
+	if event.Data != nil {
+		// Marshall the data
+		data, err = json.Marshal(event.Data)
+		if err != nil {
+			w.log.Errorf("Cannot unmarshall JSON data in event: %s ", err.Error())
+			return err
+		}
+	}
+
+	message := fmt.Sprintf("wails._.notify('%s','%s')", event.Name, data)
+	return w.evalJS(message)
+}
+
+// Window
+func (w *webViewRenderer) Fullscreen() {
+	if w.config.Resizable == false {
+		w.log.Warn("Cannot call Fullscreen() - App.Resizable = false")
+		return
+	}
+	w.window.Dispatch(func() {
+		w.window.SetFullscreen(true)
+	})
+}
+
+func (w *webViewRenderer) UnFullscreen() {
+	if w.config.Resizable == false {
+		w.log.Warn("Cannot call UnFullscreen() - App.Resizable = false")
+		return
+	}
+	w.window.Dispatch(func() {
+		w.window.SetFullscreen(false)
+	})
+}
+
+func (w *webViewRenderer) SetTitle(title string) {
+	w.window.Dispatch(func() {
+		w.window.SetTitle(title)
+	})
+}
+
+func (w *webViewRenderer) Close() {
+	w.window.Dispatch(func() {
+		w.window.Terminate()
+	})
+}

runtime.go

@@ -0,0 +1,18 @@
+package wails
+
+// Runtime is the Wails Runtime Interface, given to a user who has defined the WailsInit method
+type Runtime struct {
+	Events *RuntimeEvents
+	Log    *RuntimeLog
+	Dialog *RuntimeDialog
+	Window *RuntimeWindow
+}
+
+func newRuntime(eventManager *eventManager, renderer Renderer) *Runtime {
+	return &Runtime{
+		Events: newRuntimeEvents(eventManager),
+		Log:    newRuntimeLog(),
+		Dialog: newRuntimeDialog(renderer),
+		Window: newRuntimeWindow(renderer),
+	}
+}