Develop (#250)

runtime/js/.eslintrc

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

runtime/js/babel.config.js

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

runtime/js/core/bindings.js

@@ -0,0 +1,94 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Call } from './calls';
+
+window.backend = {};
+
+/**
+ * Determines if the given identifier is valid Javascript
+ *
+ * @param {boolean} name
+ * @returns
+ */
+function isValidIdentifier(name) {
+	// Don't xss yourself :-)
+	try {
+		new Function('var ' + name);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+/**
+ * NewBinding creates a new binding from the given binding name
+ *
+ * @export
+ * @param {string} bindingName
+ * @returns
+ */
+// eslint-disable-next-line max-lines-per-function
+export function NewBinding(bindingName) {
+
+	// Get all the sections of the binding
+	var bindingSections = [].concat(bindingName.split('.').splice(1));
+	var pathToBinding = window.backend;
+
+	// Check if we have a path (IE Struct)
+	if (bindingSections.length > 1) {
+		// Iterate over binding sections, adding them to the window.backend object
+		for (let index = 0; index < bindingSections.length-1; index += 1) {
+			const name = bindingSections[index];
+			// Is name a valid javascript identifier?
+			if (!isValidIdentifier(name)) {
+				return new Error(`${name} is not a valid javascript identifier.`);
+			}
+			if (!pathToBinding[name]) {
+				pathToBinding[name] = {};
+			}
+			pathToBinding = pathToBinding[name];
+		}
+	}
+
+	// Get the actual function/method call name
+	const name = bindingSections.pop();
+
+	// Is name a valid javascript identifier?
+	if (!isValidIdentifier(name)) {
+		return new Error(`${name} is not a valid javascript identifier.`);
+	}
+
+	// Add binding call
+	pathToBinding[name] = 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;
+	}();
+}

runtime/js/core/browser.js

@@ -0,0 +1,34 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { SystemCall } from './calls';
+
+/**
+ * Opens the given URL in the system browser
+ *
+ * @export
+ * @param {string} url
+ * @returns
+ */
+export function OpenURL(url) {
+	return SystemCall('Browser.OpenURL', url);
+}
+
+/**
+ * Opens the given filename using the system's default file handler
+ *
+ * @export
+ * @param {sting} filename
+ * @returns
+ */
+export function OpenFile(filename) {
+	return SystemCall('Browser.OpenFile', filename);
+}

runtime/js/core/calls.js

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

runtime/js/core/events.js

@@ -0,0 +1,194 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Error } from './log';
+import { SendMessage } from './ipc';
+
+// Defines a single listener with a maximum number of times to callback
+/**
+ * The Listener class defines a listener! :-)
+ *
+ * @class Listener
+ */
+class Listener {
+	/**
+	 * Creates an instance of Listener.
+	 * @param {function} callback
+	 * @param {number} maxCallbacks
+	 * @memberof Listener
+	 */
+	constructor(callback, maxCallbacks) {
+		// Default of -1 means infinite
+		maxCallbacks = maxCallbacks || -1;
+		// Callback invokes the callback with the given data
+		// Returns true if this listener should be destroyed
+		this.Callback = (data) => {
+			callback.apply(null, data);
+			// If maxCallbacks is infinite, return false (do not destroy)
+			if (maxCallbacks === -1) {
+				return false;
+			}
+			// Decrement maxCallbacks. Return true if now 0, otherwise false
+			maxCallbacks -= 1;
+			return maxCallbacks === 0;
+		};
+	}
+}
+
+var eventListeners = {};
+
+/**
+ * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ * @param {number} maxCallbacks
+ */
+export function OnMultiple(eventName, callback, maxCallbacks) {
+	eventListeners[eventName] = eventListeners[eventName] || [];
+	const thisListener = new Listener(callback, maxCallbacks);
+	eventListeners[eventName].push(thisListener);
+}
+
+/**
+ * Registers an event listener that will be invoked every time the event is emitted
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ */
+export function On(eventName, callback) {
+	OnMultiple(eventName, callback);
+}
+
+/**
+ * Registers an event listener that will be invoked once then destroyed
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ */
+export function Once(eventName, callback) {
+	OnMultiple(eventName, callback, 1);
+}
+
+/**
+ * Notify informs frontend listeners that an event was emitted with the given data
+ *
+ * @export
+ * @param {string} eventName
+ * @param {string} data
+ */
+export function Notify(eventName, data) {
+
+	// Check if we have any listeners for this event
+	if (eventListeners[eventName]) {
+
+		// Keep a list of listener indexes to destroy
+		const newEventListenerList = eventListeners[eventName].slice();
+
+		// Iterate listeners
+		for (let count = 0; count < eventListeners[eventName].length; count += 1) {
+
+			// Get next listener
+			const listener = eventListeners[eventName][count];
+
+			// Parse data if we have it
+			var parsedData = [];
+			if (data) {
+				try {
+					parsedData = JSON.parse(data);
+				} catch (e) {
+					Error('Invalid JSON data sent to notify. Event name = ' + eventName);
+				}
+			}
+			// Do the callback
+			const destroy = listener.Callback(parsedData);
+			if (destroy) {
+				// if the listener indicated to destroy itself, add it to the destroy list
+				newEventListenerList.splice(count, 1);
+			}
+		}
+
+		// Update callbacks with new list of listners
+		eventListeners[eventName] = newEventListenerList;
+	}
+}
+
+/**
+ * Emit an event with the given name and data
+ *
+ * @export
+ * @param {string} eventName
+ */
+export function Emit(eventName) {
+
+	// Calculate the data
+	var data = JSON.stringify([].slice.apply(arguments).slice(1));
+
+	// Notify backend
+	const payload = {
+		name: eventName,
+		data: data,
+	};
+	SendMessage('event', payload);
+}
+
+// Callbacks for the heartbeat calls
+const heartbeatCallbacks = {};
+
+/**
+ * Heartbeat emits the event `eventName`, every `timeInMilliseconds` milliseconds until 
+ * the event is acknowledged via `Event.Acknowledge`. Once this happens, `callback` is invoked ONCE
+ *
+ * @export
+ * @param {string} eventName
+ * @param {number} timeInMilliseconds
+ * @param {function} callback
+ */
+export function Heartbeat(eventName, timeInMilliseconds, callback) {
+
+	// Declare interval variable
+	let interval = null;
+
+	// Setup callback
+	function dynamicCallback() {
+		// Kill interval
+		clearInterval(interval);
+		// Callback
+		callback();
+	}
+
+	// Register callback
+	heartbeatCallbacks[eventName] = dynamicCallback;
+
+	// Start emitting the event
+	interval = setInterval(function () {
+		Emit(eventName);
+	}, timeInMilliseconds);
+}
+
+/**
+ * Acknowledges a heartbeat event by name
+ *
+ * @export
+ * @param {string} eventName
+ */
+export function Acknowledge(eventName) {
+	// If we are waiting for acknowledgement for this event type
+	if (heartbeatCallbacks[eventName]) {
+		// Acknowledge!
+		heartbeatCallbacks[eventName]();
+	} else {
+		throw new Error(`Cannot acknowledge unknown heartbeat '${eventName}'`);
+	}
+}

