@wailsio/runtime 3.0.0-alpha.4

package/events.js

@@ -0,0 +1,134 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+/**
+ * @typedef {import("./types").WailsEvent} WailsEvent
+ */
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+const call = newRuntimeCallerWithID(objectNames.Events, '');
+const EmitMethod = 0;
+const eventListeners = new Map();
+
+class Listener {
+    constructor(eventName, callback, maxCallbacks) {
+        this.eventName = eventName;
+        this.maxCallbacks = maxCallbacks || -1;
+        this.Callback = (data) => {
+            callback(data);
+            if (this.maxCallbacks === -1) return false;
+            this.maxCallbacks -= 1;
+            return this.maxCallbacks === 0;
+        };
+    }
+}
+
+export class WailsEvent {
+    constructor(name, data = null) {
+        this.name = name;
+        this.data = data;
+    }
+}
+
+
+window._wails = window._wails || {};
+window._wails.dispatchWailsEvent = dispatchWailsEvent;
+
+export function dispatchWailsEvent(event) {
+    let listeners = eventListeners.get(event.name);
+    if (listeners) {
+        let toRemove = listeners.filter(listener => {
+            let remove = listener.Callback(event);
+            if (remove) return true;
+        });
+        if (toRemove.length > 0) {
+            listeners = listeners.filter(l => !toRemove.includes(l));
+            if (listeners.length === 0) eventListeners.delete(event.name);
+            else eventListeners.set(event.name, listeners);
+        }
+    }
+}
+
+/**
+ * Register a callback function to be called multiple times for a specific event.
+ *
+ * @param {string} eventName - The name of the event to register the callback for.
+ * @param {function} callback - The callback function to be called when the event is triggered.
+ * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.
+ *
+ @return {function} - A function that, when called, will unregister the callback from the event.
+ */
+export function OnMultiple(eventName, callback, maxCallbacks) {
+    let listeners = eventListeners.get(eventName) || [];
+    const thisListener = new Listener(eventName, callback, maxCallbacks);
+    listeners.push(thisListener);
+    eventListeners.set(eventName, listeners);
+    return () => listenerOff(thisListener);
+}
+
+/**
+ * Registers a callback function to be executed when the specified event occurs.
+ *
+ * @param {string} eventName - The name of the event.
+ * @param {function} callback - The callback function to be executed. It takes no parameters.
+ * @return {function} - A function that, when called, will unregister the callback from the event. */
+export function On(eventName, callback) { return OnMultiple(eventName, callback, -1); }
+
+/**
+ * Registers a callback function to be executed only once for the specified event.
+ *
+ * @param {string} eventName - The name of the event.
+ * @param {function} callback - The function to be executed when the event occurs.
+ * @return {void@return {function} - A function that, when called, will unregister the callback from the event.
+ */
+export function Once(eventName, callback) { return OnMultiple(eventName, callback, 1); }
+
+/**
+ * Removes the specified listener from the event listeners collection.
+ * If all listeners for the event are removed, the event key is deleted from the collection.
+ *
+ * @param {Object} listener - The listener to be removed.
+ */
+function listenerOff(listener) {
+    const eventName = listener.eventName;
+    let listeners = eventListeners.get(eventName).filter(l => l !== listener);
+    if (listeners.length === 0) eventListeners.delete(eventName);
+    else eventListeners.set(eventName, listeners);
+}
+
+
+/**
+ * Removes event listeners for the specified event names.
+ *
+ * @param {string} eventName - The name of the event to remove listeners for.
+ * @param {...string} additionalEventNames - Additional event names to remove listeners for.
+ * @return {undefined}
+ */
+export function Off(eventName, ...additionalEventNames) {
+    let eventsToRemove = [eventName, ...additionalEventNames];
+    eventsToRemove.forEach(eventName => eventListeners.delete(eventName));
+}
+/**
+ * Removes all event listeners.
+ *
+ * @function OffAll
+ * @returns {void}
+ */
+export function OffAll() { eventListeners.clear(); }
+
+/**
+ * Emits an event using the given event name.
+ *
+ * @param {WailsEvent} event - The name of the event to emit.
+ * @returns {any} - The result of the emitted event.
+ */
+export function Emit(event) { return call(EmitMethod, event); }

package/flags.js

