electron-json-rpc 1.0.0

package/dist/renderer/client.d.mts

@@ -0,0 +1,42 @@
+import { d as RpcClientOptions, f as RpcDebugOptions, u as RpcApi } from "../types-BnGse9DF.mjs";
+
+//#region src/renderer/client.d.ts
+/**
+ * Create an untyped RPC client
+ *
+ * @param options - Client options
+ * @returns RPC client with call/notify/stream methods
+ */
+declare function createRpcClient(options?: RpcClientOptions & RpcDebugOptions): {
+  call: <T = unknown>(method: string, ...params: unknown[]) => Promise<T>;
+  notify: (method: string, ...params: unknown[]) => void;
+  stream: (method: string, ...params: unknown[]) => ReadableStream;
+};
+/**
+ * Create a typed RPC client with full type safety
+ *
+ * @param options - Client options
+ * @returns Typed proxy client
+ */
+declare function createTypedRpcClient<T extends Record<string, (...args: any[]) => any>>(options?: RpcClientOptions & RpcDebugOptions): RpcApi<T>;
+/**
+ * Create a RPC client using the preload proxy method
+ * This allows the preload script to expose a typed proxy
+ *
+ * @param options - Client options
+ * @returns RPC client or proxy
+ */
+declare function useRpcProxy(options?: RpcClientOptions & RpcDebugOptions): Record<string, (...args: unknown[]) => Promise<unknown>>;
+/**
+ * Define a typed RPC API from an interface
+ *
+ * This is an alias for createTypedRpcClient with a more semantic name
+ * for defining API interfaces.
+ *
+ * @param options - Client options
+ * @returns Typed proxy client
+ */
+declare function defineRpcApi<T extends Record<string, (...args: any[]) => any>>(options?: RpcClientOptions & RpcDebugOptions): RpcApi<T>;
+//#endregion
+export { type RpcApi, type RpcClientOptions, createRpcClient, createTypedRpcClient, defineRpcApi, useRpcProxy };
+//# sourceMappingURL=client.d.mts.map

package/dist/renderer/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../../src/renderer/client.ts"],"mappings":";;;;AAiBA;;;;;iBAAgB,eAAA,CAAA,OAAA,GAAyB,gBAAA,GAAmB,eAAA;EAAA,IAAA,gBAAA,MAAA,aAAA,MAAA,gBACG,OAAA,CAAQ,CAAA;EAAA,MAAA,GAAA,MAAA,aAAA,MAAA;EAAA,MAAA,GAAA,MAAA,aAAA,MAAA,gBAEnB,cAAA;AAAA;AAAA;;AA+DpD;;;;AA/DoD,iBA+DpC,oBAAA,WAA+B,MAAA,aAAA,IAAA,iBAAA,CAAA,OAAA,GACpC,gBAAA,GAAmB,eAAA,GAC3B,MAAA,CAAO,CAAA;AAAA;;;AAuDV;;;;AAvDU,iBAuDM,WAAA,CAAA,OAAA,GACL,gBAAA,GAAmB,eAAA,GAC3B,MAAA,aAAA,IAAA,gBAAuC,OAAA;AAAA;;;AAqD1C;;;;;;AArD0C,iBAqD1B,YAAA,WAAuB,MAAA,aAAA,IAAA,iBAAA,CAAA,OAAA,GAC5B,gBAAA,GAAmB,eAAA,GAC3B,MAAA,CAAO,CAAA"}

package/dist/renderer/client.mjs

