@wailsio/runtime 3.0.0-alpha.72 → 3.0.0-alpha.74

package/dist/calls.js

@@ -12,8 +12,6 @@ import { newRuntimeCaller, objectNames } from "./runtime.js";
 import { nanoid } from "./nanoid.js";
 // Setup
 window._wails = window._wails || {};
-window._wails.callResultHandler = resultHandler;
-window._wails.callErrorHandler = errorHandler;
 const call = newRuntimeCaller(objectNames.Call);
 const cancelCall = newRuntimeCaller(objectNames.CancelCall);
 const callResponses = new Map();
@@ -34,90 +32,6 @@ export class RuntimeError extends Error {
         this.name = "RuntimeError";
     }
 }
-/**
- * Handles the result of a call request.
- *
- * @param id - The id of the request to handle the result for.
- * @param data - The result data of the request.
- * @param isJSON - Indicates whether the data is JSON or not.
- */
-function resultHandler(id, data, isJSON) {
-    const resolvers = getAndDeleteResponse(id);
-    if (!resolvers) {
-        return;
-    }
-    if (!data) {
-        resolvers.resolve(undefined);
-    }
-    else if (!isJSON) {
-        resolvers.resolve(data);
-    }
-    else {
-        try {
-            resolvers.resolve(JSON.parse(data));
-        }
-        catch (err) {
-            resolvers.reject(new TypeError("could not parse result: " + err.message, { cause: err }));
-        }
-    }
-}
-/**
- * Handles the error from a call request.
- *
- * @param id - The id of the promise handler.
- * @param data - The error data to reject the promise handler with.
- * @param isJSON - Indicates whether the data is JSON or not.
- */
-function errorHandler(id, data, isJSON) {
-    const resolvers = getAndDeleteResponse(id);
-    if (!resolvers) {
-        return;
-    }
-    if (!isJSON) {
-        resolvers.reject(new Error(data));
-    }
-    else {
-        let error;
-        try {
-            error = JSON.parse(data);
-        }
-        catch (err) {
-            resolvers.reject(new TypeError("could not parse error: " + err.message, { cause: err }));
-            return;
-        }
-        let options = {};
-        if (error.cause) {
-            options.cause = error.cause;
-        }
-        let exception;
-        switch (error.kind) {
-            case "ReferenceError":
-                exception = new ReferenceError(error.message, options);
-                break;
-            case "TypeError":
-                exception = new TypeError(error.message, options);
-                break;
-            case "RuntimeError":
-                exception = new RuntimeError(error.message, options);
-                break;
-            default:
-                exception = new Error(error.message, options);
-                break;
-        }
-        resolvers.reject(exception);
-    }
-}
-/**
- * Retrieves and removes the response associated with the given ID from the callResponses map.
- *
- * @param id - The ID of the response to be retrieved and removed.
- * @returns The response object associated with the given ID, if any.
- */
-function getAndDeleteResponse(id) {
-    const response = callResponses.get(id);
-    callResponses.delete(id);
-    return response;
-}
 /**
  * Generates a unique ID using the nanoid library.
  *
@@ -147,10 +61,13 @@ export function Call(options) {
     const result = CancellablePromise.withResolvers();
     callResponses.set(id, { resolve: result.resolve, reject: result.reject });
     const request = call(CallBinding, Object.assign({ "call-id": id }, options));
-    let running = false;
-    request.then(() => {
-        running = true;
+    let running = true;
+    request.then((res) => {
+        running = false;
+        callResponses.delete(id);
+        result.resolve(res);
     }, (err) => {
+        running = false;
         callResponses.delete(id);
         result.reject(err);
     });

package/dist/create.js

@@ -92,3 +92,8 @@ export function Struct(createField) {
         return source;
     };
 }
+/**
+ * Maps known event names to creation functions for their data types.
+ * Will be monkey-patched by the binding generator.
+ */
+export const Events = {};

package/dist/dialogs.js

@@ -8,13 +8,9 @@ The electron alternative for Go
 (c) Lea Anthony 2019-present
 */
 import { newRuntimeCaller, objectNames } from "./runtime.js";
-import { nanoid } from './nanoid.js';
 // setup
 window._wails = window._wails || {};
-window._wails.dialogErrorCallback = dialogErrorCallback;
-window._wails.dialogResultCallback = dialogResultCallback;
 const call = newRuntimeCaller(objectNames.Dialog);