@@ -0,0 +1,63 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+let flags = new Map();
+
+function convertToMap(obj) {
+    const map = new Map();
+
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'object' && value !== null) {
+            map.set(key, convertToMap(value)); // Recursively convert nested object
+        } else {
+            map.set(key, value);
+        }
+    }
+
+    return map;
+}
+
+fetch("/wails/flags").then((response) => {
+    response.json().then((data) => {
+        flags = convertToMap(data);
+    });
+});
+
+
+function getValueFromMap(keyString) {
+    const keys = keyString.split('.');
+    let value = flags;
+
+    for (const key of keys) {
+        if (value instanceof Map) {
+            value = value.get(key);
+        } else {
+            value = value[key];
+        }
+
+        if (value === undefined) {
+            break;
+        }
+    }
+
+    return value;
+}
+
+/**
+ * Retrieves the value associated with the specified key from the flag map.
+ *
+ * @param {string} keyString - The key to retrieve the value for.
+ * @return {*} - The value associated with the specified key.
+ */
+export function GetFlag(keyString) {
+    return getValueFromMap(keyString);
+}

package/index.js

@@ -0,0 +1,56 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+import {setupContextMenus} from "./contextmenu";
+import {setupDrag} from "./drag";
+import {reloadWML} from "./wml";
+import {Emit, Off, OffAll, On, Once, OnMultiple, WailsEvent} from './events';
+import {ByID, ByName, Plugin} from "./calls";
+import {Error, Info, OpenFile, Question, SaveFile, Warning} from "./dialogs";
+
+export * as Application from "./application";
+export * as Browser from "./browser";
+export * as Clipboard from "./clipboard";
+export * as ContextMenu from "./contextmenu";
+export * as Flags from "./flags";
+export * as Runtime from "./runtime";
+export * as Screens from "./screens";
+export * as System from "./system";
+export * as Window from "./window";
+
+export const Events = {
+    On,
+    Off,
+    OnMultiple,
+    WailsEvent,
+    OffAll,
+    Emit,
+    Once
+
+}
+
+export const Call = {
+    Plugin,
+    ByID,
+    ByName
+}
+
+export const Dialogs = {
+    Info,
+    Error,
+    OpenFile, Question, Warning, SaveFile
+}
+
+setupContextMenus();
+setupDrag();
+
+document.addEventListener("DOMContentLoaded", function () {
+    reloadWML();
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@wailsio/runtime",
+  "version": "3.0.0-alpha.4",
+  "description": "Wails Runtime",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wailsapp/wails.git"
+  },
+  "author": "The Wails Team",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wailsapp/wails/issues"
+  },
+  "homepage": "https://wails.io",
+  "private": false
+}

package/runtime.js

@@ -0,0 +1,122 @@
+/*
+ _     __     _ __
+| |  / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+import { nanoid } from 'nanoid/non-secure';
+
+const runtimeURL = window.location.origin + "/wails/runtime";
+
+// Object Names
+export const objectNames = {
+    Call: 0,
+    Clipboard: 1,
+    Application: 2,
+    Events: 3,
+    ContextMenu: 4,
+    Dialog: 5,
+    Window: 6,
+    Screens: 7,
+    System: 8,
+    Browser: 9,
+}
+export let clientId = nanoid();
+
+/**
+ * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.
+ *
+ * @param {Object} object - The object on which the method is to be invoked.
+ * @param {string} windowName - The name of the window context in which the method should be called.
+ * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context.
+ */
+export function newRuntimeCaller(object, windowName) {
+    return function (method, args=null) {
+        return runtimeCall(object + "." + method, windowName, args);
+    };
+}
+
+/**
+ * Creates a new runtime caller with specified ID.
+ *
+ * @param {object} object - The object to invoke the method on.
+ * @param {string} windowName - The name of the window.
+ * @return {Function} - The new runtime caller function.
+ */
+export function newRuntimeCallerWithID(object, windowName) {
+    return function (method, args=null) {
+        return runtimeCallWithID(object, method, windowName, args);
+    };
+}
+
+
+function runtimeCall(method, windowName, args) {
+    let url = new URL(runtimeURL);
+    if( method ) {
+        url.searchParams.append("method", method);
+    }
+    let fetchOptions = {
+        headers: {},
+    };
+    if (windowName) {
+        fetchOptions.headers["x-wails-window-name"] = windowName;
+    }
+    if (args) {
+        url.searchParams.append("args", JSON.stringify(args));
+    }
+    fetchOptions.headers["x-wails-client-id"] = clientId;
+
+    return new Promise((resolve, reject) => {
+        fetch(url, fetchOptions)
+            .then(response => {
+                if (response.ok) {
+                    // check content type
+                    if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) {
+                        return response.json();
+                    } else {
+                        return response.text();
+                    }
+                }
+                reject(Error(response.statusText));
+            })
+            .then(data => resolve(data))
+            .catch(error => reject(error));
+    });
+}
+
+function runtimeCallWithID(objectID, method, windowName, args) {
+    let url = new URL(runtimeURL);
+    url.searchParams.append("object", objectID);
+    url.searchParams.append("method", method);
+    let fetchOptions = {
+        headers: {},
+    };
+    if (windowName) {
+        fetchOptions.headers["x-wails-window-name"] = windowName;
+    }
+    if (args) {
+        url.searchParams.append("args", JSON.stringify(args));
+    }
+    fetchOptions.headers["x-wails-client-id"] = clientId;
+    return new Promise((resolve, reject) => {
+        fetch(url, fetchOptions)
+            .then(response => {
+                if (response.ok) {
+                    // check content type
+                    if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) {
+                        return response.json();
+                    } else {
+                        return response.text();
+                    }
+                }
+                reject(Error(response.statusText));
+            })
+            .then(data => resolve(data))
+            .catch(error => reject(error));
+    });
+}

