electron-json-rpc 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,78 @@
+import { S as UnderlyingSource, _ as RpcValidator, a as ExposeRpcApiOptions, b as StreamMethodOptions, c as JsonRpcRequest, d as RpcClientOptions, f as RpcDebugOptions, g as RpcMethodOptions, h as RpcLogger, i as EventSubscriber, l as JsonRpcResponse, m as RpcLogEntry, n as EventBusEvents, o as JsonRpcError, p as RpcHandler, r as EventHandler, s as JsonRpcErrorCode, t as EventBus, u as RpcApi, v as StreamChunk, x as StreamRequest, y as StreamHandler } from "./types-BnGse9DF.mjs";
+import { STREAM_CHANNEL, asyncGeneratorToStream, createStreamChunk, generateStreamId, isReadableStream, iterableToStream, readStream } from "./stream.mjs";
+
+//#region src/error.d.ts
+/**
+ * Create a JSON-RPC error object
+ */
+declare function createJsonRpcError(code: number, message: string, data?: unknown): JsonRpcError;
+/**
+ * Predefined error creators
+ */
+declare const errors: {
+  parseError: (data?: unknown) => JsonRpcError;
+  invalidRequest: (data?: unknown) => JsonRpcError;
+  methodNotFound: (method?: string) => JsonRpcError;
+  invalidParams: (data?: unknown) => JsonRpcError;
+  internalError: (data?: unknown) => JsonRpcError;
+};
+/**
+ * Check if an error is a JSON-RPC error
+ */
+declare function isJsonRpcError(error: unknown): error is JsonRpcError;
+/**
+ * Convert an Error object to JSON-RPC error
+ */
+declare function errorToJsonRpc(error: unknown): JsonRpcError;
+/**
+ * Timeout error class
+ */
+declare class RpcTimeoutError extends Error {
+  readonly name: "RpcTimeoutError";
+  readonly timeout: number;
+  constructor(timeout: number);
+}
+/**
+ * Check if an error is a timeout error
+ */
+declare function isTimeoutError(error: unknown): error is RpcTimeoutError;
+/**
+ * Error thrown when queue is full and fullBehavior is 'reject'
+ */
+declare class RpcQueueFullError extends Error {
+  readonly name: "RpcQueueFullError";
+  readonly currentSize: number;
+  readonly maxSize: number;
+  constructor(currentSize: number, maxSize: number);
+}
+/**
+ * Error thrown when connection to main process is lost
+ */
+declare class RpcConnectionError extends Error {
+  readonly name: "RpcConnectionError";
+  readonly code?: string;
+  constructor(message: string, code?: string);
+}
+/**
+ * Error thrown when request is evicted from queue
+ */
+declare class RpcQueueEvictedError extends Error {
+  readonly name: "RpcQueueEvictedError";
+  readonly reason: "full" | "timeout";
+  constructor(reason: "full" | "timeout");
+}
+/**
+ * Check if an error is a queue full error
+ */
+declare function isQueueFullError(error: unknown): error is RpcQueueFullError;
+/**
+ * Check if an error is a connection error
+ */
+declare function isConnectionError(error: unknown): error is RpcConnectionError;
+/**
+ * Check if an error is a queue evicted error
+ */
+declare function isQueueEvictedError(error: unknown): error is RpcQueueEvictedError;
+//#endregion
+export { EventBus, EventBusEvents, EventHandler, EventSubscriber, ExposeRpcApiOptions, JsonRpcError, JsonRpcErrorCode, JsonRpcRequest, JsonRpcResponse, RpcApi, RpcClientOptions, RpcConnectionError, RpcDebugOptions, RpcHandler, RpcLogEntry, RpcLogger, RpcMethodOptions, RpcQueueEvictedError, RpcQueueFullError, RpcTimeoutError, RpcValidator, STREAM_CHANNEL, StreamChunk, StreamHandler, StreamMethodOptions, StreamRequest, UnderlyingSource, asyncGeneratorToStream, createJsonRpcError, createStreamChunk, errorToJsonRpc, errors, generateStreamId, isConnectionError, isJsonRpcError, isQueueEvictedError, isQueueFullError, isReadableStream, isTimeoutError, iterableToStream, readStream };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/error.ts"],"mappings":";;;;;AAUA;AAOA;iBAPgB,kBAAA,CAAA,IAAA,UAAA,OAAA,UAAA,IAAA,aAAmE,YAAA;AAAA;AAOnF;;AAPmF,cAOtE,MAAA;EAAA,UAAA,GAAA,IAAA,eACgB,YAAA;EAAA,cAAA,GAAA,IAAA,eAEI,YAAA;EAAA,cAAA,GAAA,MAAA,cAEC,YAAA;EAAA,aAAA,GAAA,IAAA,eAKF,YAAA;EAAA,aAAA,GAAA,IAAA,eAEA,YAAA;AAAA;AAAA;;AAOhC;AAPgC,iBAOhB,cAAA,CAAA,KAAA,YAAA,KAAA,IAAyC,YAAA;AAAA;AAczD;AAuBA;AArCyD,iBAczC,cAAA,CAAA,KAAA,YAAgC,YAAA;AAAA;AAuBhD;AAcA;AArCgD,cAuBnC,eAAA,SAAwB,KAAA;EAAA,SAAA,IAAA;EAAA,SAAA,OAAA;EAAA,YAAA,OAAA;AAAA;AAAA;AAcrC;AAOA;AArBqC,iBAcrB,cAAA,CAAA,KAAA,YAAA,KAAA,IAAyC,eAAA;AAAA;AAOzD;AAgBA;AAvByD,cAO5C,iBAAA,SAA0B,KAAA;EAAA,SAAA,IAAA;EAAA,SAAA,WAAA;EAAA,SAAA,OAAA;EAAA,YAAA,WAAA,UAAA,OAAA;AAAA;AAAA;AAgBvC;AAcA;AA9BuC,cAgB1B,kBAAA,SAA2B,KAAA;EAAA,SAAA,IAAA;EAAA,SAAA,IAAA;EAAA,YAAA,OAAA,UAAA,IAAA;AAAA;AAAA;AAcxC;AAcA;AA5BwC,cAc3B,oBAAA,SAA6B,KAAA;EAAA,SAAA,IAAA;EAAA,SAAA,MAAA;EAAA,YAAA,MAAA;AAAA;AAAA;AAc1C;AAOA;AArB0C,iBAc1B,gBAAA,CAAA,KAAA,YAAA,KAAA,IAA2C,iBAAA;AAAA;AAO3D;AAOA;AAd2D,iBAO3C,iBAAA,CAAA,KAAA,YAAA,KAAA,IAA4C,kBAAA;AAAA;AAO5D;;AAP4D,iBAO5C,mBAAA,CAAA,KAAA,YAAA,KAAA,IAA8C,oBAAA"}

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { a as createJsonRpcError, c as isConnectionError, d as isQueueFullError, f as isTimeoutError, i as RpcTimeoutError, l as isJsonRpcError, n as RpcQueueEvictedError, o as errorToJsonRpc, p as JsonRpcErrorCode, r as RpcQueueFullError, s as errors, t as RpcConnectionError, u as isQueueEvictedError } from "./error-xVRu7Lxq.mjs";
+import { STREAM_CHANNEL, asyncGeneratorToStream, createStreamChunk, generateStreamId, isReadableStream, iterableToStream, readStream } from "./stream.mjs";
+
+export { JsonRpcErrorCode, RpcConnectionError, RpcQueueEvictedError, RpcQueueFullError, RpcTimeoutError, STREAM_CHANNEL, asyncGeneratorToStream, createJsonRpcError, createStreamChunk, errorToJsonRpc, errors, generateStreamId, isConnectionError, isJsonRpcError, isQueueEvictedError, isQueueFullError, isReadableStream, isTimeoutError, iterableToStream, readStream };

