@wailsio/runtime 3.0.0-alpha.4

package/window.js

@@ -0,0 +1,122 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+/**
+ * @typedef {import("../api/types").Size} Size
+ * @typedef {import("../api/types").Position} Position
+ * @typedef {import("../api/types").Screen} Screen
+ */
+
+import {newRuntimeCallerWithID, objectNames} from "./runtime";
+
+const center = 0;
+const setTitle = 1;
+const fullscreen = 2;
+const unFullscreen = 3;
+const setSize = 4;
+const size = 5;
+const setMaxSize = 6;
+const setMinSize = 7;
+const setAlwaysOnTop = 8;
+const setRelativePosition = 9;
+const relativePosition = 10;
+const screen = 11;
+const hide = 12;
+const maximise = 13;
+const unMaximise = 14;
+const toggleMaximise = 15;
+const minimise = 16;
+const unMinimise = 17;
+const restore = 18;
+const show = 19;
+const close = 20;
+const setBackgroundColour = 21;
+const setResizable = 22;
+const width = 23;
+const height = 24;
+const zoomIn = 25;
+const zoomOut = 26;
+const zoomReset = 27;
+const getZoomLevel = 28;
+const setZoomLevel = 29;
+
+const thisWindow = newRuntimeCallerWithID(objectNames.Window, '');
+
+function createWindow(call) {
+    return {
+        Get: (windowName) => createWindow(newRuntimeCallerWithID(objectNames.Window, windowName)),
+        Center: () => call(center),
+        SetTitle: (title) => call(setTitle, {title}),
+        Fullscreen: () => call(fullscreen),
+        UnFullscreen: () => call(unFullscreen),
+        SetSize: (width, height) => call(setSize, {width, height}),
+        Size: () => call(size),
+        SetMaxSize: (width, height) => call(setMaxSize, {width, height}),
+        SetMinSize: (width, height) => call(setMinSize, {width, height}),
+        SetAlwaysOnTop: (onTop) => call(setAlwaysOnTop, {alwaysOnTop: onTop}),
+        SetRelativePosition: (x, y) => call(setRelativePosition, {x, y}),
+        RelativePosition: () => call(relativePosition),
+        Screen: () => call(screen),
+        Hide: () => call(hide),
+        Maximise: () => call(maximise),
+        UnMaximise: () => call(unMaximise),
+        ToggleMaximise: () => call(toggleMaximise),
+        Minimise: () => call(minimise),
+        UnMinimise: () => call(unMinimise),
+        Restore: () => call(restore),
+        Show: () => call(show),
+        Close: () => call(close),
+        SetBackgroundColour: (r, g, b, a) => call(setBackgroundColour, {r, g, b, a}),
+        SetResizable: (resizable) => call(setResizable, {resizable}),
+        Width: () => call(width),
+        Height: () => call(height),
+        ZoomIn: () => call(zoomIn),
+        ZoomOut: () => call(zoomOut),
+        ZoomReset: () => call(zoomReset),
+        GetZoomLevel: () => call(getZoomLevel),
+        SetZoomLevel: (zoomLevel) => call(setZoomLevel, {zoomLevel}),
+    };
+}
+
+/**
+ * Gets the specified window.
+ *
+ * @param {string} windowName - The name of the window to get.
+ * @return {Object} - The specified window object.
+ */
+export function Get(windowName) {
+    return createWindow(newRuntimeCallerWithID(objectNames.Window, windowName));
+}
+
+/**
+ * Returns a map of all methods in the current window.
+ * @returns {Map} - A map of window methods.
+ */
+export function WindowMethods(targetWindow) {
+    // Create a new map to store methods
+    let result = new Map();
+
+    // Iterate over all properties of the window object
+    for (let method in targetWindow) {
+        // Check if the property is indeed a method (function)
+        if(typeof targetWindow[method] === 'function') {
+            // Add the method to the map
+            result.set(method, targetWindow[method]);
+        }
+
+    }
+    // Return the map of window methods
+    return result;
+}
+export default {
+    ...Get('')
+}

package/wml.js

