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

package/types/events.d.ts

@@ -1,26 +1,48 @@
-export { Types } from "./event_types.js";
+import { Types } from "./event_types.js";
+export * from "./event_types.js";
+/**
+ * A table of data types for all known events.
+ * Will be monkey-patched by the binding generator.
+ */
+export interface CustomEvents {
+}
+/**
+ * Either a known event name or an arbitrary string.
+ */
+export type WailsEventName<E extends keyof CustomEvents = keyof CustomEvents> = E | (string & {});
+/**
+ * Union of all known system event names.
+ */
+type SystemEventName = {
+    [K in keyof (typeof Types)]: (typeof Types)[K][keyof ((typeof Types)[K])];
+} extends (infer M) ? M[keyof M] : never;
+/**
+ * The data type associated to a given event.
+ */
+export type WailsEventData<E extends WailsEventName = WailsEventName> = E extends keyof CustomEvents ? CustomEvents[E] : (E extends SystemEventName ? void : any);
 /**
  * The type of handlers for a given event.
  */
-export type Callback = (ev: WailsEvent) => void;
+export type WailsEventCallback<E extends WailsEventName = WailsEventName> = (ev: WailsEvent<E>) => void;
 /**
  * Represents a system event or a custom event emitted through wails-provided facilities.
  */
-export declare class WailsEvent {
+export declare class WailsEvent<E extends WailsEventName = WailsEventName> {
     /**
      * The name of the event.
      */
-    name: string;
+    name: E;
     /**
      * Optional data associated with the emitted event.
      */
-    data: any;
+    data: WailsEventData<E>;
     /**
      * Name of the originating window. Omitted for application events.
      * Will be overridden if set manually.
      */
     sender?: string;
-    constructor(name: string, data?: any);
+    constructor(name: E, data: WailsEventData<E>);
+    constructor(name: WailsEventData<E> extends null | void ? E : never);
 }
 /**
  * Register a callback function to be called multiple times for a specific event.
@@ -30,7 +52,7 @@ export declare class WailsEvent {
  * @param 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.
  * @returns A function that, when called, will unregister the callback from the event.
  */
-export declare function OnMultiple(eventName: string, callback: Callback, maxCallbacks: number): () => void;
+export declare function OnMultiple<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>, maxCallbacks: number): () => void;
 /**
  * Registers a callback function to be executed when the specified event occurs.
  *
@@ -38,7 +60,7 @@ export declare function OnMultiple(eventName: string, callback: Callback, maxCal
  * @param callback - The callback function to be called when the event is triggered.
  * @returns A function that, when called, will unregister the callback from the event.
  */
-export declare function On(eventName: string, callback: Callback): () => void;
+export declare function On<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void;
 /**
  * Registers a callback function to be executed only once for the specified event.
  *
@@ -46,22 +68,23 @@ export declare function On(eventName: string, callback: Callback): () => void;
  * @param callback - The callback function to be called when the event is triggered.
  * @returns A function that, when called, will unregister the callback from the event.
  */
-export declare function Once(eventName: string, callback: Callback): () => void;
+export declare function Once<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void;
 /**
  * Removes event listeners for the specified event names.
  *
  * @param eventNames - The name of the events to remove listeners for.
  */
-export declare function Off(...eventNames: [string, ...string[]]): void;
+export declare function Off(...eventNames: [WailsEventName, ...WailsEventName[]]): void;
 /**
  * Removes all event listeners.
  */
 export declare function OffAll(): void;
 /**
- * Emits an event using the name and data.
+ * Emits an event.
  *
- * @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.
+ * @returns A promise that will be fulfilled once the event has been emitted.  Resolves to true if the event was cancelled.
+ * @param name - The name of the event to emit
+ * @param data - The data that will be sent with the event
  */
-export declare function Emit(name: string, data?: any): Promise<void>;
+export declare function Emit<E extends WailsEventName = WailsEventName>(name: E, data: WailsEventData<E>): Promise<boolean>;
+export declare function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E> extends null | void ? E : never): Promise<boolean>;

package/types/index.d.ts

@@ -13,4 +13,11 @@ import * as System from "./system.js";
 import Window from "./window.js";
 import * as WML from "./wml.js";
 export { Application, Browser, Call, Clipboard, Dialogs, Events, Flags, Screens, System, Window, WML };
+/**
+ * An internal utility consumed by the binding generator.
+ *
+ * @ignore
+ */
+export { Create };
 export * from "./cancellable.js";
+export { setTransport, getTransport, type RuntimeTransport, objectNames, clientId, } from "./runtime.js";

package/types/plugins/vite.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+/**
+ * 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: string): Plugin;

package/types/runtime.d.ts

@@ -1,3 +1,5 @@
+import { nanoid } from "./nanoid.js";
+export { nanoid };
 export declare const objectNames: Readonly<{
     Call: 0;
     Clipboard: 1;
@@ -12,6 +14,48 @@ export declare const objectNames: Readonly<{
     CancelCall: 10;
 }>;
 export declare let clientId: string;
+/**
+ * RuntimeTransport defines the interface for custom IPC transport implementations.
+ * Implement this interface to use WebSockets, custom protocols, or any other
+ * transport mechanism instead of the default HTTP fetch.
+ */
+export interface RuntimeTransport {
+    /**
+     * Send a runtime call and return the response.
+     *
+     * @param objectID - The Wails object ID (0=Call, 1=Clipboard, etc.)
+     * @param method - The method ID to call
+     * @param windowName - Optional window name
+     * @param args - Arguments to pass (will be JSON stringified if present)
+     * @returns Promise that resolves with the response data
+     */
+    call(objectID: number, method: number, windowName: string, args: any): Promise<any>;
+}
+/**
+ * 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 declare function setTransport(transport: RuntimeTransport | null): void;
+/**
+ * Get the current transport (useful for extending/wrapping)
+ */
+export declare function getTransport(): RuntimeTransport | null;
 /**
  * Creates a new runtime caller with specified ID.
  *