@wailsio/runtime 3.0.0-alpha.4

package/application.js

@@ -0,0 +1,46 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+import { newRuntimeCallerWithID, objectNames } from "./runtime";
+const call = newRuntimeCallerWithID(objectNames.Application);
+
+const HideMethod = 0;
+const ShowMethod = 1;
+const QuitMethod = 2;
+
+/**
+ * Hides a certain method by calling the HideMethod function.
+ *
+ * @return {Promise<void>}
+ *
+ */
+export function Hide() {
+    return call(HideMethod);
+}
+
+/**
+ * Calls the ShowMethod and returns the result.
+ *
+ * @return {Promise<void>}
+ */
+export function Show() {
+    return call(ShowMethod);
+}
+
+/**
+ * Calls the QuitMethod to terminate the program.
+ *
+ * @return {Promise<void>}
+ */
+export function Quit() {
+    return call(QuitMethod);
+}

package/browser.js

@@ -0,0 +1,24 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+const call = newRuntimeCallerWithID(objectNames.Browser, '');
+const BrowserOpenURL = 0;
+
+/**
+ * Open a browser window to the given URL
+ * @param {string} url - The URL to open
+ * @returns {Promise<string>}
+ */
+export function OpenURL(url) {
+    return call(BrowserOpenURL, {url});
+}

package/calls.js

@@ -0,0 +1,123 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+import { newRuntimeCallerWithID, objectNames } from "./runtime";
+import { nanoid } from 'nanoid/non-secure';
+
+const CallBinding = 0;
+const call = newRuntimeCallerWithID(objectNames.Call, '');
+let callResponses = new Map();
+
+window._wails = window._wails || {};
+window._wails.callCallback = resultHandler;
+window._wails.callErrorCallback = errorHandler;
+
+function generateID() {
+    let result;
+    do {
+        result = nanoid();
+    } while (callResponses.has(result));
+    return result;
+}
+
+export function resultHandler(id, data, isJSON) {
+    const promiseHandler = getAndDeleteResponse(id);
+    if (promiseHandler) {
+        promiseHandler.resolve(isJSON ? JSON.parse(data) : data);
+    }
+}
+
+export function errorHandler(id, message) {
+    const promiseHandler = getAndDeleteResponse(id);
+    if (promiseHandler) {
+        promiseHandler.reject(message);
+    }
+}
+
+function getAndDeleteResponse(id) {
+    const response = callResponses.get(id);
+    callResponses.delete(id);
+    return response;
+}
+
+function callBinding(type, options = {}) {
+    return new Promise((resolve, reject) => {
+        const id = generateID();
+        options["call-id"] = id;
+        callResponses.set(id, { resolve, reject });
+        call(type, options).catch((error) => {
+            reject(error);
+            callResponses.delete(id);
+        });
+    });
+}
+
+/**
+ * Call method.
+ *
+ * @param {Object} options - The options for the method.
+ * @returns {Object} - The result of the call.
+ */
+export function Call(options) {
+    return callBinding(CallBinding, options);
+}
+
+/**
+ * Executes a method by name.
+ *
+ * @param {string} name - The name of the method in the format 'package.struct.method'.
+ * @param {...*} args - The arguments to pass to the method.
+ * @throws {Error} If the name is not a string or is not in the correct format.
+ * @returns {*} The result of the method execution.
+ */
+export function ByName(name, ...args) {
+    if (typeof name !== "string" || name.split(".").length !== 3) {
+        throw new Error("CallByName requires a string in the format 'package.struct.method'");
+    }
+    let [packageName, structName, methodName] = name.split(".");
+    return callBinding(CallBinding, {
+        packageName,
+        structName,
+        methodName,
+        args
+    });
+}
+
+/**
+ * Calls a method by its ID with the specified arguments.
+ *
+ * @param {string} methodID - The ID of the method to call.
+ * @param {...*} args - The arguments to pass to the method.
+ * @return {*} - The result of the method call.
+ */
+export function ByID(methodID, ...args) {
+    return callBinding(CallBinding, {
+        methodID,
+        args
+    });
+}
+
+/**
+ * Calls a method on a plugin.
+ *
+ * @param {string} pluginName - The name of the plugin.
+ * @param {string} methodName - The name of the method to call.
+ * @param {...*} args - The arguments to pass to the method.
+ * @returns {*} - The result of the method call.
+ */
+export function Plugin(pluginName, methodName, ...args) {
+    return callBinding(CallBinding, {
+        packageName: "wails-plugins",
+        structName: pluginName,
+        methodName,
+        args
+    });
+}

package/clipboard.js

@@ -0,0 +1,35 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+const call = newRuntimeCallerWithID(objectNames.Clipboard, '');
+const ClipboardSetText = 0;
+const ClipboardText = 1;
+
+/**
+ * Sets the text to the Clipboard.
+ *
+ * @param {string} text - The text to be set to the Clipboard.
+ * @return {Promise} - A Promise that resolves when the operation is successful.
+ */
+export function SetText(text) {
+    return call(ClipboardSetText, {text});
+}
+
+/**
+ * Get the Clipboard text
+ * @returns {Promise<string>} A promise that resolves with the text from the Clipboard.
+ */
+export function Text() {
+    return call(ClipboardText);
+}