package/dist/internal-BZK_0O3n.mjs

@@ -0,0 +1,23 @@
+import { createDebugTracker, isDebugEnabled } from "./debug.mjs";
+
+//#region src/renderer/internal.ts
+/**
+* Default API name exposed by preload
+*/
+const DEFAULT_API_NAME = "rpc";
+/**
+* Get the exposed API from window object
+*/
+function getExposedApi(apiName) {
+	return window[apiName] ?? null;
+}
+/**
+* Create debug tracker with optional logger
+*/
+function createTracker(debug, logger) {
+	return createDebugTracker(isDebugEnabled(debug), logger ?? (() => {}));
+}
+
+//#endregion
+export { createTracker as n, getExposedApi as r, DEFAULT_API_NAME as t };
+//# sourceMappingURL=internal-BZK_0O3n.mjs.map

package/dist/internal-BZK_0O3n.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-BZK_0O3n.mjs","names":[],"sources":["../src/renderer/internal.ts"],"sourcesContent":["/**\n * Internal utilities for renderer modules\n */\n\nimport type { RpcLogger } from \"../types.js\";\nimport { isDebugEnabled, createDebugTracker, type DebugTracker } from \"../debug.js\";\n\n/**\n * Default API name exposed by preload\n */\nexport const DEFAULT_API_NAME = \"rpc\";\n\n/**\n * Preload API type\n */\nexport type PreloadApi = {\n  call: (method: string, ...params: unknown[]) => Promise<unknown>;\n  notify: (method: string, ...params: unknown[]) => void;\n  stream: (method: string, ...params: unknown[]) => ReadableStream;\n  on?: (eventName: string, callback: (data?: unknown) => void) => () => void;\n  off?: (eventName: string, callback?: (data?: unknown) => void) => void;\n  once?: (eventName: string, callback: (data?: unknown) => void) => void;\n  proxy?: <T>(methodNames?: (keyof T)[]) => T;\n};\n\n/**\n * Get the exposed API from window object\n */\nexport function getExposedApi(apiName: string): PreloadApi | null {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const win = window as any;\n  return win[apiName] ?? null;\n}\n\n/**\n * Create debug tracker with optional logger\n */\nexport function createTracker(\n  debug: boolean | undefined,\n  logger: RpcLogger | undefined,\n): DebugTracker {\n  const enabled = isDebugEnabled(debug);\n  return createDebugTracker(enabled, logger ?? (() => {}));\n}\n"],"mappings":";;;;;;AAUA,MAAa,mBAAmB;;;;AAkBhC,SAAgB,cAAc,SAAoC;AAGhE,QADY,OACD,YAAY;;;;;AAMzB,SAAgB,cACd,OACA,QACc;AAEd,QAAO,mBADS,eAAe,MAAM,EACF,iBAAiB,IAAI"}

package/dist/main.d.mts