@@ -0,0 +1,148 @@
+
+import {Emit, WailsEvent} from "./events";
+import {Question} from "./dialogs";
+import {WindowMethods, Get} from "./window";
+
+/**
+ * Sends an event with the given name and optional data.
+ *
+ * @param {string} eventName - The name of the event to send.
+ * @param {any} [data=null] - Optional data to send along with the event.
+ *
+ * @return {void}
+ */
+function sendEvent(eventName, data=null) {
+    let event = new WailsEvent(eventName, data);
+    Emit(event);
+}
+
+/**
+ * Adds event listeners to elements with `wml-event` attribute.
+ *
+ * @return {void}
+ */
+function addWMLEventListeners() {
+    const elements = document.querySelectorAll('[wml-event]');
+    elements.forEach(function (element) {
+        const eventType = element.getAttribute('wml-event');
+        const confirm = element.getAttribute('wml-confirm');
+        const trigger = element.getAttribute('wml-trigger') || "click";
+
+        let callback = function () {
+            if (confirm) {
+                Question({Title: "Confirm", Message:confirm, Detached: false, Buttons:[{Label:"Yes"},{Label:"No", IsDefault:true}]}).then(function (result) {
+                    if (result !== "No") {
+                        sendEvent(eventType);
+                    }
+                });
+                return;
+            }
+            sendEvent(eventType);
+        };
+
+        // Remove existing listeners
+        element.removeEventListener(trigger, callback);
+
+        // Add new listener
+        element.addEventListener(trigger, callback);
+    });
+}
+
+/**
+ * Calls a method on the window object.
+ *
+ * @param {string} method - The name of the method to call on the window object.
+ *
+ * @return {void}
+ */
+function callWindowMethod(method) {
+    // TODO: Make this a parameter!
+    let windowName = '';
+    let targetWindow = Get('');
+    let methodMap = WindowMethods(targetWindow);
+    if (!methodMap.has(method)) {
+        console.log("Window method " + method + " not found");
+    }
+    methodMap.get(method)();
+}
+
+/**
+ * Adds window listeners for elements with the 'wml-window' attribute.
+ * Removes any existing listeners before adding new ones.
+ *
+ * @return {void}
+ */
+function addWMLWindowListeners() {
+    const elements = document.querySelectorAll('[wml-window]');
+    elements.forEach(function (element) {
+        const windowMethod = element.getAttribute('wml-window');
+        const confirm = element.getAttribute('wml-confirm');
+        const trigger = element.getAttribute('wml-trigger') || "click";
+
+        let callback = function () {
+            if (confirm) {
+                Question({Title: "Confirm", Message:confirm, Buttons:[{Label:"Yes"},{Label:"No", IsDefault:true}]}).then(function (result) {
+                    if (result !== "No") {
+                        callWindowMethod(windowMethod);
+                    }
+                });
+                return;
+            }
+            callWindowMethod(windowMethod);
+        };
+
+        // Remove existing listeners
+        element.removeEventListener(trigger, callback);
+
+        // Add new listener
+        element.addEventListener(trigger, callback);
+    });
+}
+
+/**
+ * Adds a listener to elements with the 'wml-openurl' attribute.
+ * When the specified trigger event is fired on any of these elements,
+ * the listener will open the URL specified by the 'wml-openurl' attribute.
+ * If a 'wml-confirm' attribute is provided, a confirmation dialog will be displayed,
+ * and the URL will only be opened if the user confirms.
+ *
+ * @return {void}
+ */
+function addWMLOpenBrowserListener() {
+    const elements = document.querySelectorAll('[wml-openurl]');
+    elements.forEach(function (element) {
+        const url = element.getAttribute('wml-openurl');
+        const confirm = element.getAttribute('wml-confirm');
+        const trigger = element.getAttribute('wml-trigger') || "click";
+
+        let callback = function () {
+            if (confirm) {
+                Question({Title: "Confirm", Message:confirm, Buttons:[{Label:"Yes"},{Label:"No", IsDefault:true}]}).then(function (result) {
+                    if (result !== "No") {
+                        void wails.Browser.OpenURL(url);
+                    }
+                });
+                return;
+            }
+            void wails.Browser.OpenURL(url);
+        };
+
+        // Remove existing listeners
+        element.removeEventListener(trigger, callback);
+
+        // Add new listener
+        element.addEventListener(trigger, callback);
+    });
+}
+
+/**
+ * Reloads the WML page by adding necessary event listeners and browser listeners.
+ *
+ * @return {void}
+ */
+export function reloadWML() {
+    console.log("Reloading WML");
+    addWMLEventListeners();
+    addWMLWindowListeners();
+    addWMLOpenBrowserListener();
+}