package/contextmenu.js

@@ -0,0 +1,96 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+const call = newRuntimeCallerWithID(objectNames.ContextMenu, '');
+const ContextMenuOpen = 0;
+
+function openContextMenu(id, x, y, data) {
+    void call(ContextMenuOpen, {id, x, y, data});
+}
+
+export function setupContextMenus() {
+    window.addEventListener('contextmenu', contextMenuHandler);
+}
+
+function contextMenuHandler(event) {
+    // Check for custom context menu
+    let element = event.target;
+    let customContextMenu = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu");
+    customContextMenu = customContextMenu ? customContextMenu.trim() : "";
+    if (customContextMenu) {
+        event.preventDefault();
+        let customContextMenuData = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu-data");
+        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);
+        return
+    }
+
+    processDefaultContextMenu(event);
+}
+
+
+/*
+--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea
+--default-contextmenu: show; will always show the default context menu
+--default-contextmenu: hide; will always hide the default context menu
+
+This rule is inherited like normal CSS rules, so nesting works as expected
+*/
+function processDefaultContextMenu(event) {
+    // Debug builds always show the menu
+    if (DEBUG) {
+        return;
+    }
+
+    // Process default context menu
+    const element = event.target;
+    const computedStyle = window.getComputedStyle(element);
+    const defaultContextMenuAction = computedStyle.getPropertyValue("--default-contextmenu").trim();
+    switch (defaultContextMenuAction) {
+        case "show":
+            return;
+        case "hide":
+            event.preventDefault();
+            return;
+        default:
+            // Check if contentEditable is true
+            if (element.isContentEditable) {
+                return;
+            }
+
+            // Check if text has been selected
+            const selection = window.getSelection();
+            const hasSelection = (selection.toString().length > 0)
+            if (hasSelection) {
+                for (let i = 0; i < selection.rangeCount; i++) {
+                    const range = selection.getRangeAt(i);
+                    const rects = range.getClientRects();
+                    for (let j = 0; j < rects.length; j++) {
+                        const rect = rects[j];
+                        if (document.elementFromPoint(rect.left, rect.top) === element) {
+                            return;
+                        }
+                    }
+                }
+            }
+            // Check if tagname is input or textarea
+            if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+                if (hasSelection || (!element.readOnly && !element.disabled)) {
+                    return;
+                }
+            }
+
+            // hide default context menu
+            event.preventDefault();
+    }
+}

package/dialogs.js

@@ -0,0 +1,138 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+/**
+ * @typedef {import("./types").MessageDialogOptions} MessageDialogOptions
+ * @typedef {import("./types").OpenDialogOptions} OpenDialogOptions
+ * @typedef {import("./types").SaveDialogOptions} SaveDialogOptions
+ */
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+import { nanoid } from 'nanoid/non-secure';
+
+// Define constants from the `methods` object in Title Case
+const DialogInfo = 0;
+const DialogWarning = 1;
+const DialogError = 2;
+const DialogQuestion = 3;
+const DialogOpenFile = 4;
+const DialogSaveFile = 5;
+
+const call = newRuntimeCallerWithID(objectNames.Dialog, '');
+const dialogResponses = new Map();
+
+/**
+ * Generates a unique id that is not present in dialogResponses.
+ * @returns {string} unique id
+ */
+function generateID() {
+    let result;
+    do {
+        result = nanoid();
+    } while (dialogResponses.has(result));
+    return result;
+}
+
+/**
+ * Shows a dialog of specified type with the given options.
+ * @param {number} type - type of dialog
+ * @param {object} options - options for the dialog
+ * @returns {Promise} promise that resolves with result of dialog
+ */
+function dialog(type, options = {}) {
+    const id = generateID();
+    options["dialog-id"] = id;
+    return new Promise((resolve, reject) => {
+        dialogResponses.set(id, {resolve, reject});
+        call(type, options).catch((error) => {
+            reject(error);
+            dialogResponses.delete(id);
+        });
+    });
+}
+
+/**
+ * Handles the callback from a dialog.
+ *
+ * @param {string} id - The ID of the dialog response.
+ * @param {string} data - The data received from the dialog.
+ * @param {boolean} isJSON - Flag indicating whether the data is in JSON format.
+ *
+ * @return {undefined}
+ */
+export function dialogCallback(id, data, isJSON) {
+    let p = dialogResponses.get(id);
+    if (p) {
+        if (isJSON) {
+            p.resolve(JSON.parse(data));
+        } else {
+            p.resolve(data);
+        }
+        dialogResponses.delete(id);
+    }
+}
+
+/**
+ * Callback function for handling errors in dialog.
+ *
+ * @param {string} id - The id of the dialog response.
+ * @param {string} message - The error message.
+ *
+ * @return {void}
+ */
+export function dialogErrorCallback(id, message) {
+    let p = dialogResponses.get(id);
+    if (p) {
+        p.reject(message);
+        dialogResponses.delete(id);
+    }
+}
+
+
+// Replace `methods` with constants in Title Case
+
+/**
+ * @param {MessageDialogOptions} options - Dialog options
+ * @returns {Promise<string>} - The label of the button pressed
+ */
+export const Info = (options) => dialog(DialogInfo, options);
+
+/**
+ * @param {MessageDialogOptions} options - Dialog options
+ * @returns {Promise<string>} - The label of the button pressed
+ */
+export const Warning = (options) => dialog(DialogWarning, options);
+
+/**
+ * @param {MessageDialogOptions} options - Dialog options
+ * @returns {Promise<string>} - The label of the button pressed
+ */
+export const Error = (options) => dialog(DialogError, options);
+
+/**
+ * @param {MessageDialogOptions} options - Dialog options
+ * @returns {Promise<string>} - The label of the button pressed
+ */
+export const Question = (options) => dialog(DialogQuestion, options);
+
+/**
+ * @param {OpenDialogOptions} options - Dialog options
+ * @returns {Promise<string[]|string>} Returns selected file or list of files. Returns blank string if no file is selected.
+ */
+export const OpenFile = (options) => dialog(DialogOpenFile, options);
+
+/**
+ * @param {SaveDialogOptions} options - Dialog options
+ * @returns {Promise<string>} Returns the selected file. Returns blank string if no file is selected.
+ */
+export const SaveFile = (options) => dialog(DialogSaveFile, options);

