@wailsio/runtime 3.0.0-alpha.7 → 3.0.0-alpha.71

package/dist/wml.js

@@ -0,0 +1,179 @@
+/*
+ _     __     _ __
+| |  / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+import { OpenURL } from "./browser.js";
+import { Question } from "./dialogs.js";
+import { Emit } from "./events.js";
+import { canAbortListeners, whenReady } from "./utils.js";
+import Window from "./window.js";
+/**
+ * Sends an event with the given name and optional data.
+ *
+ * @param eventName - - The name of the event to send.
+ * @param [data=null] - - Optional data to send along with the event.
+ */
+function sendEvent(eventName, data = null) {
+    Emit(eventName, data);
+}
+/**
+ * Calls a method on a specified window.
+ *
+ * @param windowName - The name of the window to call the method on.
+ * @param methodName - The name of the method to call.
+ */
+function callWindowMethod(windowName, methodName) {
+    const targetWindow = Window.Get(windowName);
+    const method = targetWindow[methodName];
+    if (typeof method !== "function") {
+        console.error(`Window method '${methodName}' not found`);
+        return;
+    }
+    try {
+        method.call(targetWindow);
+    }
+    catch (e) {
+        console.error(`Error calling window method '${methodName}': `, e);
+    }
+}
+/**
+ * Responds to a triggering event by running appropriate WML actions for the current target.
+ */
+function onWMLTriggered(ev) {
+    const element = ev.currentTarget;
+    function runEffect(choice = "Yes") {
+        if (choice !== "Yes")
+            return;
+        const eventType = element.getAttribute('wml-event') || element.getAttribute('data-wml-event');
+        const targetWindow = element.getAttribute('wml-target-window') || element.getAttribute('data-wml-target-window') || "";
+        const windowMethod = element.getAttribute('wml-window') || element.getAttribute('data-wml-window');
+        const url = element.getAttribute('wml-openurl') || element.getAttribute('data-wml-openurl');
+        if (eventType !== null)
+            sendEvent(eventType);
+        if (windowMethod !== null)
+            callWindowMethod(targetWindow, windowMethod);
+        if (url !== null)
+            void OpenURL(url);
+    }
+    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');
+    if (confirm) {
+        Question({
+            Title: "Confirm",
+            Message: confirm,
+            Detached: false,
+            Buttons: [
+                { Label: "Yes" },
+                { Label: "No", IsDefault: true }
+            ]
+        }).then(runEffect);
+    }
+    else {
+        runEffect();
+    }
+}
+// Private field names.
+const controllerSym = Symbol("controller");
+const triggerMapSym = Symbol("triggerMap");
+const elementCountSym = Symbol("elementCount");
+/**
+ * AbortControllerRegistry does not actually remember active event listeners: instead
+ * it ties them to an AbortSignal and uses an AbortController to remove them all at once.
+ */
+class AbortControllerRegistry {
+    constructor() {
+        this[controllerSym] = new AbortController();
+    }
+    /**
+     * Returns an options object for addEventListener that ties the listener
+     * to the AbortSignal from the current AbortController.
+     *
+     * @param element - An HTML element
+     * @param triggers - The list of active WML trigger events for the specified elements
+     */
+    set(element, triggers) {
+        return { signal: this[controllerSym].signal };
+    }
+    /**
+     * Removes all registered event listeners and resets the registry.
+     */
+    reset() {
+        this[controllerSym].abort();
+        this[controllerSym] = new AbortController();
+    }
+}
+/**
+ * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.
+ * This ensures that the mapping remains private to this module, while still allowing garbage
+ * collection of the involved elements.
+ */
+class WeakMapRegistry {
+    constructor() {
+        this[triggerMapSym] = new WeakMap();
+        this[elementCountSym] = 0;
+    }
+    /**
+     * Sets active triggers for the specified element.
+     *
+     * @param element - An HTML element
+     * @param triggers - The list of active WML trigger events for the specified element
+     */
+    set(element, triggers) {
+        if (!this[triggerMapSym].has(element)) {
+            this[elementCountSym]++;
+        }
+        this[triggerMapSym].set(element, triggers);
+        return {};
+    }
+    /**
+     * Removes all registered event listeners.
+     */
+    reset() {
+        if (this[elementCountSym] <= 0)
+            return;
+        for (const element of document.body.querySelectorAll('*')) {
+            if (this[elementCountSym] <= 0)
+                break;
+            const triggers = this[triggerMapSym].get(element);
+            if (triggers != null) {
+                this[elementCountSym]--;
+            }
+            for (const trigger of triggers || [])
+                element.removeEventListener(trigger, onWMLTriggered);
+        }
+        this[triggerMapSym] = new WeakMap();
+        this[elementCountSym] = 0;
+    }
+}
+const triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();
+/**
+ * Adds event listeners to the specified element.
+ */
+function addWMLListeners(element) {
+    const triggerRegExp = /\S+/g;
+    const triggerAttr = (element.getAttribute('wml-trigger') || element.getAttribute('data-wml-trigger') || "click");
+    const triggers = [];
+    let match;
+    while ((match = triggerRegExp.exec(triggerAttr)) !== null)
+        triggers.push(match[0]);
+    const options = triggerRegistry.set(element, triggers);
+    for (const trigger of triggers)
+        element.addEventListener(trigger, onWMLTriggered, options);
+}
+/**
+ * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.
+ */
+export function Enable() {
+    whenReady(Reload);
+}
+/**
+ * Reloads the WML page by adding necessary event listeners and browser listeners.
+ */
+export function Reload() {
+    triggerRegistry.reset();
+    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);
+}