package/screens.js

@@ -0,0 +1,45 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+/**
+ * @typedef {import("./api/types").Screen} Screen
+ */
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+const call = newRuntimeCallerWithID(objectNames.Screens, '');
+
+const getAll = 0;
+const getPrimary = 1;
+const getCurrent = 2;
+
+/**
+ * Gets all screens.
+ * @returns {Promise<Screen[]>} A promise that resolves to an array of Screen objects.
+ */
+export function GetAll() {
+    return call(getAll);
+}
+/**
+ * Gets the primary screen.
+ * @returns {Promise<Screen>} A promise that resolves to the primary screen.
+ */
+export function GetPrimary() {
+    return call(getPrimary);
+}
+/**
+ * Gets the current active screen.
+ *
+ * @returns {Promise<Screen>} A promise that resolves with the current active screen.
+ */
+export function GetCurrent() {
+    return call(getCurrent);
+}

package/system.js

@@ -0,0 +1,118 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+let call = newRuntimeCallerWithID(objectNames.System, '');
+const systemIsDarkMode = 0;
+const environment = 1;
+
+/**
+ * @function
+ * Retrieves the system dark mode status.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean value indicating if the system is in dark mode.
+ */
+export function IsDarkMode() {
+    return call(systemIsDarkMode);
+}
+
+
+/**
+ * Fetches the capabilities of the application from the server.
+ *
+ * @async
+ * @function Capabilities
+ * @returns {Promise<Object>} A promise that resolves to an object containing the capabilities.
+ */
+export async function Capabilities() {
+    let response = fetch("/wails/capabilities");
+    return response.json();
+}
+
+/**
+ * @typedef {object} EnvironmentInfo
+ * @property {string} OS - The operating system in use.
+ * @property {string} Arch - The architecture of the system.
+ */
+
+/**
+ * @function
+ * Retrieves environment details.
+ * @returns {Promise<EnvironmentInfo>} - A promise that resolves to an object containing OS and system architecture.
+ */
+export function Environment() {
+    return call(environment);
+}
+
+export let invoke = null;
+let environmentCache = null;
+
+Environment()
+    .then(result => {
+        environmentCache = result;
+        invoke = IsWindows() ? window.chrome.webview.postMessage : window.webkit.messageHandlers.external.postMessage;
+    })
+    .catch(error => {
+        console.error(`Error getting Environment: ${error}`);
+    });
+
+/**
+ * Checks if the current operating system is Windows.
+ *
+ * @return {boolean} True if the operating system is Windows, otherwise false.
+ */
+export function IsWindows() {
+    return environmentCache.OS === "windows";
+}
+
+/**
+ * Checks if the current operating system is Linux.
+ *
+ * @returns {boolean} Returns true if the current operating system is Linux, false otherwise.
+ */
+export function IsLinux() {
+    return environmentCache.OS === "linux";
+}
+
+/**
+ * Checks if the current environment is a macOS operating system.
+ *
+ * @returns {boolean} True if the environment is macOS, false otherwise.
+ */
+export function IsMac() {
+    return environmentCache.OS === "darwin";
+}
+
+/**
+ * Checks if the current environment architecture is AMD64.
+ * @returns {boolean} True if the current environment architecture is AMD64, false otherwise.
+ */
+export function IsAMD64() {
+    return environmentCache.Arch === "amd64";
+}
+
+/**
+ * Checks if the current architecture is ARM.
+ *
+ * @returns {boolean} True if the current architecture is ARM, false otherwise.
+ */
+export function IsARM() {
+    return environmentCache.Arch === "arm";
+}
+
+/**
+ * Checks if the current environment is ARM64 architecture.
+ *
+ * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false.
+ */
+export function IsARM64() {
+    return environmentCache.Arch === "arm64";
+}