package/drag.js

@@ -0,0 +1,125 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+import {invoke, IsWindows} from "./system";
+import {GetFlag} from "./flags";
+
+let shouldDrag = false;
+let resizeEdge = null;
+let resizable = false;
+let defaultCursor = "auto";
+window._wails = window._wails || {};
+window._wails.setResizable = setResizable;
+window._wails.endDrag = endDrag;
+
+export function dragTest(e) {
+    let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region");
+    if (val && val.trim() !== "drag" || e.buttons !== 1) {
+        return false;
+    }
+    return e.detail === 1;
+}
+
+export function setupDrag() {
+    window.addEventListener('mousedown', onMouseDown);
+    window.addEventListener('mousemove', onMouseMove);
+    window.addEventListener('mouseup', onMouseUp);
+}
+
+export function setResizable(value) {
+    resizable = value;
+}
+
+export function endDrag() {
+    document.body.style.cursor = 'default';
+    shouldDrag = false;
+}
+
+function testResize() {
+    if( resizeEdge ) {
+        invoke(`resize:${resizeEdge}`);
+        return true
+    }
+    return false;
+}
+
+function onMouseDown(e) {
+    if(IsWindows() && testResize() || dragTest(e)) {
+        shouldDrag = !!isValidDrag(e);
+    }
+}
+
+function isValidDrag(e) {
+    // Ignore drag on scrollbars
+    return !(e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight);
+}
+
+function onMouseUp(e) {
+    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;
+    if (mousePressed > 0) {
+        endDrag();
+    }
+}
+
+function setResize(cursor = defaultCursor) {
+    document.documentElement.style.cursor = cursor;
+    resizeEdge = cursor;
+}
+
+function onMouseMove(e) {
+    shouldDrag = checkDrag(e);
+    if (IsWindows() && resizable) {
+        handleResize(e);
+    }
+}
+
+function checkDrag(e) {
+    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;
+    if(shouldDrag && mousePressed > 0) {
+        invoke("drag");
+        return false;
+    }
+    return shouldDrag;
+}
+
+function handleResize(e) {
+    let resizeHandleHeight = GetFlag("system.resizeHandleHeight") || 5;
+    let resizeHandleWidth = GetFlag("system.resizeHandleWidth") || 5;
+
+    // Extra pixels for the corner areas
+    let cornerExtra = GetFlag("resizeCornerExtra") || 10;
+
+    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;
+    let leftBorder = e.clientX < resizeHandleWidth;
+    let topBorder = e.clientY < resizeHandleHeight;
+    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;
+
+    // Adjust for corners
+    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);
+    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);
+    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);
+    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);
+
+    // If we aren't on an edge, but were, reset the cursor to default
+    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {
+        setResize();
+    }
+    // Adjusted for corner areas
+    else if (rightCorner && bottomCorner) setResize("se-resize");
+    else if (leftCorner && bottomCorner) setResize("sw-resize");
+    else if (leftCorner && topCorner) setResize("nw-resize");
+    else if (topCorner && rightCorner) setResize("ne-resize");
+    else if (leftBorder) setResize("w-resize");
+    else if (topBorder) setResize("n-resize");
+    else if (bottomBorder) setResize("s-resize");
+    else if (rightBorder) setResize("e-resize");
+}