@@ -0,0 +1,151 @@
+import { g as RpcMethodOptions, p as RpcHandler, y as StreamHandler } from "./types-BnGse9DF.mjs";
+
+//#region src/main.d.ts
+/**
+ * JSON-RPC Server for Electron Main Process
+ *
+ * @example
+ * ```typescript
+ * import { app, BrowserWindow } from 'electron';
+ * import { RpcServer } from 'electron-json-rpc/main';
+ *
+ * const rpc = new RpcServer();
+ *
+ * rpc.register('add', (a: number, b: number) => a + b);
+ * rpc.register('fetchData', async (url: string) => {
+ *   const response = await fetch(url);
+ *   return response.json();
+ * });
+ * ```
+ */
+declare class RpcServer {
+  private readonly methods;
+  private readonly streams;
+  private readonly eventSubscribers;
+  private readonly handleMessageBound;
+  private readonly handleStreamMessageBound;
+  private readonly handleEventBusMessageBound;
+  private ipcMain;
+  private webContents;
+  private isListening;
+  constructor(
+  /**
+       * Electron instance (for dependency injection in testing)
+       * @internal
+       */
+  electron?: {
+    ipcMain: any;
+    webContents: any;
+  });
+  /**
+       * Register a RPC method
+       * @param name - Method name
+       * @param handler - Handler function
+       * @param options - Optional validation and metadata
+       */
+  register(name: string, handler: RpcHandler, options?: RpcMethodOptions): void;
+  /**
+       * Register a stream method that returns a ReadableStream
+       * @param name - Method name
+       * @param handler - Handler function that returns a ReadableStream
+       * @param options - Optional validation and metadata
+       *
+       * @example
+       * ```typescript
+       * rpc.registerStream('dataStream', (count: number) => {
+       *   return new ReadableStream({
+       *     async start(controller) {
+       *       for (let i = 0; i < count; i++) {
+       *         controller.enqueue({ index: i, data: `chunk ${i}` });
+       *         await new Promise(r => setTimeout(r, 100));
+       *       }
+       *       controller.close();
+       *     }
+       *   });
+       * });
+       * ```
+       */
+  registerStream(name: string, handler: StreamHandler, options?: RpcMethodOptions): void;
+  /**
+       * Unregister a RPC method
+       */
+  unregister(name: string): void;
+  /**
+       * Check if a method is registered
+       */
+  has(name: string): boolean;
+  /**
+       * Get all registered method names
+       */
+  getMethodNames(): string[];
+  /**
+       * Start listening for IPC messages
+       */
+  listen(): void;
+  /**
+       * Stop listening for IPC messages
+       */
+  dispose(): void;
+  /**
+       * Handle incoming IPC message
+       */
+  private handleMessage;
+  /**
+       * Handle stream-related messages from renderer
+       */
+  private handleStreamMessage;
+  /**
+       * Process a single request and return response
+       */
+  private processRequest;
+  /**
+       * Handle a stream method request
+       * Returns stream ID and starts streaming in background
+       */
+  private handleStreamRequest;
+  /**
+       * Execute a stream handler and send chunks to renderer
+       */
+  private executeStreamHandler;
+  /**
+       * Handle event bus messages (subscribe/unsubscribe)
+       */
+  private handleEventBusMessage;
+  /**
+       * Subscribe a window to an event
+       */
+  private subscribeToEvent;
+  /**
+       * Unsubscribe a window from an event
+       */
+  private unsubscribeFromEvent;
+  /**
+       * Publish an event to all subscribed windows
+       * @param eventName - The name of the event to publish
+       * @param data - Optional data to send with the event
+       *
+       * @example
+       * ```typescript
+       * rpc.publish('user-updated', { id: '123', name: 'John' });
+       * ```
+       */
+  publish(eventName: string, data?: unknown): void;
+  /**
+       * Get current event subscribers
+       * @returns Record mapping event names to subscriber counts
+       *
+       * @example
+       * ```typescript
+       * const subscribers = rpc.getEventSubscribers();
+       * console.log(subscribers); // { 'user-updated': 2, 'data-changed': 1 }
+       * ```
+       */
+  getEventSubscribers(): Record<string, number>;
+}
+/**
+ * Create a new RPC server instance
+ */
+declare function createRpcServer(): RpcServer;
+//#endregion
+export { RpcServer, createRpcServer };
+//# sourceMappingURL=main.d.mts.map

package/dist/main.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.mts","names":[],"sources":["../src/main.ts"],"mappings":";;;;AA2DA;;;;;;;AAibA;;;;;;;;;cAjba,SAAA;EAAA,iBAAA,OAAA;EAAA,iBAAA,OAAA;EAAA,iBAAA,gBAAA;EAAA,iBAAA,kBAAA;EAAA,iBAAA,wBAAA;EAAA,iBAAA,0BAAA;EAAA,QAAA,OAAA;EAAA,QAAA,WAAA;EAAA,QAAA,WAAA;EAAA;EAAA;;;;EAAA,QAAA;IAAA,OAAA;IAAA,WAAA;EAAA;EAAA;;;;;;EAAA,SAAA,IAAA,UAAA,OAAA,EAmDqB,UAAA,EAAA,OAAA,GAAsB,gBAAA;EAAA;;;;;AA8XxD;;;;;;;;;;;;;;;;EA9XwD,eAAA,IAAA,UAAA,OAAA,EA6BhB,aAAA,EAAA,OAAA,GAAyB,gBAAA;EAAA;;;EAAA,WAAA,IAAA;EAAA;;;EAAA,IAAA,IAAA;EAAA;;;EAAA,eAAA;EAAA;;;EAAA,OAAA;EAAA;;;EAAA,QAAA;EAAA;;;EAAA,QAAA,aAAA;EAAA;;;EAAA,QAAA,mBAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;AAiWjE;EAjWiE,QAAA,mBAAA;EAAA;;;EAAA,QAAA,oBAAA;EAAA;;;EAAA,QAAA,qBAAA;EAAA;;;EAAA,QAAA,gBAAA;EAAA;;;EAAA,QAAA,oBAAA;EAAA;;;AAiWjE;;;;;;;EAjWiE,QAAA,SAAA,UAAA,IAAA;EAAA;;;AAiWjE;;;;;;;EAjWiE,oBAAA,GAqVxC,MAAA;AAAA;AAAA;;AAYzB;AAZyB,iBAYT,eAAA,CAAA,GAAmB,SAAA"}