runtime/js/core/ipc.js

@@ -0,0 +1,37 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Invoke sends the given message to the backend
+ *
+ * @param {string} message
+ */
+function Invoke(message) {
+	window.external.invoke(message);
+}
+
+/**
+ * Sends a message to the backend based on the given type, payload and callbackID
+ *
+ * @export
+ * @param {string} type
+ * @param {string} payload
+ * @param {string=} callbackID
+ */
+export function SendMessage(type, payload, callbackID) {
+	const message = {
+		type,
+		callbackID,
+		payload
+	};
+
+	Invoke(JSON.stringify(message));
+}

runtime/js/core/log.js

@@ -0,0 +1,80 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 6 */
+
+import { SendMessage } from './ipc';
+
+/**
+ * Sends a log message to the backend with the given level + message
+ *
+ * @param {string} level
+ * @param {string} message
+ */
+function sendLogMessage(level, message) {
+
+	// Log Message
+	const payload = {
+		level: level,
+		message: message,
+	};
+	SendMessage('log', payload);
+}
+
+/**
+ * Log the given debug message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Debug(message) {
+	sendLogMessage('debug', message);
+}
+
+/**
+ * Log the given info message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Info(message) {
+	sendLogMessage('info', message);
+}
+
+/**
+ * Log the given warning message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Warning(message) {
+	sendLogMessage('warning', message);
+}
+
+/**
+ * Log the given error message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Error(message) {
+	sendLogMessage('error', message);
+}
+
+/**
+ * Log the given fatal message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+export function Fatal(message) {
+	sendLogMessage('fatal', message);
+}
+

runtime/js/core/main.js

@@ -0,0 +1,55 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+import * as Log from './log';
+import * as Browser from './browser';
+import { On, OnMultiple, Emit, Notify, Heartbeat, Acknowledge } from './events';
+import { NewBinding } from './bindings';
+import { Callback } from './calls';
+import { AddScript, InjectCSS } from './utils';
+
+// Initialise global if not already
+window.wails = window.wails || {};
+window.backend = {};
+
+// Setup internal calls
+var internal = {
+	NewBinding,
+	Callback,
+	Notify,
+	AddScript,
+	InjectCSS,
+	Init,
+};
+
+// Setup runtime structure
+var runtime = {
+	Log,
+	Browser,
+	Events: {
+		On,
+		OnMultiple,
+		Emit,
+		Heartbeat,
+		Acknowledge,
+	},
+	_: internal,
+};
+
+// Augment global
+Object.assign(window.wails, runtime);
+
+// Emit loaded event
+Emit('wails:loaded');
+
+// Nothing to init in production
+export function Init(callback) {
+	callback();
+}

runtime/js/core/utils.js

@@ -0,0 +1,34 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+import { Emit } from './events';
+
+export function AddScript(js, callbackID) {
+	var script = document.createElement('script');
+	script.text = js;
+	document.body.appendChild(script);
+	if (callbackID) {
+		Emit(callbackID);
+	}
+}
+
+// Adapted from webview - thanks zserge!
+export function InjectCSS(css) {
+	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);
+}

runtime/js/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "wails-runtime",
+  "version": "1.0.0",
+  "description": "The Javascript Wails Runtime",
+  "main": "index.js",
+  "scripts": {
+    "build": "eslint core/ && npm run build:prod",
+    "build:prod": "webpack --env prod --colors",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wailsapp/runtime.git"
+  },
+  "keywords": [
+    "Wails",
+    "Go",
+    "Javascript",
+    "Runtime"
+  ],
+  "browserslist": [
+    "> 5%",
+    "IE 9"
+  ],
+  "author": "Lea Anthony <lea.anthony@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wailsapp/runtime/issues"
+  },
+  "homepage": "https://github.com/wailsapp/runtime#readme",
+  "devDependencies": {
+    "@babel/cli": "^7.5.0",
+    "@babel/core": "^7.5.4",
+    "@babel/plugin-transform-object-assign": "^7.2.0",
+    "@babel/preset-env": "^7.5.4",
+    "babel-loader": "^8.0.6",
+    "babel-preset-minify": "^0.5.0",
+    "core-js": "^3.1.4",
+    "eslint": "^6.2.2",
+    "webpack": "^4.35.3",
+    "webpack-cli": "^3.3.5"
+  }
+}

runtime/js/runtime/.npmignore

@@ -0,0 +1 @@
+bridge.js

runtime/js/runtime/README.md

@@ -0,0 +1,3 @@
+# Wails Runtime
+
+This module is the Javascript runtime library for the [Wails](https://wails.app) framework. It is intended to be installed as part of a [Wails](https://wails.app) project, not a standalone module.

runtime/js/runtime/browser.js

@@ -0,0 +1,37 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Opens the given URL in the system browser
+ *
+ * @export
+ * @param {string} url
+ * @returns
+ */
+function OpenURL(url) {
+	return window.wails.Browser.OpenURL(url);
+}
+
+/**
+ * Opens the given filename using the system's default file handler
+ *
+ * @export
+ * @param {sting} filename
+ * @returns
+ */
+function OpenFile(filename) {
+	return window.wails.Browser.OpenFile(filename);
+}
+
+module.exports = {
+	OpenURL,
+	OpenFile
+};