-const dialogResponses = new Map();
 // Define constants from the `methods` object in Title Case
 const DialogInfo = 0;
 const DialogWarning = 1;
@@ -22,63 +18,6 @@ const DialogError = 2;
 const DialogQuestion = 3;
 const DialogOpenFile = 4;
 const DialogSaveFile = 5;
-/**
- * Handles the result of a dialog request.
- *
- * @param id - The id of the request to handle the result for.
- * @param data - The result data of the request.
- * @param isJSON - Indicates whether the data is JSON or not.
- */
-function dialogResultCallback(id, data, isJSON) {
-    let resolvers = getAndDeleteResponse(id);
-    if (!resolvers) {
-        return;
-    }
-    if (isJSON) {
-        try {
-            resolvers.resolve(JSON.parse(data));
-        }
-        catch (err) {
-            resolvers.reject(new TypeError("could not parse result: " + err.message, { cause: err }));
-        }
-    }
-    else {
-        resolvers.resolve(data);
-    }
-}
-/**
- * Handles the error from a dialog request.
- *
- * @param id - The id of the promise handler.
- * @param message - An error message.
- */
-function dialogErrorCallback(id, message) {
-    var _a;
-    (_a = getAndDeleteResponse(id)) === null || _a === void 0 ? void 0 : _a.reject(new window.Error(message));
-}
-/**
- * Retrieves and removes the response associated with the given ID from the dialogResponses map.
- *
- * @param id - The ID of the response to be retrieved and removed.
- * @returns The response object associated with the given ID, if any.
- */
-function getAndDeleteResponse(id) {
-    const response = dialogResponses.get(id);
-    dialogResponses.delete(id);
-    return response;
-}
-/**
- * Generates a unique ID using the nanoid library.
- *
- * @returns A unique ID that does not exist in the dialogResponses set.
- */
-function generateID() {
-    let result;
-    do {
-        result = nanoid();
-    } while (dialogResponses.has(result));
-    return result;
-}
 /**
  * Presents a dialog of specified type with the given options.
  *
@@ -87,14 +26,7 @@ function generateID() {
  * @returns A promise that resolves with result of dialog.
  */
 function dialog(type, options = {}) {
-    const id = generateID();
-    return new Promise((resolve, reject) => {
-        dialogResponses.set(id, { resolve, reject });
-        call(type, Object.assign({ "dialog-id": id }, options)).catch((err) => {
-            dialogResponses.delete(id);
-            reject(err);
-        });
-    });
+    return call(type, options);
 }
 /**
  * Presents an info dialog.

package/dist/event_types.js

@@ -230,3 +230,7 @@ export const Types = Object.freeze({
         WindowDropZoneFilesDropped: "common:WindowDropZoneFilesDropped",
     }),
 });
+export const Windows = Types.Windows;
+export const Mac = Types.Mac;
+export const Linux = Types.Linux;
+export const Common = Types.Common;

package/dist/events.js

@@ -9,19 +9,21 @@ The electron alternative for Go
 */
 import { newRuntimeCaller, objectNames } from "./runtime.js";
 import { eventListeners, Listener, listenerOff } from "./listener.js";
+import { Events as Create } from "./create.js";
+import { Types } from "./event_types.js";
 // Setup
 window._wails = window._wails || {};
 window._wails.dispatchWailsEvent = dispatchWailsEvent;
 const call = newRuntimeCaller(objectNames.Events);
 const EmitMethod = 0;