package/types.d.ts

@@ -0,0 +1,130 @@
+
+export interface Button {
+    // The label of the button
+    Label?: string;
+    // True if this button is the cancel button (selected when pressing escape)
+    IsCancel?: boolean;
+    // True if this button is the default button (selected when pressing enter)
+    IsDefault?: boolean;
+}
+
+interface MessageDialogOptions {
+    // The title for the dialog
+    Title?: string;
+    // The message to display
+    Message?: string;
+    // The buttons to use on the dialog
+    Buttons?: Button[];
+    // Whether the dialog is detached from the current window
+    Detached?: boolean;
+}
+
+export interface OpenFileDialogOptions {
+    // Allows the user to be able to select directories
+    CanChooseDirectories?: boolean;
+    // Allows the user to be able to select files
+    CanChooseFiles?: boolean;
+    // Provide an option to create directories in the dialog
+    CanCreateDirectories?: boolean;
+    // Makes the dialog show hidden files
+    ShowHiddenFiles?: boolean;
+    // Whether the dialog should follow filesystem aliases
+    ResolvesAliases?: boolean;
+    // Allow the user to select multiple files or directories
+    AllowsMultipleSelection?: boolean;
+    // Hide the extension when showing the filename
+    HideExtension?: boolean;
+    // Allow the user to select files where the system hides their extensions
+    CanSelectHiddenExtension?: boolean;
+    // Treats file packages as directories, e.g. .app on macOS
+    TreatsFilePackagesAsDirectories?: boolean;
+    // Allows selection of filetypes not specified in the filters
+    AllowsOtherFiletypes?: boolean;
+    // The file filters to use in the dialog
+    Filters?: FileFilter[];
+    // The title of the dialog
+    Title?: string;
+    // The message to display
+    Message?: string;
+    // The label for the select button
+    ButtonText?: string;
+    // The default directory to open the dialog in
+    Directory?: string;
+    // Whether the dialog is detached from the current window
+    Detached?: boolean;
+}
+export interface FileFilter {
+    // The display name for the filter, e.g. "Text Files"
+    DisplayName?: string;
+    // The pattern to use for the filter, e.g. "*.txt;*.md"
+    Pattern?: string;
+}
+export interface SaveFileDialogOptions {
+    // Provide an option to create directories in the dialog
+    CanCreateDirectories?: boolean;
+    // Makes the dialog show hidden files
+    ShowHiddenFiles?: boolean;
+    // Allow the user to select files where the system hides their extensions
+    CanSelectHiddenExtension?: boolean;
+    // Allows selection of filetypes not specified in the filters
+    AllowOtherFiletypes?: boolean;
+    // Hide the extension when showing the filename
+    HideExtension?: boolean;
+    // Treats file packages as directories, e.g. .app on macOS
+    TreatsFilePackagesAsDirectories?: boolean;
+    // The message to show in the dialog
+    Message?: string;
+    // The default directory to open the dialog in
+    Directory?: string;
+    // The default filename to use in the dialog
+    Filename?: string;
+    // The label for the select button
+    ButtonText?: string;
+    // Whether the dialog is detached from the current window
+    Detached?: boolean;
+}
+
+export interface Screen {
+    // The screen ID
+    Id: string;
+    // The screen name
+    Name: string;
+    // The screen scale. 1 = standard resolution, 2: 2x retina, etc.
+    Scale: number;
+    // The X position of the screen
+    X: number;
+    // The Y position of the screen
+    Y: number;
+    // The width and height of the screen
+    Size: Size;
+    // The bounds of the screen
+    Bounds: Rect;
+    // The work area of the screen
+    WorkArea: Rect;
+    // True if this is the primary screen
+    IsPrimary: boolean;
+    // The rotation of the screen
+    Rotation: number;
+}
+export interface Rect {
+    X: number;
+    Y: number;
+    Width: number;
+    Height: number;
+}
+
+export interface WailsEvent {
+    // The name of the event
+    Name: string;
+    // The data associated with the event
+    Data?: any;
+}
+
+export interface Size {
+    Width: number;
+    Height: number;
+}
+export interface Position {
+    X: number;
+    Y: number;
+}