@wailsio/runtime 3.0.0-alpha.65 → 3.0.0-alpha.69

package/{src → dist}/wml.js

@@ -7,64 +7,52 @@
 The electron alternative for Go
 (c) Lea Anthony 2019-present
 */
-
-import {OpenURL} from "./browser";
-import {Question} from "./dialogs";
-import {Emit, WailsEvent} from "./events";
-import {canAbortListeners, whenReady} from "./utils";
-import Window from "./window";
-
+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 {string} eventName - The name of the event to send.
- * @param {any} [data=null] - Optional data to send along with the event.
- *
- * @return {void}
+ * @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(new WailsEvent(eventName, data));
+function sendEvent(eventName, data = null) {
+    Emit(eventName, data);
 }
-
 /**
  * Calls a method on a specified window.
- * @param {string} windowName - The name of the window to call the method on.
- * @param {string} methodName - The name of the method to call.
+ *
+ * @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) {
+    }
+    catch (e) {
         console.error(`Error calling window method '${methodName}': `, e);
     }
 }
-
 /**
- * Responds to a triggering event by running appropriate WML actions for the current target
- *
- * @param {Event} ev
- * @return {void}
+ * 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('data-wml-event');
-        const targetWindow = element.getAttribute('data-wml-target-window') || "";
-        const windowMethod = element.getAttribute('data-wml-window');
-        const url = element.getAttribute('data-wml-openURL');
-
+        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)
@@ -72,9 +60,7 @@ function onWMLTriggered(ev) {
         if (url !== null)
             void OpenURL(url);
     }
-
-    const confirm = element.getAttribute('data-wml-confirm');
-
+    const confirm = element.getAttribute('wml-confirm') || element.getAttribute('data-wml-confirm');
     if (confirm) {
         Question({
             Title: "Confirm",
@@ -85,65 +71,41 @@ function onWMLTriggered(ev) {
                 { Label: "No", IsDefault: true }
             ]
         }).then(runEffect);
-    } else {
+    }
+    else {
         runEffect();
     }
 }
-
-/**
- * @type {symbol}
- */
-const controller = Symbol();
-
+// 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() {
-        /**
-         * Stores the AbortController that can be used to remove all currently active listeners.
-         *
-         * @private
-         * @name {@link controller}
-         * @member {AbortController}
-         */
-        this[controller] = new AbortController();
+        this[controllerSym] = new AbortController();
     }
-
     /**
      * Returns an options object for addEventListener that ties the listener
      * to the AbortSignal from the current AbortController.
      *
-     * @param {HTMLElement} element An HTML element
-     * @param {string[]} triggers The list of active WML trigger events for the specified elements
-     * @returns {AddEventListenerOptions}
+     * @param element - An HTML element
+     * @param triggers - The list of active WML trigger events for the specified elements
      */
     set(element, triggers) {
-        return { signal: this[controller].signal };
+        return { signal: this[controllerSym].signal };
     }
-
     /**
-     * Removes all registered event listeners.
-     *
-     * @returns {void}
+     * Removes all registered event listeners and resets the registry.
      */
     reset() {
-        this[controller].abort();
-        this[controller] = new AbortController();
+        this[controllerSym].abort();
+        this[controllerSym] = new AbortController();
     }
 }
-
-/**
- * @type {symbol}
- */
-const triggerMap = Symbol();
-
-/**
- * @type {symbol}
- */
-const elementCount = Symbol();
-
 /**
  * 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
@@ -151,100 +113,67 @@ const elementCount = Symbol();
  */
 class WeakMapRegistry {
     constructor() {
-        /**
-         * Stores the current element-to-trigger mapping.
-         *
-         * @private
-         * @name {@link triggerMap}
-         * @member {WeakMap<HTMLElement, string[]>}
-         */
-        this[triggerMap] = new WeakMap();
-
-        /**
-         * Counts the number of elements with active WML triggers.
-         *
-         * @private
-         * @name {@link elementCount}
-         * @member {number}
-         */
-        this[elementCount] = 0;
+        this[triggerMapSym] = new WeakMap();
+        this[elementCountSym] = 0;
     }
-
     /**
-     * Sets the active triggers for the specified element.
+     * Sets active triggers for the specified element.
      *
-     * @param {HTMLElement} element An HTML element
-     * @param {string[]} triggers The list of active WML trigger events for the specified element
-     * @returns {AddEventListenerOptions}
+     * @param element - An HTML element
+     * @param triggers - The list of active WML trigger events for the specified element
      */
     set(element, triggers) {
-        this[elementCount] += !this[triggerMap].has(element);
-        this[triggerMap].set(element, triggers);
+        if (!this[triggerMapSym].has(element)) {
+            this[elementCountSym]++;
+        }
+        this[triggerMapSym].set(element, triggers);
         return {};
     }
-
     /**
      * Removes all registered event listeners.
-     *
-     * @returns {void}
      */
     reset() {
-        if (this[elementCount] <= 0)
+        if (this[elementCountSym] <= 0)
             return;
-
         for (const element of document.body.querySelectorAll('*')) {
-            if (this[elementCount] <= 0)
+            if (this[elementCountSym] <= 0)
                 break;
-
-            const triggers = this[triggerMap].get(element);
-            this[elementCount] -= (typeof triggers !== "undefined");
-
+            const triggers = this[triggerMapSym].get(element);
+            if (triggers != null) {
+                this[elementCountSym]--;
+            }
             for (const trigger of triggers || [])
                 element.removeEventListener(trigger, onWMLTriggered);
         }
-
-        this[triggerMap] = new WeakMap();
-        this[elementCount] = 0;
+        this[triggerMapSym] = new WeakMap();
+        this[elementCountSym] = 0;
     }
 }