package/dist/main.mjs

@@ -0,0 +1,329 @@
+import { o as errorToJsonRpc, s as errors } from "./error-xVRu7Lxq.mjs";
+import { STREAM_CHANNEL, createStreamChunk, generateStreamId } from "./stream.mjs";
+import { EVENT_CHANNEL } from "./event.mjs";
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/main.ts
+/**
+* IPC channel name for JSON-RPC communication
+*/
+const RPC_CHANNEL = "json-rpc";
+const HEALTH_CHECK_METHOD = "__rpc_health__";
+/**
+* JSON-RPC Server for Electron Main Process
+*
+* @example
+* ```typescript
+* import { app, BrowserWindow } from 'electron';
+* import { RpcServer } from 'electron-json-rpc/main';
+*
+* const rpc = new RpcServer();
+*
+* rpc.register('add', (a: number, b: number) => a + b);
+* rpc.register('fetchData', async (url: string) => {
+*   const response = await fetch(url);
+*   return response.json();
+* });
+* ```
+*/
+var RpcServer = class {
+	methods = /* @__PURE__ */ new Map();
+	streams = /* @__PURE__ */ new Map();
+	eventSubscribers = /* @__PURE__ */ new Map();
+	handleMessageBound;
+	handleStreamMessageBound;
+	handleEventBusMessageBound;
+	ipcMain;
+	webContents;
+	isListening = false;
+	constructor(electron) {
+		try {
+			const e = electron || __require("electron");
+			this.ipcMain = e.ipcMain;
+			this.webContents = e.webContents;
+		} catch {
+			throw new Error("Electron not found. Please install electron as a peer dependency.");
+		}
+		this.handleMessageBound = this.handleMessage.bind(this);
+		this.handleStreamMessageBound = this.handleStreamMessage.bind(this);
+		this.handleEventBusMessageBound = this.handleEventBusMessage.bind(this);
+		if (!this.methods.has(HEALTH_CHECK_METHOD)) this.register(HEALTH_CHECK_METHOD, () => true);
+	}
+	/**
+	* Register a RPC method
+	* @param name - Method name
+	* @param handler - Handler function
+	* @param options - Optional validation and metadata
+	*/
+	register(name, handler, options) {
+		this.methods.set(name, {
+			handler,
+			validate: options?.validate,
+			description: options?.description
+		});
+	}
+	/**
+	* Register a stream method that returns a ReadableStream
+	* @param name - Method name
+	* @param handler - Handler function that returns a ReadableStream
+	* @param options - Optional validation and metadata
+	*
+	* @example
+	* ```typescript
+	* rpc.registerStream('dataStream', (count: number) => {
+	*   return new ReadableStream({
+	*     async start(controller) {
+	*       for (let i = 0; i < count; i++) {
+	*         controller.enqueue({ index: i, data: `chunk ${i}` });
+	*         await new Promise(r => setTimeout(r, 100));
+	*       }
+	*       controller.close();
+	*     }
+	*   });
+	* });
+	* ```
+	*/
+	registerStream(name, handler, options) {
+		this.methods.set(name, {
+			handler,
+			validate: options?.validate,
+			description: options?.description,
+			isStream: true
+		});
+	}
+	/**
+	* Unregister a RPC method
+	*/
+	unregister(name) {
+		this.methods.delete(name);
+	}
+	/**
+	* Check if a method is registered
+	*/
+	has(name) {
+		return this.methods.has(name);
+	}
+	/**
+	* Get all registered method names
+	*/
+	getMethodNames() {
+		return Array.from(this.methods.keys());
+	}
+	/**
+	* Start listening for IPC messages
+	*/
+	listen() {
+		if (this.isListening) return;
+		this.ipcMain.on(RPC_CHANNEL, this.handleMessageBound);
+		this.ipcMain.on(STREAM_CHANNEL, this.handleStreamMessageBound);
+		this.ipcMain.on(EVENT_CHANNEL, this.handleEventBusMessageBound);
+		this.isListening = true;
+	}
+	/**
+	* Stop listening for IPC messages
+	*/
+	dispose() {
+		if (!this.isListening) return;
+		this.ipcMain.removeListener(RPC_CHANNEL, this.handleMessageBound);
+		this.ipcMain.removeListener(STREAM_CHANNEL, this.handleStreamMessageBound);
+		this.ipcMain.removeListener(EVENT_CHANNEL, this.handleEventBusMessageBound);
+		this.isListening = false;
+		this.methods.clear();
+		this.streams.clear();
+		this.eventSubscribers.clear();
+	}
+	/**
+	* Handle incoming IPC message
+	*/
+	async handleMessage(_event, request) {
+		const sender = _event.sender;
+		const response = await this.processRequest(request, sender);
+		if (request.id !== void 0 && request.id !== null) _event.reply?.(RPC_CHANNEL, response);
+	}
+	/**
+	* Handle stream-related messages from renderer
+	*/
+	handleStreamMessage(_event, chunk) {
+		const { streamId, type } = chunk;
+		if (type === "end" || type === "error") this.streams.delete(String(streamId));
+	}
+	/**
+	* Process a single request and return response
+	*/
+	async processRequest(request, sender) {
+		const { id, method, params } = request;
+		if (!method || typeof method !== "string") return {
+			jsonrpc: "2.0",
+			id: id ?? null,
+			error: errors.invalidRequest()
+		};
+		const storedMethod = this.methods.get(method);
+		if (!storedMethod) return {
+			jsonrpc: "2.0",
+			id: id ?? null,
+			error: errors.methodNotFound(method)
+		};
+		try {
+			let args;
+			if (params === void 0) args = [];
+			else if (Array.isArray(params)) args = params;
+			else args = [params];
+			if (storedMethod.validate) try {
+				await storedMethod.validate(args);
+			} catch (validationError) {
+				return {
+					jsonrpc: "2.0",
+					id: id ?? null,
+					error: errors.invalidParams(validationError instanceof Error ? validationError.message : void 0)
+				};
+			}
+			if (storedMethod.isStream) return this.handleStreamRequest(id, method, args, storedMethod, sender);
+			const result = await storedMethod.handler(...args);
+			return {
+				jsonrpc: "2.0",
+				id: id ?? null,
+				result
+			};
+		} catch (error) {
+			return {
+				jsonrpc: "2.0",
+				id: id ?? null,
+				error: errorToJsonRpc(error)
+			};
+		}
+	}
+	/**
+	* Handle a stream method request
+	* Returns stream ID and starts streaming in background
+	*/
+	async handleStreamRequest(id, _method, args, storedMethod, sender) {
+		const streamId = generateStreamId();
+		const sendChunk = sender ? (channel, data) => sender.send(channel, data) : (channel, data) => {
+			const allWindows = this.webContents.getAllWebContents();
+			for (const wc of allWindows) wc.send(channel, data);
+		};
+		this.streams.set(streamId, {
+			streamId,
+			sender: sendChunk
+		});
+		this.executeStreamHandler(streamId, storedMethod.handler, args, sendChunk).catch((error) => {
+			sendChunk(STREAM_CHANNEL, createStreamChunk(streamId, "error", errorToJsonRpc(error)));
+			this.streams.delete(streamId);
+		});
+		return {
+			jsonrpc: "2.0",
+			id: id ?? null,
+			result: { streamId }
+		};
+	}
+	/**
+	* Execute a stream handler and send chunks to renderer
+	*/
+	async executeStreamHandler(streamId, handler, args, sendChunk) {
+		const result = await handler(...args);
+		if (result instanceof ReadableStream) {
+			const reader = result.getReader();
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					sendChunk(STREAM_CHANNEL, createStreamChunk(streamId, "chunk", value));
+				}
+				sendChunk(STREAM_CHANNEL, createStreamChunk(streamId, "end"));
+			} catch (error) {
+				sendChunk(STREAM_CHANNEL, createStreamChunk(streamId, "error", errorToJsonRpc(error)));
+			} finally {
+				reader.releaseLock();
+				this.streams.delete(streamId);
+			}
+		} else {
+			sendChunk(STREAM_CHANNEL, createStreamChunk(streamId, "chunk", result));
+			sendChunk(STREAM_CHANNEL, createStreamChunk(streamId, "end"));
+			this.streams.delete(streamId);
+		}
+	}
+	/**
+	* Handle event bus messages (subscribe/unsubscribe)
+	*/
+	handleEventBusMessage(_event, message) {
+		const { type, eventName } = message;
+		const sender = _event.sender;
+		if (!sender) return;
+		const windowId = sender.id;
+		switch (type) {
+			case "subscribe":
+				this.subscribeToEvent(eventName, windowId);
+				break;
+			case "unsubscribe":
+				this.unsubscribeFromEvent(eventName, windowId);
+				break;
+		}
+	}
+	/**
+	* Subscribe a window to an event
+	*/
+	subscribeToEvent(eventName, windowId) {
+		if (!this.eventSubscribers.has(eventName)) this.eventSubscribers.set(eventName, /* @__PURE__ */ new Set());
+		this.eventSubscribers.get(eventName).add(windowId);
+	}
+	/**
+	* Unsubscribe a window from an event
+	*/
+	unsubscribeFromEvent(eventName, windowId) {
+		const subscribers = this.eventSubscribers.get(eventName);
+		if (subscribers) {
+			subscribers.delete(windowId);
+			if (subscribers.size === 0) this.eventSubscribers.delete(eventName);
+		}
+	}
+	/**
+	* Publish an event to all subscribed windows
+	* @param eventName - The name of the event to publish
+	* @param data - Optional data to send with the event
+	*
+	* @example
+	* ```typescript
+	* rpc.publish('user-updated', { id: '123', name: 'John' });
+	* ```
+	*/
+	publish(eventName, data) {
+		const subscribers = this.eventSubscribers.get(eventName);
+		if (!subscribers || subscribers.size === 0) return;
+		const message = {
+			type: "event",
+			eventName,
+			data
+		};
+		const allWindows = this.webContents.getAllWebContents();
+		for (const wc of allWindows) if (subscribers.has(wc.id)) wc.send(EVENT_CHANNEL, message);
+	}
+	/**
+	* Get current event subscribers
+	* @returns Record mapping event names to subscriber counts
+	*
+	* @example
+	* ```typescript
+	* const subscribers = rpc.getEventSubscribers();
+	* console.log(subscribers); // { 'user-updated': 2, 'data-changed': 1 }
+	* ```
+	*/
+	getEventSubscribers() {
+		const result = {};
+		for (const [eventName, subscribers] of this.eventSubscribers.entries()) result[eventName] = subscribers.size;
+		return result;
+	}
+};
+/**
+* Create a new RPC server instance
+*/
+function createRpcServer() {
+	return new RpcServer();
+}
+
+//#endregion
+export { RpcServer, createRpcServer };
+//# sourceMappingURL=main.mjs.map