@@ -0,0 +1,136 @@
+import { i as RpcTimeoutError } from "../error-xVRu7Lxq.mjs";
+import { getLogger } from "../debug.mjs";
+import { n as createTracker, r as getExposedApi, t as DEFAULT_API_NAME } from "../internal-BZK_0O3n.mjs";
+
+//#region src/renderer/client.ts
+/**
+* Create an untyped RPC client
+*
+* @param options - Client options
+* @returns RPC client with call/notify/stream methods
+*/
+function createRpcClient(options = {}) {
+	const { timeout = 3e4, apiName = DEFAULT_API_NAME, debug, logger } = options;
+	const api = getExposedApi(apiName);
+	if (!api) throw new Error(`RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`);
+	const debugTracker = createTracker(debug, logger ?? getLogger());
+	const requestIdCounter = { value: 0 };
+	return {
+		call: (method, ...params) => {
+			const requestId = ++requestIdCounter.value;
+			const startTime = performance.now();
+			debugTracker.onRequest(method, params, requestId);
+			return new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					const duration = Math.round(performance.now() - startTime);
+					debugTracker.onError(method, params, `Timeout after ${timeout}ms`, duration, requestId);
+					reject(new RpcTimeoutError(timeout));
+				}, timeout);
+				api.call(method, ...params).then((result) => {
+					clearTimeout(timeoutId);
+					const duration = Math.round(performance.now() - startTime);
+					debugTracker.onResponse(method, params, result, duration, requestId);
+					resolve(result);
+				}).catch((error) => {
+					clearTimeout(timeoutId);
+					const duration = Math.round(performance.now() - startTime);
+					debugTracker.onError(method, params, error.message, duration, requestId);
+					reject(error);
+				});
+			});
+		},
+		notify: (method, ...params) => {
+			debugTracker.onNotify(method, params);
+			api.notify(method, ...params);
+		},
+		stream: (method, ...params) => {
+			debugTracker.onStream(method, params);
+			return api.stream(method, ...params);
+		}
+	};
+}
+/**
+* Create a typed RPC client with full type safety
+*
+* @param options - Client options
+* @returns Typed proxy client
+*/
+function createTypedRpcClient(options = {}) {
+	const { timeout = 3e4, apiName = DEFAULT_API_NAME, debug, logger } = options;
+	const api = getExposedApi(apiName);
+	if (!api) throw new Error(`RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`);
+	const debugTracker = createTracker(debug, logger ?? getLogger());
+	const requestIdCounter = { value: 0 };
+	return new Proxy({}, { get(_target, prop) {
+		return (...args) => {
+			const requestId = ++requestIdCounter.value;
+			const startTime = performance.now();
+			debugTracker.onRequest(prop, args, requestId);
+			return new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					const duration = Math.round(performance.now() - startTime);
+					debugTracker.onError(prop, args, `Timeout after ${timeout}ms`, duration, requestId);
+					reject(new RpcTimeoutError(timeout));
+				}, timeout);
+				api.call(prop, ...args).then((result) => {
+					clearTimeout(timeoutId);
+					const duration = Math.round(performance.now() - startTime);
+					debugTracker.onResponse(prop, args, result, duration, requestId);
+					resolve(result);
+				}).catch((error) => {
+					clearTimeout(timeoutId);
+					const duration = Math.round(performance.now() - startTime);
+					debugTracker.onError(prop, args, error.message, duration, requestId);
+					reject(error);
+				});
+			});
+		};
+	} });
+}
+/**
+* Create a RPC client using the preload proxy method
+* This allows the preload script to expose a typed proxy
+*
+* @param options - Client options
+* @returns RPC client or proxy
+*/
+function useRpcProxy(options = {}) {
+	const { apiName = DEFAULT_API_NAME, debug, logger } = options;
+	const api = getExposedApi(apiName);
+	if (!api) throw new Error(`RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`);
+	if (typeof api.proxy === "function") return api.proxy();
+	const debugTracker = createTracker(debug, logger ?? getLogger());
+	const requestIdCounter = { value: 0 };
+	return new Proxy({}, { get(_target, prop) {
+		return (...args) => {
+			const requestId = ++requestIdCounter.value;
+			const startTime = performance.now();
+			debugTracker.onRequest(prop, args, requestId);
+			return api.call(prop, ...args).then((result) => {
+				const duration = Math.round(performance.now() - startTime);
+				debugTracker.onResponse(prop, args, result, duration, requestId);
+				return result;
+			}).catch((error) => {
+				const duration = Math.round(performance.now() - startTime);
+				debugTracker.onError(prop, args, error.message, duration, requestId);
+				throw error;
+			});
+		};
+	} });
+}
+/**
+* Define a typed RPC API from an interface
+*
+* This is an alias for createTypedRpcClient with a more semantic name
+* for defining API interfaces.
+*
+* @param options - Client options
+* @returns Typed proxy client
+*/
+function defineRpcApi(options = {}) {
+	return createTypedRpcClient(options);
+}
+
+//#endregion
+export { createRpcClient, createTypedRpcClient, defineRpcApi, useRpcProxy };
+//# sourceMappingURL=client.mjs.map