-
 const triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();
-
 /**
  * Adds event listeners to the specified element.
- *
- * @param {HTMLElement} element
- * @return {void}
  */
 function addWMLListeners(element) {
     const triggerRegExp = /\S+/g;
-    const triggerAttr = (element.getAttribute('data-wml-trigger') || "click");
+    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.
- *
- * @return {void}
  */
 export function Enable() {
     whenReady(Reload);
 }
-
 /**
  * Reloads the WML page by adding necessary event listeners and browser listeners.
- *
- * @return {void}
  */
 export function Reload() {
     triggerRegistry.reset();
-    document.body.querySelectorAll('[data-wml-event], [data-wml-window], [data-wml-openURL]').forEach(addWMLListeners);
+    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl], [data-wml-event], [data-wml-window], [data-wml-openurl]').forEach(addWMLListeners);
 }

package/package.json

@@ -1,38 +1,62 @@
 {
   "name": "@wailsio/runtime",
   "type": "module",
-  "version": "3.0.0-alpha.65",
+  "version": "3.0.0-alpha.69",
   "description": "Wails Runtime",
   "types": "types/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./types/index.d.ts",
-      "require": "./src/index.js",
-      "import": "./src/index.js"
-    }
+    "types": "./types/index.d.ts",
+    "import": "./dist/index.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/wailsapp/wails.git"
-  },
-  "scripts": {
-    "prebuild:types": "rimraf ./types",
-    "build:types": "npx -p typescript tsc src/index.js --declaration --allowJs --emitDeclarationOnly --outDir types",
-    "postbuild:types": "task generate:events",
-    "build:docs": "npx typedoc ./src/index.js",
-    "build:docs:md": "npx typedoc ./src/index.js"
+    "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"
   },
-  "homepage": "https://wails.io",
-  "private": false,
+  "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.25.7",
-    "typedoc-plugin-markdown": "^3.17.1",
-    "typescript": "^5.3.3"
+    "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

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

package/types/browser.d.ts

@@ -1,6 +1,6 @@
 /**
- * Open a browser window to the given URL
- * @param {string} url - The URL to open
- * @returns {Promise<string>}
+ * Open a browser window to the given URL.
+ *
+ * @param url - The URL to open
  */
-export function OpenURL(url: string): Promise<string>;
+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

@@ -1,3 +1,35 @@
+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.
  *
@@ -7,63 +39,25 @@
  * The exception might have a "cause" field with the value returned
  * by the application- or service-level error marshaling functions.
  *
- * @param {CallOptions} options - A method call descriptor.
- * @returns {Promise<any>} - The result of the call.
+ * @param options - A method call descriptor.
+ * @returns The result of the call.
  */
-export function Call(options: CallOptions): Promise<any>;
+export declare function Call(options: CallOptions): CancellablePromise<any>;
 /**
  * Calls a bound method by name with the specified arguments.
  * See {@link Call} for details.
  *
- * @param {string} methodName - The name of the method in the format 'package.struct.method'.
- * @param {any[]} args - The arguments to pass to the method.
- * @returns {Promise<any>} The result of the method call.
+ * @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 function ByName(methodName: string, ...args: any[]): Promise<any>;
+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 {number} methodID - The ID of the method to call.
- * @param {any[]} args - The arguments to pass to the method.
- * @return {Promise<any>} - The result of the method call.
- */
-export function ByID(methodID: number, ...args: any[]): Promise<any>;
-/**
- * Collects all required information for a binding call.
- *
- * @typedef {Object} CallOptions
- * @property {number} [methodID] - The numeric ID of the bound method to call.
- * @property {string} [methodName] - The fully qualified name of the bound method to call.
- * @property {any[]} args - Arguments to be passed into the bound method.
- */
-/**
- * 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 class RuntimeError extends Error {
-    /**
-     * Constructs a new RuntimeError instance.
-     *
-     * @param {string} message - The error message.
-     * @param {any[]} args - Optional arguments for the Error constructor.
-     */
-    constructor(message: string, ...args: any[]);
-}
-/**
- * Collects all required information for a binding call.
+ * @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 type CallOptions = {
-    /**
-     * - The numeric ID of the bound method to call.
-     */
-    methodID?: number;
-    /**
-     * - The fully qualified name of the bound method to call.
-     */
-    methodName?: string;
-    /**
-     * - Arguments to be passed into the bound method.
-     */
-    args: any[];
-};
+export declare function ByID(methodID: number, ...args: any[]): CancellablePromise<any>;