package/dist/main.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.mjs","names":[],"sources":["../src/main.ts"],"sourcesContent":["/**\n * JSON-RPC Server for Electron Main Process\n */\n\nimport type {\n  JsonRpcRequest,\n  JsonRpcResponse,\n  RpcHandler,\n  RpcMethodOptions,\n  RpcValidator,\n  StreamHandler,\n  StreamChunk,\n} from \"./types.js\";\nimport { errors, errorToJsonRpc } from \"./error.js\";\nimport { generateStreamId, createStreamChunk, STREAM_CHANNEL } from \"./stream.js\";\nimport { EVENT_CHANNEL, type EventMessage } from \"./event.js\";\n\n/**\n * Stored method with metadata\n */\ninterface StoredMethod {\n  handler: RpcHandler;\n  validate?: RpcValidator;\n  description?: string;\n  isStream?: boolean;\n}\n\n/**\n * Active stream state\n */\ninterface ActiveStream {\n  streamId: string;\n  sender: (channel: string, data: unknown) => void;\n}\n\n/**\n * IPC channel name for JSON-RPC communication\n */\nconst RPC_CHANNEL = \"json-rpc\";\n\nconst HEALTH_CHECK_METHOD = \"__rpc_health__\";\n\n/**\n * JSON-RPC Server for Electron Main Process\n *\n * @example\n * ```typescript\n * import { app, BrowserWindow } from 'electron';\n * import { RpcServer } from 'electron-json-rpc/main';\n *\n * const rpc = new RpcServer();\n *\n * rpc.register('add', (a: number, b: number) => a + b);\n * rpc.register('fetchData', async (url: string) => {\n *   const response = await fetch(url);\n *   return response.json();\n * });\n * ```\n */\nexport class RpcServer {\n  private readonly methods = new Map<string, StoredMethod>();\n  private readonly streams = new Map<string, ActiveStream>();\n  private readonly eventSubscribers = new Map<string, Set<number>>(); // eventName -> Set of window IDs\n  private readonly handleMessageBound: (event: unknown, request: JsonRpcRequest) => void;\n  private readonly handleStreamMessageBound: (event: unknown, chunk: StreamChunk) => void;\n  private readonly handleEventBusMessageBound: (event: unknown, message: EventMessage) => void;\n  private ipcMain: any;\n  private webContents: any;\n  private isListening = false;\n\n  constructor(\n    /**\n     * Electron instance (for dependency injection in testing)\n     * @internal\n     */\n    electron?: {\n      ipcMain: any;\n      webContents: any;\n    },\n  ) {\n    // Electron is a peer dependency, we'll get it at runtime\n    // Or use provided instance (for testing)\n    try {\n      const e =\n        electron ||\n        (() => {\n          // eslint-disable-next-line @typescript-eslint/no-require-imports\n          return require(\"electron\");\n        })();\n      this.ipcMain = e.ipcMain;\n      this.webContents = e.webContents;\n    } catch {\n      throw new Error(\"Electron not found. Please install electron as a peer dependency.\");\n    }\n\n    this.handleMessageBound = this.handleMessage.bind(this);\n    this.handleStreamMessageBound = this.handleStreamMessage.bind(this);\n    this.handleEventBusMessageBound = this.handleEventBusMessage.bind(this);\n\n    if (!this.methods.has(HEALTH_CHECK_METHOD)) {\n      this.register(HEALTH_CHECK_METHOD, () => true);\n    }\n  }\n\n  /**\n   * Register a RPC method\n   * @param name - Method name\n   * @param handler - Handler function\n   * @param options - Optional validation and metadata\n   */\n  register(name: string, handler: RpcHandler, options?: RpcMethodOptions): void {\n    this.methods.set(name, {\n      handler,\n      validate: options?.validate,\n      description: options?.description,\n    });\n  }\n\n  /**\n   * Register a stream method that returns a ReadableStream\n   * @param name - Method name\n   * @param handler - Handler function that returns a ReadableStream\n   * @param options - Optional validation and metadata\n   *\n   * @example\n   * ```typescript\n   * rpc.registerStream('dataStream', (count: number) => {\n   *   return new ReadableStream({\n   *     async start(controller) {\n   *       for (let i = 0; i < count; i++) {\n   *         controller.enqueue({ index: i, data: `chunk ${i}` });\n   *         await new Promise(r => setTimeout(r, 100));\n   *       }\n   *       controller.close();\n   *     }\n   *   });\n   * });\n   * ```\n   */\n  registerStream(name: string, handler: StreamHandler, options?: RpcMethodOptions): void {\n    this.methods.set(name, {\n      handler: handler as RpcHandler,\n      validate: options?.validate,\n      description: options?.description,\n      isStream: true,\n    });\n  }\n\n  /**\n   * Unregister a RPC method\n   */\n  unregister(name: string): void {\n    this.methods.delete(name);\n  }\n\n  /**\n   * Check if a method is registered\n   */\n  has(name: string): boolean {\n    return this.methods.has(name);\n  }\n\n  /**\n   * Get all registered method names\n   */\n  getMethodNames(): string[] {\n    return Array.from(this.methods.keys());\n  }\n\n  /**\n   * Start listening for IPC messages\n   */\n  listen(): void {\n    if (this.isListening) {\n      return;\n    }\n\n    this.ipcMain.on(RPC_CHANNEL, this.handleMessageBound);\n    this.ipcMain.on(STREAM_CHANNEL, this.handleStreamMessageBound);\n    this.ipcMain.on(EVENT_CHANNEL, this.handleEventBusMessageBound);\n    this.isListening = true;\n  }\n\n  /**\n   * Stop listening for IPC messages\n   */\n  dispose(): void {\n    if (!this.isListening) {\n      return;\n    }\n\n    this.ipcMain.removeListener(RPC_CHANNEL, this.handleMessageBound);\n    this.ipcMain.removeListener(STREAM_CHANNEL, this.handleStreamMessageBound);\n    this.ipcMain.removeListener(EVENT_CHANNEL, this.handleEventBusMessageBound);\n    this.isListening = false;\n    this.methods.clear();\n    this.streams.clear();\n    this.eventSubscribers.clear();\n  }\n\n  /**\n   * Handle incoming IPC message\n   */\n  private async handleMessage(_event: unknown, request: JsonRpcRequest): Promise<void> {\n    const sender = (_event as { sender?: { send: (channel: string, data: unknown) => void } })\n      .sender;\n\n    const response = await this.processRequest(request, sender);\n\n    // Only send response for non-notifications (requests with id)\n    if (request.id !== undefined && request.id !== null) {\n      // Send response via the same event's reply method\n      const event = _event as {\n        reply?: (channel: string, data: unknown) => void;\n      };\n      event.reply?.(RPC_CHANNEL, response);\n    }\n  }\n\n  /**\n   * Handle stream-related messages from renderer\n   */\n  private handleStreamMessage(_event: unknown, chunk: StreamChunk): void {\n    const { streamId, type } = chunk;\n\n    if (type === \"end\" || type === \"error\") {\n      // Clean up stream state\n      this.streams.delete(String(streamId));\n    }\n  }\n\n  /**\n   * Process a single request and return response\n   */\n  private async processRequest(\n    request: JsonRpcRequest,\n    sender?: { send: (channel: string, data: unknown) => void },\n  ): Promise<JsonRpcResponse> {\n    const { id, method, params } = request;\n\n    // Validate request\n    if (!method || typeof method !== \"string\") {\n      return {\n        jsonrpc: \"2.0\",\n        id: id ?? null,\n        error: errors.invalidRequest(),\n      };\n    }\n\n    // Check if method exists\n    const storedMethod = this.methods.get(method);\n    if (!storedMethod) {\n      return {\n        jsonrpc: \"2.0\",\n        id: id ?? null,\n        error: errors.methodNotFound(method),\n      };\n    }\n\n    try {\n      // Normalize params to array\n      let args: unknown[];\n      if (params === undefined) {\n        args = [];\n      } else if (Array.isArray(params)) {\n        args = params;\n      } else {\n        // Named params - pass as single object\n        args = [params];\n      }\n\n      // Run validator if provided\n      if (storedMethod.validate) {\n        try {\n          await storedMethod.validate(args);\n        } catch (validationError) {\n          return {\n            jsonrpc: \"2.0\",\n            id: id ?? null,\n            error: errors.invalidParams(\n              validationError instanceof Error ? validationError.message : undefined,\n            ),\n          };\n        }\n      }\n\n      // Handle stream methods\n      if (storedMethod.isStream) {\n        return this.handleStreamRequest(id, method, args, storedMethod, sender);\n      }\n\n      // Execute regular handler\n      const result = await storedMethod.handler(...args);\n\n      return {\n        jsonrpc: \"2.0\",\n        id: id ?? null,\n        result,\n      };\n    } catch (error) {\n      return {\n        jsonrpc: \"2.0\",\n        id: id ?? null,\n        error: errorToJsonRpc(error),\n      };\n    }\n  }\n\n  /**\n   * Handle a stream method request\n   * Returns stream ID and starts streaming in background\n   */\n  private async handleStreamRequest(\n    id: string | number | null | undefined,\n    _method: string,\n    args: unknown[],\n    storedMethod: StoredMethod,\n    sender?: { send: (channel: string, data: unknown) => void },\n  ): Promise<JsonRpcResponse> {\n    const streamId = generateStreamId();\n\n    // Prefer responding to the requesting sender; fallback to all windows\n    const sendChunk = sender\n      ? (channel: string, data: unknown) => sender.send(channel, data)\n      : (channel: string, data: unknown) => {\n          const allWindows = this.webContents.getAllWebContents();\n          for (const wc of allWindows) {\n            wc.send(channel, data);\n          }\n        };\n\n    this.streams.set(streamId, { streamId, sender: sendChunk });\n\n    // Start streaming in background\n    this.executeStreamHandler(streamId, storedMethod.handler, args, sendChunk).catch((error) => {\n      const errorChunk = createStreamChunk(streamId, \"error\", errorToJsonRpc(error));\n      sendChunk(STREAM_CHANNEL, errorChunk);\n      this.streams.delete(streamId);\n    });\n\n    // Return stream ID immediately\n    return {\n      jsonrpc: \"2.0\",\n      id: id ?? null,\n      result: { streamId },\n    };\n  }\n\n  /**\n   * Execute a stream handler and send chunks to renderer\n   */\n  private async executeStreamHandler(\n    streamId: string,\n    handler: RpcHandler,\n    args: unknown[],\n    sendChunk: (channel: string, data: unknown) => void,\n  ): Promise<void> {\n    const result = await handler(...args);\n\n    if (result instanceof ReadableStream) {\n      const reader = result.getReader();\n\n      try {\n        while (true) {\n          const { done, value } = await reader.read();\n          if (done) break;\n\n          const chunk = createStreamChunk(streamId, \"chunk\", value);\n          sendChunk(STREAM_CHANNEL, chunk);\n        }\n\n        // Send end chunk\n        const endChunk = createStreamChunk(streamId, \"end\");\n        sendChunk(STREAM_CHANNEL, endChunk);\n      } catch (error) {\n        const errorChunk = createStreamChunk(streamId, \"error\", errorToJsonRpc(error));\n        sendChunk(STREAM_CHANNEL, errorChunk);\n      } finally {\n        reader.releaseLock();\n        this.streams.delete(streamId);\n      }\n    } else {\n      // Non-stream result, send as single chunk and end\n      const chunk = createStreamChunk(streamId, \"chunk\", result);\n      sendChunk(STREAM_CHANNEL, chunk);\n\n      const endChunk = createStreamChunk(streamId, \"end\");\n      sendChunk(STREAM_CHANNEL, endChunk);\n\n      this.streams.delete(streamId);\n    }\n  }\n\n  /**\n   * Handle event bus messages (subscribe/unsubscribe)\n   */\n  private handleEventBusMessage(_event: unknown, message: EventMessage): void {\n    const { type, eventName } = message;\n    const sender = (_event as { sender?: { id: number } }).sender;\n\n    if (!sender) {\n      return;\n    }\n\n    const windowId = sender.id;\n\n    switch (type) {\n      case \"subscribe\":\n        this.subscribeToEvent(eventName, windowId);\n        break;\n      case \"unsubscribe\":\n        this.unsubscribeFromEvent(eventName, windowId);\n        break;\n    }\n  }\n\n  /**\n   * Subscribe a window to an event\n   */\n  private subscribeToEvent(eventName: string, windowId: number): void {\n    if (!this.eventSubscribers.has(eventName)) {\n      this.eventSubscribers.set(eventName, new Set());\n    }\n    this.eventSubscribers.get(eventName)!.add(windowId);\n  }\n\n  /**\n   * Unsubscribe a window from an event\n   */\n  private unsubscribeFromEvent(eventName: string, windowId: number): void {\n    const subscribers = this.eventSubscribers.get(eventName);\n    if (subscribers) {\n      subscribers.delete(windowId);\n      if (subscribers.size === 0) {\n        this.eventSubscribers.delete(eventName);\n      }\n    }\n  }\n\n  /**\n   * Publish an event to all subscribed windows\n   * @param eventName - The name of the event to publish\n   * @param data - Optional data to send with the event\n   *\n   * @example\n   * ```typescript\n   * rpc.publish('user-updated', { id: '123', name: 'John' });\n   * ```\n   */\n  publish(eventName: string, data?: unknown): void {\n    const subscribers = this.eventSubscribers.get(eventName);\n    if (!subscribers || subscribers.size === 0) {\n      return; // No subscribers, nothing to do\n    }\n\n    const message: EventMessage = {\n      type: \"event\",\n      eventName,\n      data,\n    };\n\n    // Send to all subscribed windows\n    const allWindows = this.webContents.getAllWebContents();\n    for (const wc of allWindows) {\n      if (subscribers.has(wc.id)) {\n        wc.send(EVENT_CHANNEL, message);\n      }\n    }\n  }\n\n  /**\n   * Get current event subscribers\n   * @returns Record mapping event names to subscriber counts\n   *\n   * @example\n   * ```typescript\n   * const subscribers = rpc.getEventSubscribers();\n   * console.log(subscribers); // { 'user-updated': 2, 'data-changed': 1 }\n   * ```\n   */\n  getEventSubscribers(): Record<string, number> {\n    const result: Record<string, number> = {};\n    for (const [eventName, subscribers] of this.eventSubscribers.entries()) {\n      result[eventName] = subscribers.size;\n    }\n    return result;\n  }\n}\n\n/**\n * Create a new RPC server instance\n */\nexport function createRpcServer(): RpcServer {\n  return new RpcServer();\n}\n"],"mappings":"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"}