package/dist/renderer/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../src/renderer/client.ts"],"sourcesContent":["/**\n * JSON-RPC Client for Electron Renderer Process\n *\n * Basic client functionality: createRpcClient, createTypedRpcClient, useRpcProxy, defineRpcApi\n */\n\nimport type { RpcApi, RpcClientOptions, RpcDebugOptions } from \"../types.js\";\nimport { RpcTimeoutError } from \"../error.js\";\nimport { getLogger } from \"../debug.js\";\nimport { DEFAULT_API_NAME, getExposedApi, createTracker } from \"./internal.js\";\n\n/**\n * Create an untyped RPC client\n *\n * @param options - Client options\n * @returns RPC client with call/notify/stream methods\n */\nexport function createRpcClient(options: RpcClientOptions & RpcDebugOptions = {}): {\n  call: <T = unknown>(method: string, ...params: unknown[]) => Promise<T>;\n  notify: (method: string, ...params: unknown[]) => void;\n  stream: (method: string, ...params: unknown[]) => ReadableStream;\n} {\n  const { timeout = 30000, apiName = DEFAULT_API_NAME, debug, logger } = options;\n  const api = getExposedApi(apiName);\n\n  if (!api) {\n    throw new Error(\n      `RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`,\n    );\n  }\n\n  const debugTracker = createTracker(debug, logger ?? getLogger());\n  const requestIdCounter = { value: 0 };\n\n  return {\n    call: <T = unknown>(method: string, ...params: unknown[]): Promise<T> => {\n      const requestId = ++requestIdCounter.value;\n      const startTime = performance.now();\n\n      debugTracker.onRequest(method, params, requestId);\n\n      return new Promise((resolve, reject) => {\n        const timeoutId = setTimeout(() => {\n          const duration = Math.round(performance.now() - startTime);\n          debugTracker.onError(method, params, `Timeout after ${timeout}ms`, duration, requestId);\n          reject(new RpcTimeoutError(timeout));\n        }, timeout);\n\n        api\n          .call(method, ...params)\n          .then((result: unknown) => {\n            clearTimeout(timeoutId);\n            const duration = Math.round(performance.now() - startTime);\n            debugTracker.onResponse(method, params, result, duration, requestId);\n            resolve(result as T);\n          })\n          .catch((error: Error) => {\n            clearTimeout(timeoutId);\n            const duration = Math.round(performance.now() - startTime);\n            debugTracker.onError(method, params, error.message, duration, requestId);\n            reject(error);\n          });\n      });\n    },\n\n    notify: (method: string, ...params: unknown[]): void => {\n      debugTracker.onNotify(method, params);\n      api.notify(method, ...params);\n    },\n\n    stream: (method: string, ...params: unknown[]): ReadableStream => {\n      debugTracker.onStream(method, params);\n      return api.stream(method, ...params);\n    },\n  };\n}\n\n/**\n * Create a typed RPC client with full type safety\n *\n * @param options - Client options\n * @returns Typed proxy client\n */\nexport function createTypedRpcClient<T extends Record<string, (...args: any[]) => any>>(\n  options: RpcClientOptions & RpcDebugOptions = {},\n): RpcApi<T> {\n  const { timeout = 30000, apiName = DEFAULT_API_NAME, debug, logger } = options;\n  const api = getExposedApi(apiName);\n\n  if (!api) {\n    throw new Error(\n      `RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`,\n    );\n  }\n\n  const debugTracker = createTracker(debug, logger ?? getLogger());\n  const requestIdCounter = { value: 0 };\n\n  return new Proxy({} as RpcApi<T>, {\n    get(_target, prop: string) {\n      return (...args: unknown[]) => {\n        const requestId = ++requestIdCounter.value;\n        const startTime = performance.now();\n\n        debugTracker.onRequest(prop, args, requestId);\n\n        return new Promise((resolve, reject) => {\n          const timeoutId = setTimeout(() => {\n            const duration = Math.round(performance.now() - startTime);\n            debugTracker.onError(prop, args, `Timeout after ${timeout}ms`, duration, requestId);\n            reject(new RpcTimeoutError(timeout));\n          }, timeout);\n\n          api\n            .call(prop, ...args)\n            .then((result: unknown) => {\n              clearTimeout(timeoutId);\n              const duration = Math.round(performance.now() - startTime);\n              debugTracker.onResponse(prop, args, result, duration, requestId);\n              resolve(result as any);\n            })\n            .catch((error: Error) => {\n              clearTimeout(timeoutId);\n              const duration = Math.round(performance.now() - startTime);\n              debugTracker.onError(prop, args, error.message, duration, requestId);\n              reject(error);\n            });\n        });\n      };\n    },\n  });\n}\n\n/**\n * Create a RPC client using the preload proxy method\n * This allows the preload script to expose a typed proxy\n *\n * @param options - Client options\n * @returns RPC client or proxy\n */\nexport function useRpcProxy(\n  options: RpcClientOptions & RpcDebugOptions = {},\n): Record<string, (...args: unknown[]) => Promise<unknown>> {\n  const { apiName = DEFAULT_API_NAME, debug, logger } = options;\n  const api = getExposedApi(apiName);\n\n  if (!api) {\n    throw new Error(\n      `RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`,\n    );\n  }\n\n  // If preload exposed a proxy method, use it\n  if (typeof api.proxy === \"function\") {\n    return api.proxy();\n  }\n\n  const debugTracker = createTracker(debug, logger ?? getLogger());\n  const requestIdCounter = { value: 0 };\n\n  // Otherwise, return a generic proxy\n  return new Proxy({} as Record<string, (...args: unknown[]) => Promise<unknown>>, {\n    get(_target, prop: string) {\n      return (...args: unknown[]) => {\n        const requestId = ++requestIdCounter.value;\n        const startTime = performance.now();\n\n        debugTracker.onRequest(prop, args, requestId);\n\n        return api\n          .call(prop, ...args)\n          .then((result: unknown) => {\n            const duration = Math.round(performance.now() - startTime);\n            debugTracker.onResponse(prop, args, result, duration, requestId);\n            return result;\n          })\n          .catch((error: Error) => {\n            const duration = Math.round(performance.now() - startTime);\n            debugTracker.onError(prop, args, error.message, duration, requestId);\n            throw error;\n          });\n      };\n    },\n  });\n}\n\n/**\n * Define a typed RPC API from an interface\n *\n * This is an alias for createTypedRpcClient with a more semantic name\n * for defining API interfaces.\n *\n * @param options - Client options\n * @returns Typed proxy client\n */\nexport function defineRpcApi<T extends Record<string, (...args: any[]) => any>>(\n  options: RpcClientOptions & RpcDebugOptions = {},\n): RpcApi<T> {\n  return createTypedRpcClient<T>(options);\n}\n\n/**\n * Re-export types for convenience\n */\nexport type { RpcApi, RpcClientOptions } from \"../types.js\";\n"],"mappings":";;;;;;;;;;;AAiBA,SAAgB,gBAAgB,UAA8C,EAAE,EAI9E;CACA,MAAM,EAAE,UAAU,KAAO,UAAU,kBAAkB,OAAO,WAAW;CACvE,MAAM,MAAM,cAAc,QAAQ;AAElC,KAAI,CAAC,IACH,OAAM,IAAI,MACR,8FAA8F,QAAQ,IACvG;CAGH,MAAM,eAAe,cAAc,OAAO,UAAU,WAAW,CAAC;CAChE,MAAM,mBAAmB,EAAE,OAAO,GAAG;AAErC,QAAO;EACL,OAAoB,QAAgB,GAAG,WAAkC;GACvE,MAAM,YAAY,EAAE,iBAAiB;GACrC,MAAM,YAAY,YAAY,KAAK;AAEnC,gBAAa,UAAU,QAAQ,QAAQ,UAAU;AAEjD,UAAO,IAAI,SAAS,SAAS,WAAW;IACtC,MAAM,YAAY,iBAAiB;KACjC,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,kBAAa,QAAQ,QAAQ,QAAQ,iBAAiB,QAAQ,KAAK,UAAU,UAAU;AACvF,YAAO,IAAI,gBAAgB,QAAQ,CAAC;OACnC,QAAQ;AAEX,QACG,KAAK,QAAQ,GAAG,OAAO,CACvB,MAAM,WAAoB;AACzB,kBAAa,UAAU;KACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,kBAAa,WAAW,QAAQ,QAAQ,QAAQ,UAAU,UAAU;AACpE,aAAQ,OAAY;MACpB,CACD,OAAO,UAAiB;AACvB,kBAAa,UAAU;KACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,kBAAa,QAAQ,QAAQ,QAAQ,MAAM,SAAS,UAAU,UAAU;AACxE,YAAO,MAAM;MACb;KACJ;;EAGJ,SAAS,QAAgB,GAAG,WAA4B;AACtD,gBAAa,SAAS,QAAQ,OAAO;AACrC,OAAI,OAAO,QAAQ,GAAG,OAAO;;EAG/B,SAAS,QAAgB,GAAG,WAAsC;AAChE,gBAAa,SAAS,QAAQ,OAAO;AACrC,UAAO,IAAI,OAAO,QAAQ,GAAG,OAAO;;EAEvC;;;;;;;;AASH,SAAgB,qBACd,UAA8C,EAAE,EACrC;CACX,MAAM,EAAE,UAAU,KAAO,UAAU,kBAAkB,OAAO,WAAW;CACvE,MAAM,MAAM,cAAc,QAAQ;AAElC,KAAI,CAAC,IACH,OAAM,IAAI,MACR,8FAA8F,QAAQ,IACvG;CAGH,MAAM,eAAe,cAAc,OAAO,UAAU,WAAW,CAAC;CAChE,MAAM,mBAAmB,EAAE,OAAO,GAAG;AAErC,QAAO,IAAI,MAAM,EAAE,EAAe,EAChC,IAAI,SAAS,MAAc;AACzB,UAAQ,GAAG,SAAoB;GAC7B,MAAM,YAAY,EAAE,iBAAiB;GACrC,MAAM,YAAY,YAAY,KAAK;AAEnC,gBAAa,UAAU,MAAM,MAAM,UAAU;AAE7C,UAAO,IAAI,SAAS,SAAS,WAAW;IACtC,MAAM,YAAY,iBAAiB;KACjC,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,kBAAa,QAAQ,MAAM,MAAM,iBAAiB,QAAQ,KAAK,UAAU,UAAU;AACnF,YAAO,IAAI,gBAAgB,QAAQ,CAAC;OACnC,QAAQ;AAEX,QACG,KAAK,MAAM,GAAG,KAAK,CACnB,MAAM,WAAoB;AACzB,kBAAa,UAAU;KACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,kBAAa,WAAW,MAAM,MAAM,QAAQ,UAAU,UAAU;AAChE,aAAQ,OAAc;MACtB,CACD,OAAO,UAAiB;AACvB,kBAAa,UAAU;KACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,kBAAa,QAAQ,MAAM,MAAM,MAAM,SAAS,UAAU,UAAU;AACpE,YAAO,MAAM;MACb;KACJ;;IAGP,CAAC;;;;;;;;;AAUJ,SAAgB,YACd,UAA8C,EAAE,EACU;CAC1D,MAAM,EAAE,UAAU,kBAAkB,OAAO,WAAW;CACtD,MAAM,MAAM,cAAc,QAAQ;AAElC,KAAI,CAAC,IACH,OAAM,IAAI,MACR,8FAA8F,QAAQ,IACvG;AAIH,KAAI,OAAO,IAAI,UAAU,WACvB,QAAO,IAAI,OAAO;CAGpB,MAAM,eAAe,cAAc,OAAO,UAAU,WAAW,CAAC;CAChE,MAAM,mBAAmB,EAAE,OAAO,GAAG;AAGrC,QAAO,IAAI,MAAM,EAAE,EAA8D,EAC/E,IAAI,SAAS,MAAc;AACzB,UAAQ,GAAG,SAAoB;GAC7B,MAAM,YAAY,EAAE,iBAAiB;GACrC,MAAM,YAAY,YAAY,KAAK;AAEnC,gBAAa,UAAU,MAAM,MAAM,UAAU;AAE7C,UAAO,IACJ,KAAK,MAAM,GAAG,KAAK,CACnB,MAAM,WAAoB;IACzB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,iBAAa,WAAW,MAAM,MAAM,QAAQ,UAAU,UAAU;AAChE,WAAO;KACP,CACD,OAAO,UAAiB;IACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,iBAAa,QAAQ,MAAM,MAAM,MAAM,SAAS,UAAU,UAAU;AACpE,UAAM;KACN;;IAGT,CAAC;;;;;;;;;;;AAYJ,SAAgB,aACd,UAA8C,EAAE,EACrC;AACX,QAAO,qBAAwB,QAAQ"}