runtime/js/runtime/events.js

@@ -0,0 +1,89 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+
+/**
+ * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ * @param {number} maxCallbacks
+ */
+function OnMultiple(eventName, callback, maxCallbacks) {
+	window.wails.Events.OnMultiple(eventName, callback, maxCallbacks);
+}
+
+/**
+ * Registers an event listener that will be invoked every time the event is emitted
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ */
+function On(eventName, callback) {
+	OnMultiple(eventName, callback);
+}
+
+/**
+ * Registers an event listener that will be invoked once then destroyed
+ *
+ * @export
+ * @param {string} eventName
+ * @param {function} callback
+ */
+function Once(eventName, callback) {
+	OnMultiple(eventName, callback, 1);
+}
+
+
+/**
+ * Emit an event with the given name and data
+ *
+ * @export
+ * @param {string} eventName
+ */
+function Emit(eventName) {
+	return window.wails.Events.Emit(eventName);
+}
+
+
+/**
+ * Heartbeat emits the event `eventName`, every `timeInMilliseconds` milliseconds until 
+ * the event is acknowledged via `Event.Acknowledge`. Once this happens, `callback` is invoked ONCE
+ *
+ * @export
+ * @param {string} eventName
+ * @param {number} timeInMilliseconds
+ * @param {function} callback
+ */
+function Heartbeat(eventName, timeInMilliseconds, callback) {
+	window.wails.Events.Heartbeat(eventName, timeInMilliseconds, callback);
+}
+
+/**
+ * Acknowledges a heartbeat event by name
+ *
+ * @export
+ * @param {string} eventName 
+ */
+function Acknowledge(eventName) {
+	return window.wails.Events.Acknowledge(eventName);
+}
+
+module.exports = {
+	OnMultiple,
+	On,
+	Once,
+	Emit,
+	Heartbeat,
+	Acknowledge
+};