package/package.json

@@ -1,18 +1,62 @@
-{
-  "name": "@wailsio/runtime",
-  "version": "3.0.0-alpha.7",
-  "description": "Wails Runtime",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "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
-}
+{
+  "name": "@wailsio/runtime",
+  "type": "module",
+  "version": "3.0.0-alpha.71",
+  "description": "Wails Runtime",
+  "types": "types/index.d.ts",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wailsapp/wails.git",
+    "directory": "v3/internal/runtime/desktop/@wailsio/runtime"
+  },
+  "author": "The Wails Team",
+  "license": "MIT",
+  "homepage": "https://v3.wails.io",
+  "bugs": {
+    "url": "https://github.com/wailsapp/wails/issues"
+  },
+  "files": [
+    "./dist",
+    "./types"
+  ],
+  "sideEffects": [
+    "./dist/index.js",
+    "./dist/contextmenu.js",
+    "./dist/drag.js"
+  ],
+  "scripts": {
+    "check": "npx tsc --noEmit",
+    "test": "npx vitest run",
+    "clean": "npx rimraf ./dist ./docs ./types ./tsconfig.tsbuildinfo",
+    "generate:events": "task generate:events",
+    "generate": "npm run generate:events",
+    "prebuild": "npm run clean && npm run generate",
+    "build:code": "npx tsc",
+    "build:docs": "npx typedoc --gitRevision v3-alpha --plugin typedoc-plugin-mdn-links --plugin typedoc-plugin-missing-exports ./src/index.ts",
+    "build:docs:md": "npx typedoc --gitRevision v3-alpha --plugin typedoc-plugin-markdown --plugin typedoc-plugin-mdn-links --plugin typedoc-plugin-missing-exports ./src/index.ts",
+    "build": "npm run build:code & npm run build:docs & wait",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "happy-dom": "^17.1.1",
+    "promises-aplus-tests": "2.1.2",
+    "rimraf": "^5.0.5",
+    "typedoc": "^0.27.7",
+    "typedoc-plugin-markdown": "^4.4.2",
+    "typedoc-plugin-mdn-links": "^4.0.13",
+    "typedoc-plugin-missing-exports": "^3.1.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.6"
+  },
+  "overrides": {
+    "promises-aplus-tests": {
+      "mocha": "^11.1.0",
+      "sinon": "^19.0.2",
+      "underscore": "^1.13.7"
+    }
+  }
+}

package/types/application.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hides a certain method by calling the HideMethod function.
+ */
+export declare function Hide(): Promise<void>;
+/**
+ * Calls the ShowMethod and returns the result.
+ */
+export declare function Show(): Promise<void>;
+/**
+ * Calls the QuitMethod to terminate the program.
+ */
+export declare function Quit(): Promise<void>;

package/types/browser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Open a browser window to the given URL.
+ *
+ * @param url - The URL to open
+ */
+export declare function OpenURL(url: string | URL): Promise<void>;

package/types/callable.d.ts

@@ -0,0 +1,3 @@
+declare function isCallableRefApply<T>(value: T | unknown): value is (...args: any[]) => any;
+declare const _default: typeof isCallableRefApply;
+export default _default;

package/types/calls.d.ts

@@ -0,0 +1,63 @@
+import { CancellablePromise } from "./cancellable.js";
+/**
+ * Holds all required information for a binding call.
+ * May provide either a method ID or a method name, but not both.
+ */
+export type CallOptions = {
+    /** The numeric ID of the bound method to call. */
+    methodID: number;
+    /** The fully qualified name of the bound method to call. */
+    methodName?: never;
+    /** Arguments to be passed into the bound method. */
+    args: any[];
+} | {
+    /** The numeric ID of the bound method to call. */
+    methodID?: never;
+    /** The fully qualified name of the bound method to call. */
+    methodName: string;
+    /** Arguments to be passed into the bound method. */
+    args: any[];
+};
+/**
+ * Exception class that will be thrown in case the bound method returns an error.
+ * The value of the {@link RuntimeError#name} property is "RuntimeError".
+ */
+export declare class RuntimeError extends Error {
+    /**
+     * Constructs a new RuntimeError instance.
+     * @param message - The error message.
+     * @param options - Options to be forwarded to the Error constructor.
+     */
+    constructor(message?: string, options?: ErrorOptions);
+}
+/**
+ * Call a bound method according to the given call options.
+ *
+ * In case of failure, the returned promise will reject with an exception
+ * among ReferenceError (unknown method), TypeError (wrong argument count or type),
+ * {@link RuntimeError} (method returned an error), or other (network or internal errors).
+ * The exception might have a "cause" field with the value returned
+ * by the application- or service-level error marshaling functions.
+ *
+ * @param options - A method call descriptor.
+ * @returns The result of the call.
+ */
+export declare function Call(options: CallOptions): CancellablePromise<any>;
+/**
+ * Calls a bound method by name with the specified arguments.
+ * See {@link Call} for details.
+ *
+ * @param methodName - The name of the method in the format 'package.struct.method'.
+ * @param args - The arguments to pass to the method.
+ * @returns The result of the method call.
+ */
+export declare function ByName(methodName: string, ...args: any[]): CancellablePromise<any>;
+/**
+ * Calls a method by its numeric ID with the specified arguments.
+ * See {@link Call} for details.
+ *
+ * @param 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 declare function ByID(methodID: number, ...args: any[]): CancellablePromise<any>;