package/dist/renderer/event.d.mts

@@ -0,0 +1,17 @@
+import { f as RpcDebugOptions, r as EventHandler, t as EventBus } from "../types-BnGse9DF.mjs";
+
+//#region src/renderer/event.d.ts
+/**
+ * Create a typed event bus for renderer process
+ *
+ * Provides type-safe event subscription with full type inference.
+ *
+ * @param options - Client options
+ * @returns Typed event bus
+ */
+declare function createEventBus<T extends Record<string, unknown> = Record<string, unknown>>(options?: {
+  apiName?: string;
+} & RpcDebugOptions): EventBus<T>;
+//#endregion
+export { type EventBus, type EventHandler, createEventBus };
+//# sourceMappingURL=event.d.mts.map

package/dist/renderer/event.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.mts","names":[],"sources":["../../src/renderer/event.ts"],"mappings":";;;;AAkBA;;;;;;;iBAAgB,cAAA,WAAyB,MAAA,oBAA0B,MAAA,kBAAA,CAAA,OAAA;EAAA,OAAA;AAAA,IACjC,eAAA,GAC/B,QAAA,CAAS,CAAA"}

package/dist/renderer/event.mjs

@@ -0,0 +1,117 @@
+import { createDebugTracker, getLogger, isDebugEnabled } from "../debug.mjs";
+import { r as getExposedApi, t as DEFAULT_API_NAME } from "../internal-BZK_0O3n.mjs";
+
+//#region src/renderer/event.ts
+/**
+* Create a typed event bus for renderer process
+*
+* Provides type-safe event subscription with full type inference.
+*
+* @param options - Client options
+* @returns Typed event bus
+*/
+function createEventBus(options = {}) {
+	const { apiName = DEFAULT_API_NAME, debug, logger } = options;
+	const api = getExposedApi(apiName);
+	if (!api) throw new Error(`RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`);
+	if (typeof api.on !== "function") throw new Error("Event bus methods not available. Make sure you're using a version of electron-json-rpc/preload that supports events.");
+	const enabled = isDebugEnabled(debug);
+	const debugTracker = createDebugTracker(enabled, logger ?? getLogger());
+	const subscribedEvents = /* @__PURE__ */ new Set();
+	const handlerRegistry = /* @__PURE__ */ new Map();
+	const wrappedHandlers = /* @__PURE__ */ new Map();
+	const registerHandler = (eventName, handler) => {
+		let handlers = handlerRegistry.get(eventName);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			handlerRegistry.set(eventName, handlers);
+		}
+		handlers.add(handler);
+		subscribedEvents.add(eventName);
+	};
+	const unregisterHandler = (eventName, handler) => {
+		const handlers = handlerRegistry.get(eventName);
+		if (!handlers) return;
+		if (handler) {
+			handlers.delete(handler);
+			wrappedHandlers.get(eventName)?.delete(handler);
+		} else {
+			handlers.clear();
+			handlerRegistry.delete(eventName);
+			wrappedHandlers.delete(eventName);
+		}
+		if (handlers.size === 0) {
+			handlerRegistry.delete(eventName);
+			wrappedHandlers.delete(eventName);
+			subscribedEvents.delete(eventName);
+		}
+	};
+	const getWrappedHandler = (eventName, handler) => {
+		if (!enabled) return handler;
+		let eventHandlers = wrappedHandlers.get(eventName);
+		if (!eventHandlers) {
+			eventHandlers = /* @__PURE__ */ new Map();
+			wrappedHandlers.set(eventName, eventHandlers);
+		}
+		const existing = eventHandlers.get(handler);
+		if (existing) return existing;
+		const wrapped = (data) => {
+			debugTracker.onEvent(String(eventName), data);
+			return handler(data);
+		};
+		eventHandlers.set(handler, wrapped);
+		return wrapped;
+	};
+	return {
+		on: (eventName, callback) => {
+			const name = String(eventName);
+			const handler = callback;
+			const wrappedHandler = getWrappedHandler(name, handler);
+			registerHandler(name, handler);
+			const unsubscribe = api.on(name, wrappedHandler);
+			return () => {
+				unsubscribe();
+				unregisterHandler(name, handler);
+			};
+		},
+		off: (eventName, callback) => {
+			const name = String(eventName);
+			if (callback) {
+				const handler = callback;
+				const wrappedHandler = wrappedHandlers.get(name)?.get(handler) ?? handler;
+				api.off(name, wrappedHandler);
+				unregisterHandler(name, handler);
+			} else {
+				api.off(name);
+				unregisterHandler(name);
+			}
+		},
+		once: (eventName, callback) => {
+			const name = String(eventName);
+			const handler = callback;
+			registerHandler(name, handler);
+			const wrappedHandler = (data) => {
+				if (enabled) debugTracker.onEvent(name, data);
+				try {
+					handler(data);
+				} finally {
+					unregisterHandler(name, handler);
+				}
+			};
+			if (enabled) {
+				let eventHandlers = wrappedHandlers.get(name);
+				if (!eventHandlers) {
+					eventHandlers = /* @__PURE__ */ new Map();
+					wrappedHandlers.set(name, eventHandlers);
+				}
+				eventHandlers.set(handler, wrappedHandler);
+			}
+			api.once(name, wrappedHandler);
+		},
+		getSubscribedEvents: () => Array.from(subscribedEvents)
+	};
+}
+
+//#endregion
+export { createEventBus };
+//# sourceMappingURL=event.mjs.map