runtime/js/runtime/init.js

@@ -0,0 +1,21 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+/**
+ * Initialises the Wails runtime
+ *
+ * @param {function} callback
+ */
+function Init(callback) {
+	window.wails._.Init(callback);
+}
+
+module.exports = Init;

runtime/js/runtime/log.js

@@ -0,0 +1,70 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 6 */
+
+
+/**
+ * Log the given debug message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+function Debug(message) {
+	window.wails.Log.Debug(message);
+}
+
+/**
+ * Log the given info message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+function Info(message) {
+	window.wails.Log.Info(message);
+}
+
+/**
+ * Log the given warning message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+function Warning(message) {
+	window.wails.Log.Warning(message);
+}
+
+/**
+ * Log the given error message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+function Error(message) {
+	window.wails.Log.Error(message);
+}
+
+/**
+ * Log the given fatal message with the backend
+ *
+ * @export
+ * @param {string} message
+ */
+function Fatal(message) {
+	window.wails.Log.Fatal(message);
+}
+
+module.exports = {
+	Debug,
+	Info,
+	Warning,
+	Error,
+	Fatal
+};

runtime/js/runtime/main.js

@@ -0,0 +1,22 @@
+/*
+ _       __      _ __    
+| |     / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  ) 
+|__/|__/\__,_/_/_/____/  
+The lightweight framework for web-like apps
+(c) Lea Anthony 2019-present
+*/
+/* jshint esversion: 6 */
+
+const Log = require('./log');
+const Browser = require('./browser');
+const Events = require('./events');
+const Init = require('./init');
+
+module.exports = {
+	Log,
+	Browser,
+	Events,
+	Init
+};

runtime/js/runtime/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@wailsapp/runtime",
+  "version": "1.0.6",
+  "description": "Wails Javascript runtime library",
+  "main": "main.js",
+  "types": "runtime.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wailsapp/wails.git"
+  },
+  "keywords": [
+    "Wails",
+    "Javascript",
+    "Go"
+  ],
+  "author": "Lea Anthony <lea.anthony@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wailsapp/wails/issues"
+  },
+  "homepage": "https://github.com/wailsapp/wails#readme",
+  "devDependencies": {
+    "dts-gen": "^0.5.8"
+  }
+}

runtime/js/runtime/runtime.d.ts

@@ -0,0 +1,26 @@
+export = wailsapp__runtime;
+
+declare const wailsapp__runtime: {
+    Browser: {
+        OpenFile(filename: string): Promise<any>;
+        OpenURL(url: string): Promise<any>;
+    };
+    Events: {
+        Acknowledge(eventName: string): void; 
+        Emit(eventName: string): void;
+        Heartbeat(eventName: string, timeInMilliseconds: number, callback: () => void): void;
+        On(eventName: string, callback: () => void): void;
+        OnMultiple(eventName: string, callback: () => void, maxCallbacks: number): void;
+        Once(eventName: string, callback: () => void): void;
+    };
+    Init(callback: () => void): void;
+    Log: {
+        Debug(message: string): void;
+        Error(message: string): void;
+        Fatal(message: string): void;
+        Info(message: string): void;
+        Warning(message: string): void;
+    };
+};
+
+

runtime/js/webpack.config.js

@@ -0,0 +1,4 @@
+/* eslint-disable */
+module.exports = (env) => {
+  return require(`./webpack.${env}.js`);
+};

runtime/js/webpack.prod.js

@@ -0,0 +1,38 @@
+/* eslint-disable */
+
+const path = require('path');
+
+module.exports = {
+  entry: './core/main',
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, '..', 'assets'),
+    filename: 'wails.js'
+  },
+  module: {
+    rules: [
+      {
+        test: /\.m?js$/,
+        exclude: /(node_modules|bower_components)/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            plugins: ['@babel/plugin-transform-object-assign'],
+            presets: [
+              [
+                '@babel/preset-env',
+                {
+                  'useBuiltIns': 'entry',
+                  'corejs': {
+                    'version': 3,
+                    'proposals': true
+                  }
+                }
+              ]
+            ]
+          }
+        }
+      }
+    ]
+  }
+};