package/dist/preload.d.mts

@@ -0,0 +1,23 @@
+import { a as ExposeRpcApiOptions } from "./types-BnGse9DF.mjs";
+
+//#region src/preload.d.ts
+/**
+ * Expose an RPC API to the renderer process via contextBridge
+ */
+declare function exposeRpcApi(options: ExposeRpcApiOptions): void;
+/**
+ * Create an RPC client for use in preload scripts
+ * (without exposing to renderer)
+ */
+declare function createPreloadClient(ipcRenderer: ExposeRpcApiOptions["ipcRenderer"], timeout?: number): {
+  call: (method: string, ...params: unknown[]) => Promise<unknown>;
+  notify: (method: string, ...params: unknown[]) => void;
+  stream: (method: string, ...params: unknown[]) => ReadableStream;
+  on: (eventName: string, callback: (data?: unknown) => void) => () => void;
+  off: (eventName: string, callback?: (data?: unknown) => void) => void;
+  once: (eventName: string, callback: (data?: unknown) => void) => void;
+  dispose: () => void;
+};
+//#endregion
+export { createPreloadClient, exposeRpcApi };
+//# sourceMappingURL=preload.d.mts.map

package/dist/preload.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.d.mts","names":[],"sources":["../src/preload.ts"],"mappings":";;;;AAkXA;AAoBA;iBApBgB,YAAA,CAAA,OAAA,EAAsB,mBAAA;AAAA;AAoBtC;;;AApBsC,iBAoBtB,mBAAA,CAAA,WAAA,EACD,mBAAA,iBAAA,OAAA;EAAA,IAAA,GAAA,MAAA,aAAA,MAAA,gBAGmC,OAAA;EAAA,MAAA,GAAA,MAAA,aAAA,MAAA;EAAA,MAAA,GAAA,MAAA,aAAA,MAAA,gBAEE,cAAA;EAAA,EAAA,GAAA,SAAA,UAAA,QAAA,GAAA,IAAA;EAAA,GAAA,GAAA,SAAA,UAAA,QAAA,IAAA,IAAA;EAAA,IAAA,GAAA,SAAA,UAAA,QAAA,GAAA,IAAA;EAAA,OAAA;AAAA"}