package/dist/renderer/event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.mjs","names":[],"sources":["../../src/renderer/event.ts"],"sourcesContent":["/**\n * Typed Event Bus for Electron Renderer Process\n *\n * Provides type-safe event subscription with full type inference.\n */\n\nimport type { EventBus, EventHandler, RpcDebugOptions } from \"../types.js\";\nimport { isDebugEnabled, getLogger, createDebugTracker } from \"../debug.js\";\nimport { DEFAULT_API_NAME, getExposedApi } from \"./internal.js\";\n\n/**\n * Create a typed event bus for renderer process\n *\n * Provides type-safe event subscription with full type inference.\n *\n * @param options - Client options\n * @returns Typed event bus\n */\nexport function createEventBus<T extends Record<string, unknown> = Record<string, unknown>>(\n  options: { apiName?: string } & RpcDebugOptions = {},\n): EventBus<T> {\n  const { apiName = DEFAULT_API_NAME, debug, logger } = options;\n  const api = getExposedApi(apiName);\n\n  if (!api) {\n    throw new Error(\n      `RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${apiName}'.`,\n    );\n  }\n\n  // Check if the API has event methods\n  if (typeof api.on !== \"function\") {\n    throw new Error(\n      \"Event bus methods not available. Make sure you're using a version of electron-json-rpc/preload that supports events.\",\n    );\n  }\n\n  const enabled = isDebugEnabled(debug);\n  const debugTracker = createDebugTracker(enabled, logger ?? getLogger());\n  const subscribedEvents = new Set<string>();\n  const handlerRegistry = new Map<string, Set<EventHandler<unknown>>>();\n  const wrappedHandlers = new Map<string, Map<EventHandler<unknown>, (data: unknown) => void>>();\n\n  const registerHandler = (eventName: string, handler: EventHandler<unknown>): void => {\n    let handlers = handlerRegistry.get(eventName);\n    if (!handlers) {\n      handlers = new Set();\n      handlerRegistry.set(eventName, handlers);\n    }\n    handlers.add(handler);\n    subscribedEvents.add(eventName);\n  };\n\n  const unregisterHandler = (eventName: string, handler?: EventHandler<unknown>): void => {\n    const handlers = handlerRegistry.get(eventName);\n    if (!handlers) {\n      return;\n    }\n\n    if (handler) {\n      handlers.delete(handler);\n      wrappedHandlers.get(eventName)?.delete(handler);\n    } else {\n      handlers.clear();\n      handlerRegistry.delete(eventName);\n      wrappedHandlers.delete(eventName);\n    }\n\n    if (handlers.size === 0) {\n      handlerRegistry.delete(eventName);\n      wrappedHandlers.delete(eventName);\n      subscribedEvents.delete(eventName);\n    }\n  };\n\n  const getWrappedHandler = (\n    eventName: string,\n    handler: EventHandler<unknown>,\n  ): ((data: unknown) => void) => {\n    if (!enabled) {\n      return handler as (data: unknown) => void;\n    }\n\n    let eventHandlers = wrappedHandlers.get(eventName);\n    if (!eventHandlers) {\n      eventHandlers = new Map();\n      wrappedHandlers.set(eventName, eventHandlers);\n    }\n\n    const existing = eventHandlers.get(handler);\n    if (existing) {\n      return existing;\n    }\n\n    const wrapped = (data: unknown) => {\n      debugTracker.onEvent(String(eventName), data);\n      return handler(data);\n    };\n\n    eventHandlers.set(handler, wrapped);\n    return wrapped;\n  };\n\n  return {\n    on: (eventName, callback) => {\n      const name = String(eventName);\n      const handler = callback as EventHandler<unknown>;\n      const wrappedHandler = getWrappedHandler(name, handler);\n\n      registerHandler(name, handler);\n\n      const unsubscribe = api.on!(name, wrappedHandler);\n      return () => {\n        unsubscribe();\n        unregisterHandler(name, handler);\n      };\n    },\n\n    off: (eventName, callback) => {\n      const name = String(eventName);\n\n      if (callback) {\n        const handler = callback as EventHandler<unknown>;\n        const wrappedHandler = wrappedHandlers.get(name)?.get(handler) ?? handler;\n        api.off!(name, wrappedHandler as (data?: unknown) => void);\n        unregisterHandler(name, handler);\n      } else {\n        api.off!(name);\n        unregisterHandler(name);\n      }\n    },\n\n    once: (eventName, callback) => {\n      const name = String(eventName);\n      const handler = callback as EventHandler<unknown>;\n\n      registerHandler(name, handler);\n\n      const wrappedHandler = (data: unknown) => {\n        if (enabled) {\n          debugTracker.onEvent(name, data);\n        }\n        try {\n          handler(data);\n        } finally {\n          unregisterHandler(name, handler);\n        }\n      };\n\n      if (enabled) {\n        let eventHandlers = wrappedHandlers.get(name);\n        if (!eventHandlers) {\n          eventHandlers = new Map();\n          wrappedHandlers.set(name, eventHandlers);\n        }\n        eventHandlers.set(handler, wrappedHandler);\n      }\n\n      api.once!(name, wrappedHandler);\n    },\n\n    getSubscribedEvents: () => Array.from(subscribedEvents),\n  };\n}\n\n/**\n * Re-export types for convenience\n */\nexport type { EventBus, EventHandler } from \"../types.js\";\n"],"mappings":"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"}

