electron-json-rpc 1.0.0

package/dist/debug.d.mts

@@ -0,0 +1,92 @@
+import { h as RpcLogger } from "./types-BnGse9DF.mjs";
+
+//#region src/debug.d.ts
+/**
+ * Set global debug mode for all RPC clients
+ *
+ * @param enabled - Whether to enable debug logging
+ *
+ * @example
+ * ```typescript
+ * import { setRpcDebug } from 'electron-json-rpc/renderer';
+ *
+ * // Enable debug logging for all RPC clients
+ * setRpcDebug(true);
+ *
+ * // Disable debug logging
+ * setRpcDebug(false);
+ * ```
+ */
+declare function setRpcDebug(enabled: boolean): void;
+/**
+ * Check if global debug mode is enabled
+ *
+ * @returns True if debug mode is enabled
+ *
+ * @example
+ * ```typescript
+ * import { isRpcDebug } from 'electron-json-rpc/renderer';
+ *
+ * if (isRpcDebug()) {
+ *   console.log('Debug logging is enabled');
+ * }
+ * ```
+ */
+declare function isRpcDebug(): boolean;
+/**
+ * Set a custom logger for RPC debug output
+ *
+ * @param logger - Logger function or null to reset to default
+ *
+ * @example
+ * ```typescript
+ * import { setRpcLogger } from 'electron-json-rpc/renderer';
+ *
+ * // Set custom logger
+ * setRpcLogger((entry) => {
+ *   console.log(`[${entry.type.toUpperCase()}] ${entry.method}`, entry);
+ * });
+ *
+ * // Reset to default logger
+ * setRpcLogger(null);
+ * ```
+ */
+declare function setRpcLogger(logger: RpcLogger | null): void;
+/**
+ * Get the current logger (custom or default)
+ *
+ * @internal
+ */
+declare function getLogger(): RpcLogger;
+/**
+ * Check if debug is enabled (either globally or via option)
+ *
+ * @internal
+ */
+declare function isDebugEnabled(debugOption?: boolean): boolean;
+/**
+ * Format timestamp for debug output
+ *
+ * @internal
+ */
+declare function formatTimestamp(timestamp: number): string;
+/**
+ * Debug tracker interface
+ */
+interface DebugTracker {
+  onRequest: (method: string, params: unknown[], requestId: number) => void;
+  onResponse: (method: string, params: unknown[], result: unknown, duration: number, requestId: number) => void;
+  onError: (method: string, params: unknown[], error: string, duration: number, requestId: number) => void;
+  onNotify: (method: string, params: unknown[]) => void;
+  onStream: (method: string, params: unknown[]) => void;
+  onEvent: (eventName: string, data: unknown) => void;
+}
+/**
+ * Create a debug wrapper for tracking RPC calls
+ *
+ * @internal
+ */
+declare function createDebugTracker(enabled: boolean, logger: RpcLogger): DebugTracker;
+//#endregion
+export { DebugTracker, createDebugTracker, formatTimestamp, getLogger, isDebugEnabled, isRpcDebug, setRpcDebug, setRpcLogger };
+//# sourceMappingURL=debug.d.mts.map

package/dist/debug.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.mts","names":[],"sources":["../src/debug.ts"],"mappings":";;;;AA4BA;AAkBA;AAsBA;AASA;AASA;AASA;AAqFA;AA0BA;;;;;;;;iBAlLgB,WAAA,CAAA,OAAA;AAAA;AAkBhB;AAsBA;AASA;AASA;AASA;AAqFA;AA0BA;;;;;;;AAlLgB,iBAkBA,UAAA,CAAA;AAAA;AAsBhB;AASA;AASA;AASA;AAqFA;AA0BA;;;;;;;;;;;;AAhKgB,iBAsBA,YAAA,CAAA,MAAA,EAAqB,SAAA;AAAA;AASrC;AASA;AASA;AAqFA;AAhHqC,iBASrB,SAAA,CAAA,GAAa,SAAA;AAAA;AAS7B;AASA;AAqFA;AA0BA;AAjI6B,iBASb,cAAA,CAAA,WAAA;AAAA;AAShB;AAqFA;AA0BA;;AAxHgB,iBASA,eAAA,CAAA,SAAA;AAAA;AAqFhB;AA0BA;AA/GgB,UAqFC,YAAA;EAAA,SAAA,GAAA,MAAA,UAAA,MAAA,aAAA,SAAA;EAAA,UAAA,GAAA,MAAA,UAAA,MAAA,aAAA,MAAA,WAAA,QAAA,UAAA,SAAA;EAAA,OAAA,GAAA,MAAA,UAAA,MAAA,aAAA,KAAA,UAAA,QAAA,UAAA,SAAA;EAAA,QAAA,GAAA,MAAA,UAAA,MAAA;EAAA,QAAA,GAAA,MAAA,UAAA,MAAA;EAAA,OAAA,GAAA,SAAA,UAAA,IAAA;AAAA;AAAA;AA0BjB;;;;AA1BiB,iBA0BD,kBAAA,CAAA,OAAA,WAAA,MAAA,EAA6C,SAAA,GAAY,YAAA"}

package/dist/debug.mjs