-export { Types } from "./event_types.js";
+export * from "./event_types.js";
 /**
  * Represents a system event or a custom event emitted through wails-provided facilities.
  */
 export class WailsEvent {
-    constructor(name, data = null) {
+    constructor(name, data) {
         this.name = name;
-        this.data = data;
+        this.data = data !== null && data !== void 0 ? data : null;
     }
 }
 function dispatchWailsEvent(event) {
@@ -29,7 +31,7 @@ function dispatchWailsEvent(event) {
     if (!listeners) {
         return;
     }
-    let wailsEvent = new WailsEvent(event.name, event.data);
+    let wailsEvent = new WailsEvent(event.name, (event.name in Create) ? Create[event.name](event.data) : event.data);
     if ('sender' in event) {
         wailsEvent.sender = event.sender;
     }
@@ -90,25 +92,6 @@ export function Off(...eventNames) {
 export function OffAll() {
     eventListeners.clear();
 }
-/**
- * Emits an event using the name and data.
- *
- * @returns A promise that will be fulfilled once the event has been emitted.
- * @param name - the name of the event to emit.
- * @param data - the data to be sent with the event.
- */
 export function Emit(name, data) {
-    let eventName;
-    let eventData;
-    if (typeof name === 'object' && name !== null && 'name' in name && 'data' in name) {
-        // If name is an object with a name property, use it directly
-        eventName = name['name'];
-        eventData = name['data'];
-    }
-    else {
-        // Otherwise use the standard parameters
-        eventName = name;
-        eventData = data;
-    }
-    return call(EmitMethod, { name: eventName, data: eventData });
+    return call(EmitMethod, new WailsEvent(name, data));
 }

package/dist/index.js

@@ -29,10 +29,11 @@ export { Application, Browser, Call, Clipboard, Dialogs, Events, Flags, Screens,
  * An internal utility consumed by the binding generator.
  *
  * @ignore
- * @internal
  */
 export { Create };
 export * from "./cancellable.js";
+// Export transport interfaces and utilities
+export { setTransport, getTransport, objectNames, clientId, } from "./runtime.js";
 // Notify backend
 window._wails.invoke = System.invoke;
 // Register platform handlers (internal API)

package/dist/plugins/vite.js

@@ -0,0 +1,64 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+const TYPED_EVENTS_MODULE = "\0wailsio_runtime_events_typed";
+/**
+ * A plugin that extends the wails runtime with locally generated code
+ * to provide support for typed custom events.
+ * With the plugin installed, vite will fail to build the project
+ * unless wails bindings have been generated first.
+ *
+ * @param {string} [bindingsRoot] - The root import path for generated bindings
+ */
+export default function WailsTypedEvents(bindingsRoot) {
+    let bindingsId, runtimeId, eventsId;
+    return {
+        name: "wails-typed-events",
+        async buildStart() {
+            const bindingsPath = `${bindingsRoot}/github.com/wailsapp/wails/v3/internal/eventcreate`;
+            let resolution = await this.resolve(bindingsPath);
+            if (!resolution || resolution.external) {
+                this.error(`Event bindings module not found at import specifier '${bindingsPath}'. Please verify that the wails tool is up to date and the binding generator runs successfully. If you moved the bindings to a custom location, ensure you supplied the correct root path as the first argument to \`wailsTypedEventsPlugin\``);
+                return;
+            }
+            bindingsId = resolution.id;
+            resolution = await this.resolve("@wailsio/runtime");
+            if (!resolution || resolution.external) {
+                return;
+            }
+            runtimeId = resolution.id;
+            resolution = await this.resolve("./events.js", runtimeId);
+            if (!resolution || resolution.external) {
+                this.error("Could not resolve events module within @wailsio/runtime package. Please verify that the module is correctly installed and up to date.");
+                return;
+            }
+            eventsId = resolution.id;
+        },
+        resolveId: {
+            order: 'pre',
+            handler(id, importer) {
+                if (bindingsId !== null
+                    && runtimeId !== null
+                    && eventsId !== null
+                    && importer === runtimeId
+                    && id === "./events.js") {
+                    return TYPED_EVENTS_MODULE;
+                }
+                return undefined;
+            }
+        },
+        load(id) {
+            if (id === TYPED_EVENTS_MODULE) {
+                return (`import ${JSON.stringify(bindingsId)};\n`
+                    + `export * from ${JSON.stringify(eventsId)};`);
+            }
+            return undefined;
+        }
+    };
+}

package/dist/runtime.js

@@ -7,8 +7,10 @@
 The electron alternative for Go
 (c) Lea Anthony 2019-present
 */
-import { nanoid } from './nanoid.js';
+import { nanoid } from "./nanoid.js";
 const runtimeURL = window.location.origin + "/wails/runtime";
+// Re-export nanoid for custom transport implementations
+export { nanoid };
 // Object Names
 export const objectNames = Object.freeze({
     Call: 0,
@@ -24,6 +26,39 @@ export const objectNames = Object.freeze({
     CancelCall: 10,
 });
 export let clientId = nanoid();
+/**
+ * Custom transport implementation (can be set by user)
+ */
+let customTransport = null;
+/**
+ * Set a custom transport for all Wails runtime calls.
+ * This allows you to replace the default HTTP fetch transport with
+ * WebSockets, custom protocols, or any other mechanism.
+ *
+ * @param transport - Your custom transport implementation
+ *
+ * @example
+ * ```typescript
+ * import { setTransport } from '/wails/runtime.js';
+ *
+ * const wsTransport = {
+ *   call: async (objectID, method, windowName, args) => {
+ *     // Your WebSocket implementation
+ *   }
+ * };
+ *
+ * setTransport(wsTransport);
+ * ```
+ */
+export function setTransport(transport) {
+    customTransport = transport;
+}
+/**
+ * Get the current transport (useful for extending/wrapping)
+ */
+export function getTransport() {
+    return customTransport;
+}
 /**
  * Creates a new runtime caller with specified ID.
  *
@@ -38,19 +73,31 @@ export function newRuntimeCaller(object, windowName = '') {
 }
 async function runtimeCallWithID(objectID, method, windowName, args) {
     var _a, _b;
+    // Use custom transport if available
+    if (customTransport) {
+        return customTransport.call(objectID, method, windowName, args);
+    }
+    // Default HTTP fetch transport
     let url = new URL(runtimeURL);
-    url.searchParams.append("object", objectID.toString());
-    url.searchParams.append("method", method.toString());
-    if (args) {
-        url.searchParams.append("args", JSON.stringify(args));
+    let body = {
+        object: objectID,
+        method
+    };
+    if (args !== null && args !== undefined) {
+        body.args = args;
     }
     let headers = {
-        ["x-wails-client-id"]: clientId
+        ["x-wails-client-id"]: clientId,
+        ["Content-Type"]: "application/json"
     };
     if (windowName) {
         headers["x-wails-window-name"] = windowName;
     }
-    let response = await fetch(url, { headers });
+    let response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+    });
     if (!response.ok) {
         throw new Error(await response.text());
     }

package/dist/system.js

@@ -11,6 +11,7 @@ import { newRuntimeCaller, objectNames } from "./runtime.js";
 const call = newRuntimeCaller(objectNames.System);
 const SystemIsDarkMode = 0;
 const SystemEnvironment = 1;
+const SystemCapabilities = 2;
 const ApplicationFilesDroppedWithContext = 100; // New method ID for enriched drop event
 const _invoke = (function () {
     var _a, _b, _c, _d, _e;
@@ -43,13 +44,7 @@ export function IsDarkMode() {
  * @returns A promise that resolves to an object containing the capabilities.
  */
 export async function Capabilities() {
-    let response = await fetch("/wails/capabilities");
-    if (response.ok) {
-        return response.json();
-    }
-    else {
-        throw new Error("could not fetch capabilities: " + response.statusText);
-    }
+    return call(SystemCapabilities);
 }
 /**
  * Retrieves environment details.

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@wailsio/runtime",
   "type": "module",
-  "version": "3.0.0-alpha.72",
+  "version": "3.0.0-alpha.74",
   "description": "Wails Runtime",
   "types": "types/index.d.ts",
   "exports": {
-    "types": "./types/index.d.ts",
-    "import": "./dist/index.js"
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugins/*": {
+      "types": "./types/plugins/*.d.ts",
+      "default": "./dist/plugins/*.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -50,6 +56,7 @@
     "typedoc-plugin-mdn-links": "^4.0.13",
     "typedoc-plugin-missing-exports": "^3.1.0",
     "typescript": "^5.7.3",
+    "vite": "^5.2.0",
     "vitest": "^3.0.6"
   },
   "overrides": {

package/types/cancellable.d.ts

@@ -108,7 +108,6 @@ export interface CancellablePromiseWithResolvers<T> {
  * if so is the underlying implementation.
  */
 export declare class CancellablePromise<T> extends Promise<T> implements PromiseLike<T>, CancellablePromiseLike<T> {
-    static [x: symbol]: PromiseConstructor;
     /**
      * Creates a new `CancellablePromise`.
      *

package/types/create.d.ts

@@ -29,3 +29,8 @@ export declare function Nullable<T = any>(element: (source: any) => T): (source:
  * and returns an in-place creation function for a struct.
  */
 export declare function Struct(createField: Record<string, (source: any) => any>): <U extends Record<string, any> = any>(source: any) => U;
+/**
+ * Maps known event names to creation functions for their data types.
+ * Will be monkey-patched by the binding generator.
+ */
+export declare const Events: Record<string, (source: any) => any>;