package/dist/renderer/index.d.mts

@@ -0,0 +1,6 @@
+import { d as RpcClientOptions, h as RpcLogger, m as RpcLogEntry, r as EventHandler, t as EventBus, u as RpcApi } from "../types-BnGse9DF.mjs";
+import { isRpcDebug, setRpcDebug, setRpcLogger } from "../debug.mjs";
+import { RpcBuilder, RpcBuilderMethods, RpcBuilderWithMethod, createRpc } from "./builder.mjs";
+import { createRpcClient, createTypedRpcClient, defineRpcApi, useRpcProxy } from "./client.mjs";
+import { createEventBus } from "./event.mjs";
+export { type EventBus, type EventHandler, type RpcApi, type RpcBuilder, type RpcBuilderMethods, type RpcBuilderWithMethod, type RpcClientOptions, type RpcLogEntry, type RpcLogger, createEventBus, createRpc, createRpcClient, createTypedRpcClient, defineRpcApi, isRpcDebug, setRpcDebug, setRpcLogger, useRpcProxy };

package/dist/renderer/index.mjs

@@ -0,0 +1,6 @@
+import { isRpcDebug, setRpcDebug, setRpcLogger } from "../debug.mjs";
+import { createRpcClient, createTypedRpcClient, defineRpcApi, useRpcProxy } from "./client.mjs";
+import { createRpc } from "./builder.mjs";
+import { createEventBus } from "./event.mjs";
+
+export { createEventBus, createRpc, createRpcClient, createTypedRpcClient, defineRpcApi, isRpcDebug, setRpcDebug, setRpcLogger, useRpcProxy };