@@ -0,0 +1,206 @@
+//#region src/debug.ts
+/**
+* Global debug state
+*/
+let globalDebugEnabled = false;
+let customLogger = null;
+/**
+* Set global debug mode for all RPC clients
+*
+* @param enabled - Whether to enable debug logging
+*
+* @example
+* ```typescript
+* import { setRpcDebug } from 'electron-json-rpc/renderer';
+*
+* // Enable debug logging for all RPC clients
+* setRpcDebug(true);
+*
+* // Disable debug logging
+* setRpcDebug(false);
+* ```
+*/
+function setRpcDebug(enabled) {
+	globalDebugEnabled = enabled;
+}
+/**
+* Check if global debug mode is enabled
+*
+* @returns True if debug mode is enabled
+*
+* @example
+* ```typescript
+* import { isRpcDebug } from 'electron-json-rpc/renderer';
+*
+* if (isRpcDebug()) {
+*   console.log('Debug logging is enabled');
+* }
+* ```
+*/
+function isRpcDebug() {
+	return globalDebugEnabled;
+}
+/**
+* Set a custom logger for RPC debug output
+*
+* @param logger - Logger function or null to reset to default
+*
+* @example
+* ```typescript
+* import { setRpcLogger } from 'electron-json-rpc/renderer';
+*
+* // Set custom logger
+* setRpcLogger((entry) => {
+*   console.log(`[${entry.type.toUpperCase()}] ${entry.method}`, entry);
+* });
+*
+* // Reset to default logger
+* setRpcLogger(null);
+* ```
+*/
+function setRpcLogger(logger) {
+	customLogger = logger;
+}
+/**
+* Get the current logger (custom or default)
+*
+* @internal
+*/
+function getLogger() {
+	return customLogger ?? defaultLogger;
+}
+/**
+* Check if debug is enabled (either globally or via option)
+*
+* @internal
+*/
+function isDebugEnabled(debugOption) {
+	return globalDebugEnabled || debugOption === true;
+}
+/**
+* Format timestamp for debug output
+*
+* @internal
+*/
+function formatTimestamp(timestamp) {
+	return new Date(timestamp).toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		fractionalSecondDigits: 3
+	});
+}
+/**
+* ANSI color codes for terminal output
+*
+* @internal
+*/
+const colors = {
+	reset: "\x1B[0m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	red: "\x1B[31m",
+	gray: "\x1B[90m",
+	dim: "\x1B[2m"
+};
+/**
+* Default logger implementation with formatted console output
+*
+* @internal
+*/
+const defaultLogger = (entry) => {
+	const timeStr = formatTimestamp(entry.timestamp);
+	const arrow = entry.type === "request" || entry.type === "notify" || entry.type === "event" ? "→" : entry.type === "stream" ? "↦" : "←";
+	let typeColor = colors.cyan;
+	if (entry.type === "error") typeColor = colors.red;
+	else if (entry.type === "response") typeColor = colors.green;
+	else if (entry.type === "stream") typeColor = colors.yellow;
+	else if (entry.type === "event") typeColor = colors.cyan;
+	else if (entry.type === "notify") typeColor = colors.gray;
+	let durationSuffix = "";
+	if (entry.duration !== void 0) durationSuffix = ` ${entry.duration > 1e3 ? colors.yellow : colors.dim}(${entry.duration}ms)${colors.reset}`;
+	let idSuffix = "";
+	if (entry.requestId !== void 0) idSuffix = `${colors.dim} [#${entry.requestId}]${colors.reset}`;
+	console.log(`${typeColor}[RPC]${colors.reset} ${colors.dim}${timeStr}${colors.reset} ${arrow} ${entry.type} ${entry.method}${idSuffix}${durationSuffix}`);
+	if (entry.params !== void 0 && entry.params.length > 0) console.log(`${colors.dim}  params:${colors.reset}`, entry.params);
+	if (entry.result !== void 0) console.log(`${colors.dim}  result:${colors.reset}`, entry.result);
+	if (entry.error) console.log(`${colors.red}  error:${colors.reset}`, entry.error);
+};
+/**
+* Create a debug wrapper for tracking RPC calls
+*
+* @internal
+*/
+function createDebugTracker(enabled, logger) {
+	if (!enabled) return {
+		onRequest: () => {},
+		onResponse: () => {},
+		onError: () => {},
+		onNotify: () => {},
+		onStream: () => {},
+		onEvent: () => {}
+	};
+	return {
+		onRequest: (method, params, requestId) => {
+			logger({
+				type: "request",
+				method,
+				params,
+				timestamp: Date.now(),
+				requestId
+			});
+		},
+		onResponse: (method, params, result, duration, requestId) => {
+			logger({
+				type: "response",
+				method,
+				params,
+				result,
+				timestamp: Date.now(),
+				duration,
+				requestId
+			});
+		},
+		onError: (method, params, error, duration, requestId) => {
+			logger({
+				type: "error",
+				method,
+				params,
+				error,
+				timestamp: Date.now(),
+				duration,
+				requestId
+			});
+		},
+		onNotify: (method, params) => {
+			logger({
+				type: "notify",
+				method,
+				params,
+				timestamp: Date.now()
+			});
+		},
+		onStream: (method, params) => {
+			logger({
+				type: "stream",
+				method,
+				params,
+				timestamp: Date.now()
+			});
+		},
+		onEvent: (eventName, data) => {
+			logger({
+				type: "event",
+				method: eventName,
+				params: data !== void 0 ? [data] : void 0,
+				timestamp: Date.now()
+			});
+		}
+	};
+}
+
+//#endregion
+export { createDebugTracker, formatTimestamp, getLogger, isDebugEnabled, isRpcDebug, setRpcDebug, setRpcLogger };
+//# sourceMappingURL=debug.mjs.map

package/dist/debug.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.mjs","names":[],"sources":["../src/debug.ts"],"sourcesContent":["/**\n * Debug logging utilities for JSON-RPC clients\n */\n\nimport type { RpcLogEntry, RpcLogger } from \"./types.js\";\n\n/**\n * Global debug state\n */\nlet globalDebugEnabled = false;\nlet customLogger: RpcLogger | null = null;\n\n/**\n * Set global debug mode for all RPC clients\n *\n * @param enabled - Whether to enable debug logging\n *\n * @example\n * ```typescript\n * import { setRpcDebug } from 'electron-json-rpc/renderer';\n *\n * // Enable debug logging for all RPC clients\n * setRpcDebug(true);\n *\n * // Disable debug logging\n * setRpcDebug(false);\n * ```\n */\nexport function setRpcDebug(enabled: boolean): void {\n  globalDebugEnabled = enabled;\n}\n\n/**\n * Check if global debug mode is enabled\n *\n * @returns True if debug mode is enabled\n *\n * @example\n * ```typescript\n * import { isRpcDebug } from 'electron-json-rpc/renderer';\n *\n * if (isRpcDebug()) {\n *   console.log('Debug logging is enabled');\n * }\n * ```\n */\nexport function isRpcDebug(): boolean {\n  return globalDebugEnabled;\n}\n\n/**\n * Set a custom logger for RPC debug output\n *\n * @param logger - Logger function or null to reset to default\n *\n * @example\n * ```typescript\n * import { setRpcLogger } from 'electron-json-rpc/renderer';\n *\n * // Set custom logger\n * setRpcLogger((entry) => {\n *   console.log(`[${entry.type.toUpperCase()}] ${entry.method}`, entry);\n * });\n *\n * // Reset to default logger\n * setRpcLogger(null);\n * ```\n */\nexport function setRpcLogger(logger: RpcLogger | null): void {\n  customLogger = logger;\n}\n\n/**\n * Get the current logger (custom or default)\n *\n * @internal\n */\nexport function getLogger(): RpcLogger {\n  return customLogger ?? defaultLogger;\n}\n\n/**\n * Check if debug is enabled (either globally or via option)\n *\n * @internal\n */\nexport function isDebugEnabled(debugOption?: boolean): boolean {\n  return globalDebugEnabled || debugOption === true;\n}\n\n/**\n * Format timestamp for debug output\n *\n * @internal\n */\nexport function formatTimestamp(timestamp: number): string {\n  const time = new Date(timestamp);\n  return time.toLocaleTimeString(\"en-US\", {\n    hour12: false,\n    hour: \"2-digit\",\n    minute: \"2-digit\",\n    second: \"2-digit\",\n    fractionalSecondDigits: 3,\n  });\n}\n\n/**\n * ANSI color codes for terminal output\n *\n * @internal\n */\nconst colors = {\n  reset: \"\\x1b[0m\",\n  cyan: \"\\x1b[36m\",\n  green: \"\\x1b[32m\",\n  yellow: \"\\x1b[33m\",\n  red: \"\\x1b[31m\",\n  gray: \"\\x1b[90m\",\n  dim: \"\\x1b[2m\",\n};\n\n/**\n * Default logger implementation with formatted console output\n *\n * @internal\n */\nconst defaultLogger: RpcLogger = (entry: RpcLogEntry) => {\n  const timeStr = formatTimestamp(entry.timestamp);\n  const arrow =\n    entry.type === \"request\" || entry.type === \"notify\" || entry.type === \"event\"\n      ? \"→\"\n      : entry.type === \"stream\"\n        ? \"↦\"\n        : \"←\";\n\n  // Select color based on entry type\n  let typeColor = colors.cyan;\n  if (entry.type === \"error\") typeColor = colors.red;\n  else if (entry.type === \"response\") typeColor = colors.green;\n  else if (entry.type === \"stream\") typeColor = colors.yellow;\n  else if (entry.type === \"event\") typeColor = colors.cyan;\n  else if (entry.type === \"notify\") typeColor = colors.gray;\n\n  // Build duration suffix\n  let durationSuffix = \"\";\n  if (entry.duration !== undefined) {\n    const durationColor = entry.duration > 1000 ? colors.yellow : colors.dim;\n    durationSuffix = ` ${durationColor}(${entry.duration}ms)${colors.reset}`;\n  }\n\n  // Build request ID suffix\n  let idSuffix = \"\";\n  if (entry.requestId !== undefined) {\n    idSuffix = `${colors.dim} [#${entry.requestId}]${colors.reset}`;\n  }\n\n  // Main log line\n  console.log(\n    `${typeColor}[RPC]${colors.reset} ${colors.dim}${timeStr}${colors.reset} ${arrow} ${entry.type} ${entry.method}${idSuffix}${durationSuffix}`,\n  );\n\n  // Log params\n  if (entry.params !== undefined && entry.params.length > 0) {\n    console.log(`${colors.dim}  params:${colors.reset}`, entry.params);\n  }\n\n  // Log result\n  if (entry.result !== undefined) {\n    console.log(`${colors.dim}  result:${colors.reset}`, entry.result);\n  }\n\n  // Log error\n  if (entry.error) {\n    console.log(`${colors.red}  error:${colors.reset}`, entry.error);\n  }\n};\n\n/**\n * Debug tracker interface\n */\nexport interface DebugTracker {\n  onRequest: (method: string, params: unknown[], requestId: number) => void;\n  onResponse: (\n    method: string,\n    params: unknown[],\n    result: unknown,\n    duration: number,\n    requestId: number,\n  ) => void;\n  onError: (\n    method: string,\n    params: unknown[],\n    error: string,\n    duration: number,\n    requestId: number,\n  ) => void;\n  onNotify: (method: string, params: unknown[]) => void;\n  onStream: (method: string, params: unknown[]) => void;\n  onEvent: (eventName: string, data: unknown) => void;\n}\n\n/**\n * Create a debug wrapper for tracking RPC calls\n *\n * @internal\n */\nexport function createDebugTracker(enabled: boolean, logger: RpcLogger): DebugTracker {\n  if (!enabled) {\n    return {\n      onRequest: () => {},\n      onResponse: () => {},\n      onError: () => {},\n      onNotify: () => {},\n      onStream: () => {},\n      onEvent: () => {},\n    };\n  }\n\n  return {\n    onRequest: (method, params, requestId) => {\n      logger({\n        type: \"request\",\n        method,\n        params,\n        timestamp: Date.now(),\n        requestId,\n      });\n    },\n    onResponse: (method, params, result, duration, requestId) => {\n      logger({\n        type: \"response\",\n        method,\n        params,\n        result,\n        timestamp: Date.now(),\n        duration,\n        requestId,\n      });\n    },\n    onError: (method, params, error, duration, requestId) => {\n      logger({\n        type: \"error\",\n        method,\n        params,\n        error,\n        timestamp: Date.now(),\n        duration,\n        requestId,\n      });\n    },\n    onNotify: (method, params) => {\n      logger({\n        type: \"notify\",\n        method,\n        params,\n        timestamp: Date.now(),\n      });\n    },\n    onStream: (method, params) => {\n      logger({\n        type: \"stream\",\n        method,\n        params,\n        timestamp: Date.now(),\n      });\n    },\n    onEvent: (eventName, data) => {\n      logger({\n        type: \"event\",\n        method: eventName,\n        params: data !== undefined ? [data] : undefined,\n        timestamp: Date.now(),\n      });\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/error-xVRu7Lxq.mjs

@@ -0,0 +1,131 @@
+//#region src/types.ts
+/**
+* JSON-RPC 2.0 Error codes
+*/
+let JsonRpcErrorCode = /* @__PURE__ */ function(JsonRpcErrorCode) {
+	JsonRpcErrorCode[JsonRpcErrorCode["ParseError"] = -32700] = "ParseError";
+	JsonRpcErrorCode[JsonRpcErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+	JsonRpcErrorCode[JsonRpcErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+	JsonRpcErrorCode[JsonRpcErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+	JsonRpcErrorCode[JsonRpcErrorCode["InternalError"] = -32603] = "InternalError";
+	return JsonRpcErrorCode;
+}({});
+
+//#endregion
+//#region src/error.ts
+/**
+* Create a JSON-RPC error object
+*/
+function createJsonRpcError(code, message, data) {
+	return {
+		code,
+		message,
+		data
+	};
+}
+/**
+* Predefined error creators
+*/
+const errors = {
+	parseError: (data) => createJsonRpcError(JsonRpcErrorCode.ParseError, "Parse error", data),
+	invalidRequest: (data) => createJsonRpcError(JsonRpcErrorCode.InvalidRequest, "Invalid Request", data),
+	methodNotFound: (method) => createJsonRpcError(JsonRpcErrorCode.MethodNotFound, `Method not found${method ? `: ${method}` : ""}`),
+	invalidParams: (data) => createJsonRpcError(JsonRpcErrorCode.InvalidParams, "Invalid params", data),
+	internalError: (data) => createJsonRpcError(JsonRpcErrorCode.InternalError, "Internal error", data)
+};
+/**
+* Check if an error is a JSON-RPC error
+*/
+function isJsonRpcError(error) {
+	return typeof error === "object" && error !== null && "code" in error && typeof error.code === "number" && "message" in error && typeof error.message === "string";
+}
+/**
+* Convert an Error object to JSON-RPC error
+*/
+function errorToJsonRpc(error) {
+	if (isJsonRpcError(error)) return error;
+	if (error instanceof Error) return {
+		code: JsonRpcErrorCode.InternalError,
+		message: error.message,
+		data: error.name
+	};
+	return {
+		code: JsonRpcErrorCode.InternalError,
+		message: "Unknown error",
+		data: error
+	};
+}
+/**
+* Timeout error class
+*/
+var RpcTimeoutError = class extends Error {
+	timeout;
+	constructor(timeout) {
+		super(`RPC call timed out after ${timeout}ms`);
+		this.name = "RpcTimeoutError";
+		this.timeout = timeout;
+	}
+};
+/**
+* Check if an error is a timeout error
+*/
+function isTimeoutError(error) {
+	return error instanceof RpcTimeoutError;
+}
+/**
+* Error thrown when queue is full and fullBehavior is 'reject'
+*/
+var RpcQueueFullError = class extends Error {
+	currentSize;
+	maxSize;
+	constructor(currentSize, maxSize) {
+		super(`RPC queue is full (${currentSize}/${maxSize})`);
+		this.name = "RpcQueueFullError";
+		this.currentSize = currentSize;
+		this.maxSize = maxSize;
+	}
+};
+/**
+* Error thrown when connection to main process is lost
+*/
+var RpcConnectionError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "RpcConnectionError";
+		this.code = code;
+	}
+};
+/**
+* Error thrown when request is evicted from queue
+*/
+var RpcQueueEvictedError = class extends Error {
+	reason;
+	constructor(reason) {
+		super(`Request evicted from queue: ${reason}`);
+		this.name = "RpcQueueEvictedError";
+		this.reason = reason;
+	}
+};
+/**
+* Check if an error is a queue full error
+*/
+function isQueueFullError(error) {
+	return error instanceof RpcQueueFullError;
+}
+/**
+* Check if an error is a connection error
+*/
+function isConnectionError(error) {
+	return error instanceof RpcConnectionError;
+}
+/**
+* Check if an error is a queue evicted error
+*/
+function isQueueEvictedError(error) {
+	return error instanceof RpcQueueEvictedError;
+}
+
+//#endregion
+export { createJsonRpcError as a, isConnectionError as c, isQueueFullError as d, isTimeoutError as f, RpcTimeoutError as i, isJsonRpcError as l, RpcQueueEvictedError as n, errorToJsonRpc as o, JsonRpcErrorCode as p, RpcQueueFullError as r, errors as s, RpcConnectionError as t, isQueueEvictedError as u };
+//# sourceMappingURL=error-xVRu7Lxq.mjs.map

package/dist/error-xVRu7Lxq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-xVRu7Lxq.mjs","names":[],"sources":["../src/types.ts","../src/error.ts"],"sourcesContent":["/**\n * JSON-RPC 2.0 types for Electron IPC communication\n */\n\n/**\n * JSON-RPC 2.0 Request\n * id is optional for notifications (one-way calls)\n */\nexport interface JsonRpcRequest {\n  jsonrpc: \"2.0\";\n  id?: string | number | null;\n  method: string;\n  params?: unknown[] | Record<string, unknown>;\n}\n\n/**\n * JSON-RPC 2.0 Response\n */\nexport interface JsonRpcResponse {\n  jsonrpc: \"2.0\";\n  id: string | number | null;\n  result?: unknown;\n  error?: JsonRpcError;\n}\n\n/**\n * JSON-RPC 2.0 Error\n */\nexport interface JsonRpcError {\n  code: number;\n  message: string;\n  data?: unknown;\n}\n\n/**\n * JSON-RPC 2.0 Error codes\n */\nexport enum JsonRpcErrorCode {\n  ParseError = -32700,\n  InvalidRequest = -32600,\n  MethodNotFound = -32601,\n  InvalidParams = -32602,\n  InternalError = -32603,\n}\n\n/**\n * RPC method handler type\n */\nexport type RpcHandler = (...params: unknown[]) => unknown | Promise<unknown>;\n\n/**\n * Validator function for params\n * Throw an error to reject the request with InvalidParams error\n */\nexport type RpcValidator = (params: unknown[]) => void | Promise<void>;\n\n/**\n * RPC method registration options\n */\nexport interface RpcMethodOptions {\n  /** Optional validator for parameters */\n  validate?: RpcValidator;\n  /** Optional description for documentation */\n  description?: string;\n}\n\n/**\n * Typed API interface for RPC client\n * Converts method signatures to match JSON-RPC behavior\n */\nexport type RpcApi<T extends Record<string, (...args: any[]) => any>> = {\n  [K in keyof T]: T[K] extends (...args: infer P) => infer R\n    ? R extends void\n      ? (...params: P) => void // Notification (void return)\n      : (...params: P) => Promise<Awaited<R>> // Regular method\n    : never;\n};\n\n/**\n * Options for RPC client\n */\nexport interface RpcClientOptions {\n  /** Timeout in milliseconds (default: 30000) */\n  timeout?: number;\n  /** API name exposed by preload (default: 'rpc') */\n  apiName?: string;\n}\n\n/**\n * Options for exposing RPC API in preload\n */\nexport interface ExposeRpcApiOptions {\n  contextBridge: {\n    exposeInMainWorld: (name: string, api: Record<string, unknown>) => void;\n  };\n  ipcRenderer: {\n    send: (channel: string, ...args: unknown[]) => void;\n    on: (channel: string, listener: (event: unknown, ...args: unknown[]) => void) => void;\n    removeListener: (channel: string, listener: (...args: unknown[]) => void) => void;\n  };\n  /** Optional whitelist of methods to expose */\n  methods?: string[];\n  /** API name exposed to renderer (default: 'rpc') */\n  apiName?: string;\n}\n\n/**\n * Stream chunk message for IPC\n */\nexport interface StreamChunk {\n  streamId: string | number;\n  type: \"chunk\" | \"end\" | \"error\";\n  data?: unknown;\n  error?: JsonRpcError;\n}\n\n/**\n * Stream request with stream flag\n */\nexport interface StreamRequest extends JsonRpcRequest {\n  stream?: true;\n}\n\n/**\n * Stream handler - returns a ReadableStream\n */\nexport type StreamHandler = (...params: unknown[]) => ReadableStream;\n\n/**\n * Stream method registration options\n */\nexport interface StreamMethodOptions extends RpcMethodOptions {\n  /** Indicates this method returns a stream */\n  stream?: true;\n}\n\n/**\n * Underlying source for ReadableStream\n */\nexport type UnderlyingSource<T> = {\n  start?: (controller: ReadableStreamDefaultController<T>) => void | Promise<void>;\n  pull?: (controller: ReadableStreamDefaultController<T>) => void | Promise<void>;\n  cancel?: (reason?: unknown) => void | Promise<void>;\n  type?: undefined;\n};\n\n/**\n * Event handler callback type\n */\nexport type EventHandler<T = unknown> = (data: T) => void;\n\n/**\n * Event subscriber information\n */\nexport interface EventSubscriber {\n  windowId: number;\n  eventName: string;\n}\n\n/**\n * Event bus API type\n * Maps event names to their data types\n */\nexport type EventBusEvents<T extends Record<string, unknown>> = {\n  [K in keyof T]: T[K];\n};\n\n/**\n * Typed event bus interface\n */\nexport type EventBus<T extends Record<string, unknown> = Record<string, unknown>> = {\n  /**\n   * Subscribe to an event\n   * @returns Unsubscribe function\n   */\n  on<K extends keyof T>(eventName: K, callback: EventHandler<T[K]>): () => void;\n\n  /**\n   * Unsubscribe from an event\n   * If no callback is provided, removes all handlers for the event\n   */\n  off<K extends keyof T>(eventName: K, callback?: EventHandler<T[K]>): void;\n\n  /**\n   * Subscribe to an event once (auto-unsubscribe after first call)\n   */\n  once<K extends keyof T>(eventName: K, callback: EventHandler<T[K]>): void;\n\n  /**\n   * Get list of subscribed event names\n   */\n  getSubscribedEvents(): string[];\n};\n\n/**\n * RPC debug log entry type\n */\nexport interface RpcLogEntry {\n  /** Log entry type */\n  type: \"request\" | \"response\" | \"error\" | \"notify\" | \"stream\" | \"event\";\n  /** RPC method or event name */\n  method: string;\n  /** Request parameters */\n  params?: unknown[];\n  /** Response result */\n  result?: unknown;\n  /** Error message */\n  error?: string;\n  /** Timestamp in milliseconds */\n  timestamp: number;\n  /** Duration in milliseconds (for responses/errors) */\n  duration?: number;\n  /** Request ID for correlating request/response */\n  requestId?: string | number;\n}\n\n/**\n * RPC logger function type\n */\nexport type RpcLogger = (entry: RpcLogEntry) => void;\n\n/**\n * Debug options for RPC clients\n */\nexport interface RpcDebugOptions {\n  /** Enable debug logging */\n  debug?: boolean;\n  /** Custom logger function */\n  logger?: RpcLogger;\n}\n","/**\n * JSON-RPC error utilities\n */\n\nimport type { JsonRpcError } from \"./types.js\";\nimport { JsonRpcErrorCode } from \"./types.js\";\n\n/**\n * Create a JSON-RPC error object\n */\nexport function createJsonRpcError(code: number, message: string, data?: unknown): JsonRpcError {\n  return { code, message, data };\n}\n\n/**\n * Predefined error creators\n */\nexport const errors = {\n  parseError: (data?: unknown) =>\n    createJsonRpcError(JsonRpcErrorCode.ParseError, \"Parse error\", data),\n  invalidRequest: (data?: unknown) =>\n    createJsonRpcError(JsonRpcErrorCode.InvalidRequest, \"Invalid Request\", data),\n  methodNotFound: (method?: string) =>\n    createJsonRpcError(\n      JsonRpcErrorCode.MethodNotFound,\n      `Method not found${method ? `: ${method}` : \"\"}`,\n    ),\n  invalidParams: (data?: unknown) =>\n    createJsonRpcError(JsonRpcErrorCode.InvalidParams, \"Invalid params\", data),\n  internalError: (data?: unknown) =>\n    createJsonRpcError(JsonRpcErrorCode.InternalError, \"Internal error\", data),\n};\n\n/**\n * Check if an error is a JSON-RPC error\n */\nexport function isJsonRpcError(error: unknown): error is JsonRpcError {\n  return (\n    typeof error === \"object\" &&\n    error !== null &&\n    \"code\" in error &&\n    typeof (error as JsonRpcError).code === \"number\" &&\n    \"message\" in error &&\n    typeof (error as JsonRpcError).message === \"string\"\n  );\n}\n\n/**\n * Convert an Error object to JSON-RPC error\n */\nexport function errorToJsonRpc(error: unknown): JsonRpcError {\n  if (isJsonRpcError(error)) {\n    return error;\n  }\n\n  if (error instanceof Error) {\n    return {\n      code: JsonRpcErrorCode.InternalError,\n      message: error.message,\n      data: error.name,\n    };\n  }\n\n  return {\n    code: JsonRpcErrorCode.InternalError,\n    message: \"Unknown error\",\n    data: error,\n  };\n}\n\n/**\n * Timeout error class\n */\nexport class RpcTimeoutError extends Error {\n  declare readonly name: \"RpcTimeoutError\";\n  readonly timeout: number;\n\n  constructor(timeout: number) {\n    super(`RPC call timed out after ${timeout}ms`);\n    this.name = \"RpcTimeoutError\";\n    this.timeout = timeout;\n  }\n}\n\n/**\n * Check if an error is a timeout error\n */\nexport function isTimeoutError(error: unknown): error is RpcTimeoutError {\n  return error instanceof RpcTimeoutError;\n}\n\n/**\n * Error thrown when queue is full and fullBehavior is 'reject'\n */\nexport class RpcQueueFullError extends Error {\n  declare readonly name: \"RpcQueueFullError\";\n  readonly currentSize: number;\n  readonly maxSize: number;\n\n  constructor(currentSize: number, maxSize: number) {\n    super(`RPC queue is full (${currentSize}/${maxSize})`);\n    this.name = \"RpcQueueFullError\";\n    this.currentSize = currentSize;\n    this.maxSize = maxSize;\n  }\n}\n\n/**\n * Error thrown when connection to main process is lost\n */\nexport class RpcConnectionError extends Error {\n  declare readonly name: \"RpcConnectionError\";\n  readonly code?: string;\n\n  constructor(message: string, code?: string) {\n    super(message);\n    this.name = \"RpcConnectionError\";\n    this.code = code;\n  }\n}\n\n/**\n * Error thrown when request is evicted from queue\n */\nexport class RpcQueueEvictedError extends Error {\n  declare readonly name: \"RpcQueueEvictedError\";\n  readonly reason: \"full\" | \"timeout\";\n\n  constructor(reason: \"full\" | \"timeout\") {\n    super(`Request evicted from queue: ${reason}`);\n    this.name = \"RpcQueueEvictedError\";\n    this.reason = reason;\n  }\n}\n\n/**\n * Check if an error is a queue full error\n */\nexport function isQueueFullError(error: unknown): error is RpcQueueFullError {\n  return error instanceof RpcQueueFullError;\n}\n\n/**\n * Check if an error is a connection error\n */\nexport function isConnectionError(error: unknown): error is RpcConnectionError {\n  return error instanceof RpcConnectionError;\n}\n\n/**\n * Check if an error is a queue evicted error\n */\nexport function isQueueEvictedError(error: unknown): error is RpcQueueEvictedError {\n  return error instanceof RpcQueueEvictedError;\n}\n"],"mappings":";;;;AAqCA,IAAY,8DAAL;AACL;AACA;AACA;AACA;AACA;;;;;;;;;AChCF,SAAgB,mBAAmB,MAAc,SAAiB,MAA8B;AAC9F,QAAO;EAAE;EAAM;EAAS;EAAM;;;;;AAMhC,MAAa,SAAS;CACpB,aAAa,SACX,mBAAmB,iBAAiB,YAAY,eAAe,KAAK;CACtE,iBAAiB,SACf,mBAAmB,iBAAiB,gBAAgB,mBAAmB,KAAK;CAC9E,iBAAiB,WACf,mBACE,iBAAiB,gBACjB,mBAAmB,SAAS,KAAK,WAAW,KAC7C;CACH,gBAAgB,SACd,mBAAmB,iBAAiB,eAAe,kBAAkB,KAAK;CAC5E,gBAAgB,SACd,mBAAmB,iBAAiB,eAAe,kBAAkB,KAAK;CAC7E;;;;AAKD,SAAgB,eAAe,OAAuC;AACpE,QACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACV,OAAQ,MAAuB,SAAS,YACxC,aAAa,SACb,OAAQ,MAAuB,YAAY;;;;;AAO/C,SAAgB,eAAe,OAA8B;AAC3D,KAAI,eAAe,MAAM,CACvB,QAAO;AAGT,KAAI,iBAAiB,MACnB,QAAO;EACL,MAAM,iBAAiB;EACvB,SAAS,MAAM;EACf,MAAM,MAAM;EACb;AAGH,QAAO;EACL,MAAM,iBAAiB;EACvB,SAAS;EACT,MAAM;EACP;;;;;AAMH,IAAa,kBAAb,cAAqC,MAAM;CAEzC,AAAS;CAET,YAAY,SAAiB;AAC3B,QAAM,4BAA4B,QAAQ,IAAI;AAC9C,OAAK,OAAO;AACZ,OAAK,UAAU;;;;;;AAOnB,SAAgB,eAAe,OAA0C;AACvE,QAAO,iBAAiB;;;;;AAM1B,IAAa,oBAAb,cAAuC,MAAM;CAE3C,AAAS;CACT,AAAS;CAET,YAAY,aAAqB,SAAiB;AAChD,QAAM,sBAAsB,YAAY,GAAG,QAAQ,GAAG;AACtD,OAAK,OAAO;AACZ,OAAK,cAAc;AACnB,OAAK,UAAU;;;;;;AAOnB,IAAa,qBAAb,cAAwC,MAAM;CAE5C,AAAS;CAET,YAAY,SAAiB,MAAe;AAC1C,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,OAAO;;;;;;AAOhB,IAAa,uBAAb,cAA0C,MAAM;CAE9C,AAAS;CAET,YAAY,QAA4B;AACtC,QAAM,+BAA+B,SAAS;AAC9C,OAAK,OAAO;AACZ,OAAK,SAAS;;;;;;AAOlB,SAAgB,iBAAiB,OAA4C;AAC3E,QAAO,iBAAiB;;;;;AAM1B,SAAgB,kBAAkB,OAA6C;AAC7E,QAAO,iBAAiB;;;;;AAM1B,SAAgB,oBAAoB,OAA+C;AACjF,QAAO,iBAAiB"}

package/dist/event.d.mts

@@ -0,0 +1,71 @@
+//#region src/event.d.ts
+/**
+ * Event Bus utilities for electron-json-rpc
+ *
+ * Implements publish-subscribe pattern for main-to-renderer communication
+ */
+/**
+ * IPC channel name for event bus messages
+ */
+declare const EVENT_CHANNEL = "json-rpc-events";
+/**
+ * Message types for event bus communication
+ */
+type EventMessageType = "subscribe" | "unsubscribe" | "event";
+/**
+ * Event bus message sent between main and renderer
+ */
+interface EventMessage {
+  type: EventMessageType;
+  eventName: string;
+  data?: unknown;
+}
+/**
+ * Subscribe message sent from renderer to main
+ */
+interface SubscribeMessage extends EventMessage {
+  type: "subscribe";
+  eventName: string;
+}
+/**
+ * Unsubscribe message sent from renderer to main
+ */
+interface UnsubscribeMessage extends EventMessage {
+  type: "unsubscribe";
+  eventName: string;
+}
+/**
+ * Event message sent from main to renderer
+ */
+interface EventEmitMessage extends EventMessage {
+  type: "event";
+  eventName: string;
+  data?: unknown;
+}
+/**
+ * Create a subscribe message
+ */
+declare function createSubscribeMessage(eventName: string): SubscribeMessage;
+/**
+ * Create an unsubscribe message
+ */
+declare function createUnsubscribeMessage(eventName: string): UnsubscribeMessage;
+/**
+ * Create an event emit message
+ */
+declare function createEventMessage(eventName: string, data?: unknown): EventEmitMessage;
+/**
+ * Check if a message is an event emit message
+ */
+declare function isEventMessage(message: EventMessage): message is EventEmitMessage;
+/**
+ * Check if a message is a subscribe message
+ */
+declare function isSubscribeMessage(message: EventMessage): message is SubscribeMessage;
+/**
+ * Check if a message is an unsubscribe message
+ */
+declare function isUnsubscribeMessage(message: EventMessage): message is UnsubscribeMessage;
+//#endregion
+export { EVENT_CHANNEL, EventEmitMessage, EventMessage, EventMessageType, SubscribeMessage, UnsubscribeMessage, createEventMessage, createSubscribeMessage, createUnsubscribeMessage, isEventMessage, isSubscribeMessage, isUnsubscribeMessage };
+//# sourceMappingURL=event.d.mts.map

package/dist/event.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.mts","names":[],"sources":["../src/event.ts"],"mappings":";;AASA;AAKA;AAKA;AASA;;AAnBA;AAKA;cALa,aAAA;AAAA;AAKb;AAKA;AAVa,KAKD,gBAAA;AAAA;AAKZ;AASA;AAdY,UAKK,YAAA;EAAA,IAAA,EACT,gBAAA;EAAA,SAAA;EAAA,IAAA;AAAA;AAAA;AAQR;AAQA;AAhBQ,UAQS,gBAAA,SAAyB,YAAA;EAAA,IAAA;EAAA,SAAA;AAAA;AAAA;AAQ1C;AAQA;AAhB0C,UAQzB,kBAAA,SAA2B,YAAA;EAAA,IAAA;EAAA,SAAA;AAAA;AAAA;AAQ5C;AASA;AAjB4C,UAQ3B,gBAAA,SAAyB,YAAA;EAAA,IAAA;EAAA,SAAA;EAAA,IAAA;AAAA;AAAA;AAS1C;AAUA;AAnB0C,iBAS1B,sBAAA,CAAA,SAAA,WAA2C,gBAAA;AAAA;AAU3D;AAUA;AApB2D,iBAU3C,wBAAA,CAAA,SAAA,WAA6C,kBAAA;AAAA;AAU7D;AAWA;AArB6D,iBAU7C,kBAAA,CAAA,SAAA,UAAA,IAAA,aAAuD,gBAAA;AAAA;AAWvE;AAOA;AAlBuE,iBAWvD,cAAA,CAAA,OAAA,EAAwB,YAAA,GAAA,OAAA,IAA0B,gBAAA;AAAA;AAOlE;AAOA;AAdkE,iBAOlD,kBAAA,CAAA,OAAA,EAA4B,YAAA,GAAA,OAAA,IAA0B,gBAAA;AAAA;AAOtE;;AAPsE,iBAOtD,oBAAA,CAAA,OAAA,EAA8B,YAAA,GAAA,OAAA,IAA0B,kBAAA"}

package/dist/event.mjs

@@ -0,0 +1,60 @@
+//#region src/event.ts
+/**
+* Event Bus utilities for electron-json-rpc
+*
+* Implements publish-subscribe pattern for main-to-renderer communication
+*/
+/**
+* IPC channel name for event bus messages
+*/
+const EVENT_CHANNEL = "json-rpc-events";
+/**
+* Create a subscribe message
+*/
+function createSubscribeMessage(eventName) {
+	return {
+		type: "subscribe",
+		eventName
+	};
+}
+/**
+* Create an unsubscribe message
+*/
+function createUnsubscribeMessage(eventName) {
+	return {
+		type: "unsubscribe",
+		eventName
+	};
+}
+/**
+* Create an event emit message
+*/
+function createEventMessage(eventName, data) {
+	return {
+		type: "event",
+		eventName,
+		data
+	};
+}
+/**
+* Check if a message is an event emit message
+*/
+function isEventMessage(message) {
+	return message.type === "event";
+}
+/**
+* Check if a message is a subscribe message
+*/
+function isSubscribeMessage(message) {
+	return message.type === "subscribe";
+}
+/**
+* Check if a message is an unsubscribe message
+*/
+function isUnsubscribeMessage(message) {
+	return message.type === "unsubscribe";
+}
+
+//#endregion
+export { EVENT_CHANNEL, createEventMessage, createSubscribeMessage, createUnsubscribeMessage, isEventMessage, isSubscribeMessage, isUnsubscribeMessage };
+//# sourceMappingURL=event.mjs.map

package/dist/event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.mjs","names":[],"sources":["../src/event.ts"],"sourcesContent":["/**\n * Event Bus utilities for electron-json-rpc\n *\n * Implements publish-subscribe pattern for main-to-renderer communication\n */\n\n/**\n * IPC channel name for event bus messages\n */\nexport const EVENT_CHANNEL = \"json-rpc-events\";\n\n/**\n * Message types for event bus communication\n */\nexport type EventMessageType = \"subscribe\" | \"unsubscribe\" | \"event\";\n\n/**\n * Event bus message sent between main and renderer\n */\nexport interface EventMessage {\n  type: EventMessageType;\n  eventName: string;\n  data?: unknown;\n}\n\n/**\n * Subscribe message sent from renderer to main\n */\nexport interface SubscribeMessage extends EventMessage {\n  type: \"subscribe\";\n  eventName: string;\n}\n\n/**\n * Unsubscribe message sent from renderer to main\n */\nexport interface UnsubscribeMessage extends EventMessage {\n  type: \"unsubscribe\";\n  eventName: string;\n}\n\n/**\n * Event message sent from main to renderer\n */\nexport interface EventEmitMessage extends EventMessage {\n  type: \"event\";\n  eventName: string;\n  data?: unknown;\n}\n\n/**\n * Create a subscribe message\n */\nexport function createSubscribeMessage(eventName: string): SubscribeMessage {\n  return {\n    type: \"subscribe\",\n    eventName,\n  };\n}\n\n/**\n * Create an unsubscribe message\n */\nexport function createUnsubscribeMessage(eventName: string): UnsubscribeMessage {\n  return {\n    type: \"unsubscribe\",\n    eventName,\n  };\n}\n\n/**\n * Create an event emit message\n */\nexport function createEventMessage(eventName: string, data?: unknown): EventEmitMessage {\n  return {\n    type: \"event\",\n    eventName,\n    data,\n  };\n}\n\n/**\n * Check if a message is an event emit message\n */\nexport function isEventMessage(message: EventMessage): message is EventEmitMessage {\n  return message.type === \"event\";\n}\n\n/**\n * Check if a message is a subscribe message\n */\nexport function isSubscribeMessage(message: EventMessage): message is SubscribeMessage {\n  return message.type === \"subscribe\";\n}\n\n/**\n * Check if a message is an unsubscribe message\n */\nexport function isUnsubscribeMessage(message: EventMessage): message is UnsubscribeMessage {\n  return message.type === \"unsubscribe\";\n}\n"],"mappings":";;;;;;;;;AASA,MAAa,gBAAgB;;;;AA4C7B,SAAgB,uBAAuB,WAAqC;AAC1E,QAAO;EACL,MAAM;EACN;EACD;;;;;AAMH,SAAgB,yBAAyB,WAAuC;AAC9E,QAAO;EACL,MAAM;EACN;EACD;;;;;AAMH,SAAgB,mBAAmB,WAAmB,MAAkC;AACtF,QAAO;EACL,MAAM;EACN;EACA;EACD;;;;;AAMH,SAAgB,eAAe,SAAoD;AACjF,QAAO,QAAQ,SAAS;;;;;AAM1B,SAAgB,mBAAmB,SAAoD;AACrF,QAAO,QAAQ,SAAS;;;;;AAM1B,SAAgB,qBAAqB,SAAsD;AACzF,QAAO,QAAQ,SAAS"}