package/dist/stream.d.mts

@@ -0,0 +1,38 @@
+//#region src/stream.d.ts
+/**
+ * Stream utilities for electron-json-rpc
+ *
+ * Shared constants and utilities for streaming support
+ */
+/**
+ * IPC channel name for stream chunks
+ */
+declare const STREAM_CHANNEL = "json-rpc-stream";
+declare function generateStreamId(): string;
+/**
+ * Create a stream chunk message
+ */
+declare function createStreamChunk(streamId: string | number, type: "chunk" | "end" | "error", data?: unknown): {
+  streamId: string | number;
+  type: "chunk" | "end" | "error";
+  data?: unknown;
+};
+/**
+ * Check if a value is a ReadableStream
+ */
+declare function isReadableStream(value: unknown): value is ReadableStream;
+/**
+ * Read entire stream into an array
+ */
+declare function readStream<T>(stream: ReadableStream<T>): Promise<T[]>;
+/**
+ * Convert async generator to ReadableStream
+ */
+declare function asyncGeneratorToStream<T>(generator: () => AsyncGenerator<T>): ReadableStream<T>;
+/**
+ * Convert array to ReadableStream
+ */
+declare function iterableToStream<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;
+//#endregion
+export { STREAM_CHANNEL, asyncGeneratorToStream, createStreamChunk, generateStreamId, isReadableStream, iterableToStream, readStream };
+//# sourceMappingURL=stream.d.mts.map

package/dist/stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","names":[],"sources":["../src/stream.ts"],"mappings":";;AASA;AAMA;AAOA;AAeA;;AA5BA;AAMA;cANa,cAAA;AAAA,iBAMG,gBAAA,CAAA;AAAA;AAOhB;AAeA;AAtBgB,iBAOA,iBAAA,CAAA,QAAA,mBAAA,IAAA,6BAAA,IAAA;EAAA,QAAA;EAAA,IAAA;EAAA,IAAA;AAAA;AAAA;AAehB;AAYA;AA3BgB,iBAeA,gBAAA,CAAA,KAAA,YAAA,KAAA,IAA2C,cAAA;AAAA;AAY3D;;AAZ2D,iBAYrC,UAAA,GAAA,CAAA,MAAA,EAAsB,cAAA,CAAe,CAAA,IAAK,OAAA,CAAQ,CAAA;AAAA;;;AAAA,iBAsBxD,sBAAA,GAAA,CAAA,SAAA,QAA2C,cAAA,CAAe,CAAA,IAAK,cAAA,CAAe,CAAA;AAAA;;;AAAA,iBAkB9E,gBAAA,GAAA,CAAA,QAAA,EAA8B,QAAA,CAAS,CAAA,IAAK,aAAA,CAAc,CAAA,IAAK,cAAA,CAAe,CAAA"}

package/dist/stream.mjs

@@ -0,0 +1,80 @@
+//#region src/stream.ts
+/**
+* Stream utilities for electron-json-rpc
+*
+* Shared constants and utilities for streaming support
+*/
+/**
+* IPC channel name for stream chunks
+*/
+const STREAM_CHANNEL = "json-rpc-stream";
+/**
+* Generate unique stream ID
+*/
+let streamIdCounter = 0;
+function generateStreamId() {
+	return `stream_${++streamIdCounter}_${Date.now()}`;
+}
+/**
+* Create a stream chunk message
+*/
+function createStreamChunk(streamId, type, data) {
+	return {
+		streamId,
+		type,
+		data
+	};
+}
+/**
+* Check if a value is a ReadableStream
+*/
+function isReadableStream(value) {
+	return typeof value === "object" && value !== null && "getReader" in value && typeof value.getReader === "function";
+}
+/**
+* Read entire stream into an array
+*/
+async function readStream(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value !== void 0) chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return chunks;
+}
+/**
+* Convert async generator to ReadableStream
+*/
+function asyncGeneratorToStream(generator) {
+	return new ReadableStream({ async start(controller) {
+		try {
+			for await (const value of generator()) controller.enqueue(value);
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+}
+/**
+* Convert array to ReadableStream
+*/
+function iterableToStream(iterable) {
+	return new ReadableStream({ async start(controller) {
+		try {
+			for await (const value of iterable) controller.enqueue(value);
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+}
+
+//#endregion
+export { STREAM_CHANNEL, asyncGeneratorToStream, createStreamChunk, generateStreamId, isReadableStream, iterableToStream, readStream };
+//# sourceMappingURL=stream.mjs.map

package/dist/stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.mjs","names":[],"sources":["../src/stream.ts"],"sourcesContent":["/**\n * Stream utilities for electron-json-rpc\n *\n * Shared constants and utilities for streaming support\n */\n\n/**\n * IPC channel name for stream chunks\n */\nexport const STREAM_CHANNEL = \"json-rpc-stream\";\n\n/**\n * Generate unique stream ID\n */\nlet streamIdCounter = 0;\nexport function generateStreamId(): string {\n  return `stream_${++streamIdCounter}_${Date.now()}`;\n}\n\n/**\n * Create a stream chunk message\n */\nexport function createStreamChunk(\n  streamId: string | number,\n  type: \"chunk\" | \"end\" | \"error\",\n  data?: unknown,\n): {\n  streamId: string | number;\n  type: \"chunk\" | \"end\" | \"error\";\n  data?: unknown;\n} {\n  return { streamId, type, data };\n}\n\n/**\n * Check if a value is a ReadableStream\n */\nexport function isReadableStream(value: unknown): value is ReadableStream {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"getReader\" in value &&\n    typeof (value as ReadableStream).getReader === \"function\"\n  );\n}\n\n/**\n * Read entire stream into an array\n */\nexport async function readStream<T>(stream: ReadableStream<T>): Promise<T[]> {\n  const reader = stream.getReader();\n  const chunks: T[] = [];\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      if (value !== undefined) {\n        chunks.push(value);\n      }\n    }\n  } finally {\n    reader.releaseLock();\n  }\n\n  return chunks;\n}\n\n/**\n * Convert async generator to ReadableStream\n */\nexport function asyncGeneratorToStream<T>(generator: () => AsyncGenerator<T>): ReadableStream<T> {\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const value of generator()) {\n          controller.enqueue(value);\n        }\n        controller.close();\n      } catch (error) {\n        controller.error(error);\n      }\n    },\n  });\n}\n\n/**\n * Convert array to ReadableStream\n */\nexport function iterableToStream<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T> {\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const value of iterable) {\n          controller.enqueue(value);\n        }\n        controller.close();\n      } catch (error) {\n        controller.error(error);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AASA,MAAa,iBAAiB;;;;AAK9B,IAAI,kBAAkB;AACtB,SAAgB,mBAA2B;AACzC,QAAO,UAAU,EAAE,gBAAgB,GAAG,KAAK,KAAK;;;;;AAMlD,SAAgB,kBACd,UACA,MACA,MAKA;AACA,QAAO;EAAE;EAAU;EAAM;EAAM;;;;;AAMjC,SAAgB,iBAAiB,OAAyC;AACxE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,eAAe,SACf,OAAQ,MAAyB,cAAc;;;;;AAOnD,eAAsB,WAAc,QAAyC;CAC3E,MAAM,SAAS,OAAO,WAAW;CACjC,MAAM,SAAc,EAAE;AAEtB,KAAI;AACF,SAAO,MAAM;GACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,OAAI,KAAM;AACV,OAAI,UAAU,OACZ,QAAO,KAAK,MAAM;;WAGd;AACR,SAAO,aAAa;;AAGtB,QAAO;;;;;AAMT,SAAgB,uBAA0B,WAAuD;AAC/F,QAAO,IAAI,eAAe,EACxB,MAAM,MAAM,YAAY;AACtB,MAAI;AACF,cAAW,MAAM,SAAS,WAAW,CACnC,YAAW,QAAQ,MAAM;AAE3B,cAAW,OAAO;WACX,OAAO;AACd,cAAW,MAAM,MAAM;;IAG5B,CAAC;;;;;AAMJ,SAAgB,iBAAoB,UAA6D;AAC/F,QAAO,IAAI,eAAe,EACxB,MAAM,MAAM,YAAY;AACtB,MAAI;AACF,cAAW,MAAM,SAAS,SACxB,YAAW,QAAQ,MAAM;AAE3B,cAAW,OAAO;WACX,OAAO;AACd,cAAW,MAAM,MAAM;;IAG5B,CAAC"}