kkrpc 0.0.10 → 0.0.12

package/dist/browser-mod.cjs

@@ -1,21 +1,505 @@
-'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var worker = require('./adapters/worker.cjs');
-require('node:buffer');
-var channel = require('./channel.cjs');
-var utils = require('./utils.cjs');
-var serialization = require('./serialization.cjs');
-var iframe = require('./adapters/iframe.cjs');
+// browser-mod.ts
+var browser_mod_exports = {};
+__export(browser_mod_exports, {
+  IframeChildIO: () => IframeChildIO,
+  IframeParentIO: () => IframeParentIO,
+  RPCChannel: () => RPCChannel,
+  WorkerChildIO: () => WorkerChildIO,
+  WorkerParentIO: () => WorkerParentIO,
+  deserializeMessage: () => deserializeMessage,
+  deserializeResponse: () => deserializeResponse,
+  generateUUID: () => generateUUID,
+  serializeMessage: () => serializeMessage,
+  serializeResponse: () => serializeResponse
+});
+module.exports = __toCommonJS(browser_mod_exports);
 
+// src/adapters/worker.ts
+var DESTROY_SIGNAL = "__DESTROY__";
+var WorkerParentIO = class {
+  name = "worker-parent-io";
+  messageQueue = [];
+  resolveRead = null;
+  worker;
+  constructor(worker) {
+    this.worker = worker;
+    this.worker.onmessage = this.handleMessage;
+  }
+  handleMessage = (event) => {
+    const message = event.data;
+    if (message === DESTROY_SIGNAL) {
+      this.destroy();
+      return;
+    }
+    if (this.resolveRead) {
+      this.resolveRead(message);
+      this.resolveRead = null;
+    } else {
+      this.messageQueue.push(message);
+    }
+  };
+  read() {
+    if (this.messageQueue.length > 0) {
+      return Promise.resolve(this.messageQueue.shift() ?? null);
+    }
+    return new Promise((resolve) => {
+      this.resolveRead = resolve;
+    });
+  }
+  write(data) {
+    this.worker.postMessage(data);
+    return Promise.resolve();
+  }
+  destroy() {
+    this.worker.postMessage(DESTROY_SIGNAL);
+    this.worker.terminate();
+  }
+  signalDestroy() {
+    this.worker.postMessage(DESTROY_SIGNAL);
+  }
+};
+var WorkerChildIO = class {
+  name = "worker-child-io";
+  messageQueue = [];
+  resolveRead = null;
+  constructor() {
+    self.onmessage = this.handleMessage;
+  }
+  handleMessage = (event) => {
+    const message = event.data;
+    if (message === DESTROY_SIGNAL) {
+      this.destroy();
+      return;
+    }
+    if (this.resolveRead) {
+      this.resolveRead(message);
+      this.resolveRead = null;
+    } else {
+      this.messageQueue.push(message);
+    }
+  };
+  async read() {
+    if (this.messageQueue.length > 0) {
+      return this.messageQueue.shift() ?? null;
+    }
+    return new Promise((resolve) => {
+      this.resolveRead = resolve;
+    });
+  }
+  async write(data) {
+    self.postMessage(data);
+  }
+  destroy() {
+    self.postMessage(DESTROY_SIGNAL);
+    self.close();
+  }
+  signalDestroy() {
+    self.postMessage(DESTROY_SIGNAL);
+  }
+};
 
+// src/interface.ts
+var import_node_buffer = require("buffer");
 
-exports.WorkerChildIO = worker.WorkerChildIO;
-exports.WorkerParentIO = worker.WorkerParentIO;
-exports.RPCChannel = channel.RPCChannel;
-exports.generateUUID = utils.generateUUID;
-exports.deserializeMessage = serialization.deserializeMessage;
-exports.deserializeResponse = serialization.deserializeResponse;
-exports.serializeMessage = serialization.serializeMessage;
-exports.serializeResponse = serialization.serializeResponse;
-exports.IframeChildIO = iframe.IframeChildIO;
-exports.IframeParentIO = iframe.IframeParentIO;
+// src/serialization.ts
+function serializeMessage(message) {
+  return JSON.stringify(message) + "\n";
+}
+function deserializeMessage(message) {
+  return new Promise((resolve, reject) => {
+    try {
+      const parsed = JSON.parse(message);
+      resolve(parsed);
+    } catch (error) {
+      console.error("failed to parse message", typeof message, message, error);
+      reject(error);
+    }
+  });
+}
+function serializeResponse(response) {
+  return JSON.stringify(response) + "\n";
+}
+function deserializeResponse(response) {
+  return new Promise((resolve, reject) => {
+    try {
+      const parsed = JSON.parse(response);
+      resolve(parsed);
+    } catch (error) {
+      console.error("failed to parse response", response);
+      reject(error);
+    }
+  });
+}
+
+// src/utils.ts
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+// src/channel.ts
+var RPCChannel = class {
+  constructor(io, options) {
+    this.io = io;
+    this.apiImplementation = options?.expose;
+    this.listen();
+  }
+  pendingRequests = {};
+  callbacks = {};
+  callbackCache = /* @__PURE__ */ new Map();
+  count = 0;
+  messageStr = "";
+  apiImplementation;
+  expose(api) {
+    this.apiImplementation = api;
+  }
+  getIO() {
+    return this.io;
+  }
+  async listen() {
+    while (true) {
+      const buffer = await this.io.read();
+      if (!buffer) {
+        continue;
+      }
+      const bufferStr = buffer.toString("utf-8");
+      if (bufferStr.trim().length === 0) {
+        continue;
+      }
+      this.messageStr += bufferStr;
+      const lastChar = this.messageStr[this.messageStr.length - 1];
+      const msgsSplit = this.messageStr.split("\n");
+      const msgs = lastChar === "\n" ? msgsSplit : msgsSplit.slice(0, -1);
+      this.messageStr = lastChar === "\n" ? "" : msgsSplit.at(-1) ?? "";
+      for (const msgStr of msgs.map((msg) => msg.trim()).filter(Boolean)) {
+        this.handleMessageStr(msgStr);
+      }
+    }
+  }
+  async handleMessageStr(messageStr) {
+    this.count++;
+    const parsedMessage = await deserializeMessage(messageStr);
+    if (parsedMessage.type === "response") {
+      this.handleResponse(parsedMessage);
+    } else if (parsedMessage.type === "request") {
+      this.handleRequest(parsedMessage);
+    } else if (parsedMessage.type === "callback") {
+      this.handleCallback(parsedMessage);
+    } else {
+      console.error("received unknown message type", parsedMessage, typeof parsedMessage);
+    }
+  }
+  // Send a method call to the other process
+  callMethod(method, args) {
+    return new Promise((resolve, reject) => {
+      const messageId = generateUUID();
+      this.pendingRequests[messageId] = { resolve, reject };
+      const callbackIds = [];
+      const processedArgs = args.map((arg) => {
+        if (typeof arg === "function") {
+          let callbackId = this.callbackCache.get(arg);
+          if (!callbackId) {
+            callbackId = generateUUID();
+            this.callbacks[callbackId] = arg;
+            this.callbackCache.set(arg, callbackId);
+          } else {
+          }
+          callbackIds.push(callbackId);
+          return `__callback__${callbackId}`;
+        }
+        return arg;
+      });
+      const message = {
+        id: messageId,
+        method,
+        args: processedArgs,
+        type: "request",
+        callbackIds: callbackIds.length > 0 ? callbackIds : void 0
+      };
+      this.io.write(serializeMessage(message));
+    });
+  }
+  // Handle response to a request we sent
+  handleResponse(response) {
+    const { id } = response;
+    const { result, error } = response.args;
+    if (this.pendingRequests[id]) {
+      if (error) {
+        this.pendingRequests[id].reject(new Error(error));
+      } else {
+        this.pendingRequests[id].resolve(result);
+      }
+      delete this.pendingRequests[id];
+    }
+  }
+  // Handle incoming requests from the other process using a Proxy
+  handleRequest(request) {
+    const { id, method, args } = request;
+    const methodPath = method.split(".");
+    if (!this.apiImplementation) return;
+    let target = this.apiImplementation;
+    for (let i = 0; i < methodPath.length - 1; i++) {
+      target = target[methodPath[i]];
+      if (!target) {
+        this.sendError(id, `Method path ${method} not found at ${methodPath[i]}`);
+        return;
+      }
+    }
+    const finalMethod = methodPath[methodPath.length - 1];
+    const targetMethod = target[finalMethod];
+    if (typeof targetMethod !== "function") {
+      this.sendError(id, `Method ${method} is not a function`);
+      return;
+    }
+    const processedArgs = args.map((arg) => {
+      if (typeof arg === "string" && arg.startsWith("__callback__")) {
+        const callbackId = arg.slice(12);
+        return (...callbackArgs) => {
+          this.invokeCallback(callbackId, callbackArgs);
+        };
+      }
+      return arg;
+    });
+    try {
+      const result = targetMethod.apply(target, processedArgs);
+      Promise.resolve(result).then((res) => {
+        return this.sendResponse(id, res);
+      }).catch((err) => this.sendError(id, err.message));
+    } catch (error) {
+      this.sendError(id, error.message ?? error.toString());
+    }
+  }
+  invokeCallback(callbackId, args) {
+    const message = {
+      id: generateUUID(),
+      method: callbackId,
+      args,
+      type: "callback"
+    };
+    this.io.write(serializeMessage(message));
+  }
+  handleCallback(message) {
+    const { method: callbackId, args } = message;
+    const callback = this.callbacks[callbackId];
+    if (callback) {
+      callback(...args);
+    } else {
+      console.error(`Callback with id ${callbackId} not found`);
+    }
+  }
+  // Send a response to a request
+  sendResponse(id, result) {
+    const response = {
+      id,
+      method: "",
+      args: { result },
+      type: "response"
+    };
+    this.io.write(serializeMessage(response));
+  }
+  // Send an error response
+  sendError(id, error) {
+    const response = {
+      id,
+      method: "",
+      args: { error },
+      type: "response"
+    };
+    this.io.write(serializeMessage(response));
+  }
+  createNestedProxy(chain = []) {
+    return new Proxy(() => {
+    }, {
+      get: (_target, prop) => {
+        if (typeof prop === "string" && prop !== "then") {
+          return this.createNestedProxy([...chain, prop]);
+        }
+        return void 0;
+      },
+      apply: (_target, _thisArg, args) => {
+        const method = chain.join(".");
+        return this.callMethod(method, args);
+      }
+    });
+  }
+  getAPI() {
+    return this.createNestedProxy();
+  }
+  /**
+   * Free up the callback map and cache
+   * If you use callbacks a lot, you could get memory leak.
+   * e.g. If you use anonymous callback function in a 5000 iterations loop,
+   * you will get 5000 callbacks in cache. It's a better idea to free them.
+   *
+   * If you use a named callback function, there will be only one entry in the cache.
+   */
+  freeCallbacks() {
+    this.callbacks = {};
+    this.callbackCache.clear();
+  }
+};
+
+// src/adapters/iframe.ts
+var DESTROY_SIGNAL2 = "__DESTROY__";
+var PORT_INIT_SIGNAL = "__PORT_INIT__";
+var IframeParentIO = class {
+  /**
+   * @example
+   * ```ts
+   * const io = new IframeParentIO(iframeRef.contentWindow);
+   * const rpc = new RPCChannel(io, {
+   *   expose: {
+   *     add: (a: number, b: number) => Promise.resolve(a + b),
+   *   },
+   * });
+   * ```
+   */
+  constructor(targetWindow) {
+    this.targetWindow = targetWindow;
+    this.port = null;
+    window.addEventListener("message", (event) => {
+      if (event.source !== this.targetWindow) return;
+      if (event.data === PORT_INIT_SIGNAL && event.ports.length > 0) {
+        this.port = event.ports[0];
+        this.port.onmessage = this.handleMessage;
+        while (this.messageQueue.length > 0) {
+          const message = this.messageQueue.shift();
+          if (message) this.port.postMessage(message);
+        }
+      }
+    });
+  }
+  name = "iframe-parent-io";
+  messageQueue = [];
+  resolveRead = null;
+  port = null;
+  handleMessage = (event) => {
+    const message = event.data;
+    if (message === DESTROY_SIGNAL2) {
+      this.destroy();
+      return;
+    }
+    if (this.resolveRead) {
+      this.resolveRead(message);
+      this.resolveRead = null;
+    } else {
+      this.messageQueue.push(message);
+    }
+  };
+  async read() {
+    if (this.messageQueue.length > 0) {
+      return this.messageQueue.shift() ?? null;
+    }
+    return new Promise((resolve) => {
+      this.resolveRead = resolve;
+    });
+  }
+  async write(data) {
+    if (!this.port) {
+      this.messageQueue.push(data);
+      return;
+    }
+    this.port.postMessage(data);
+  }
+  destroy() {
+    if (this.port) {
+      this.port.postMessage(DESTROY_SIGNAL2);
+      this.port.close();
+    }
+  }
+  signalDestroy() {
+    if (this.port) {
+      this.port.postMessage(DESTROY_SIGNAL2);
+    }
+  }
+};
+var IframeChildIO = class {
+  name = "iframe-child-io";
+  messageQueue = [];
+  resolveRead = null;
+  port = null;
+  pendingMessages = [];
+  initialized;
+  channel;
+  constructor() {
+    this.channel = new MessageChannel();
+    this.port = this.channel.port1;
+    this.port.onmessage = this.handleMessage;
+    window.parent.postMessage(PORT_INIT_SIGNAL, "*", [this.channel.port2]);
+    this.initialized = Promise.resolve();
+  }
+  handleMessage = (event) => {
+    const message = event.data;
+    if (message === DESTROY_SIGNAL2) {
+      this.destroy();
+      return;
+    }
+    if (this.resolveRead) {
+      this.resolveRead(message);
+      this.resolveRead = null;
+    } else {
+      this.messageQueue.push(message);
+    }
+  };
+  async read() {
+    await this.initialized;
+    if (this.messageQueue.length > 0) {
+      return this.messageQueue.shift() ?? null;
+    }
+    return new Promise((resolve) => {
+      this.resolveRead = resolve;
+    });
+  }
+  async write(data) {
+    await this.initialized;
+    if (this.port) {
+      this.port.postMessage(data);
+    } else {
+      this.pendingMessages.push(data);
+    }
+  }
+  destroy() {
+    if (this.port) {
+      this.port.postMessage(DESTROY_SIGNAL2);
+      this.port.close();
+    }
+  }
+  signalDestroy() {
+    if (this.port) {
+      this.port.postMessage(DESTROY_SIGNAL2);
+    } else {
+      this.pendingMessages.push(DESTROY_SIGNAL2);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IframeChildIO,
+  IframeParentIO,
+  RPCChannel,
+  WorkerChildIO,
+  WorkerParentIO,
+  deserializeMessage,
+  deserializeResponse,
+  generateUUID,
+  serializeMessage,
+  serializeResponse
+});

package/dist/{src/adapters/iframe.d.ts → browser-mod.d.cts}

@@ -1,8 +1,13 @@
+export { M as Message, R as Response, a as WorkerChildIO, W as WorkerParentIO, d as deserializeMessage, c as deserializeResponse, g as generateUUID, s as serializeMessage, b as serializeResponse } from './serialization-BrfKixNU.cjs';
+import { D as DestroyableIoInterface } from './channel-CGr_xSbe.cjs';
+export { I as IoInterface, R as RPCChannel } from './channel-CGr_xSbe.cjs';
+import 'node:buffer';
+
 /**
  * This file contains the implementation of the IframeParentIO and IframeChildIO classes.
  * They are used to create a bidirectional communication channel between a parent window and a child iframe.
  */
-import type { DestroyableIoInterface } from "../interface.ts";
+
 /**
  * This design relies on built-in `MessageChannel`, and requires a pairing process to establish the port.
  * The `PORT_INIT_SIGNAL` is designed to be initiated by the child frame, parent window will wait for the signal and establish the port.
@@ -15,7 +20,7 @@ import type { DestroyableIoInterface } from "../interface.ts";
  *
  * It's a good practice to call `destroy()` on either side of the channel to close `MessageChannel` and release resources.
  */
-export declare class IframeParentIO implements DestroyableIoInterface {
+declare class IframeParentIO implements DestroyableIoInterface {
     private targetWindow;
     name: string;
     private messageQueue;
@@ -39,7 +44,7 @@ export declare class IframeParentIO implements DestroyableIoInterface {
     destroy(): void;
     signalDestroy(): void;
 }
-export declare class IframeChildIO implements DestroyableIoInterface {
+declare class IframeChildIO implements DestroyableIoInterface {
     name: string;
     private messageQueue;
     private resolveRead;
@@ -54,4 +59,5 @@ export declare class IframeChildIO implements DestroyableIoInterface {
     destroy(): void;
     signalDestroy(): void;
 }
-//# sourceMappingURL=iframe.d.ts.map
+
+export { DestroyableIoInterface, IframeChildIO, IframeParentIO };

package/dist/browser-mod.d.ts

@@ -1,7 +1,63 @@
-export * from "./src/adapters/worker.ts";
-export * from "./src/interface.ts";
-export * from "./src/channel.ts";
-export * from "./src/utils.ts";
-export * from "./src/serialization.ts";
-export * from "./src/adapters/iframe.ts";
-//# sourceMappingURL=browser-mod.d.ts.map
+export { M as Message, R as Response, a as WorkerChildIO, W as WorkerParentIO, d as deserializeMessage, c as deserializeResponse, g as generateUUID, s as serializeMessage, b as serializeResponse } from './serialization-C0yxGsSr.js';
+import { D as DestroyableIoInterface } from './channel-CGr_xSbe.js';
+export { I as IoInterface, R as RPCChannel } from './channel-CGr_xSbe.js';
+import 'node:buffer';
+
+/**
+ * This file contains the implementation of the IframeParentIO and IframeChildIO classes.
+ * They are used to create a bidirectional communication channel between a parent window and a child iframe.
+ */
+
+/**
+ * This design relies on built-in `MessageChannel`, and requires a pairing process to establish the port.
+ * The `PORT_INIT_SIGNAL` is designed to be initiated by the child frame, parent window will wait for the signal and establish the port.
+ *
+ * If `PORT_INIT_SIGNAL` is started by the parent window, there has to be a delay (with `setTimeout`) to wait for the child frame to listen to the signal.
+ * Parent window can easily listen to iframe onload event, but there is no way to know when child JS is ready to listen to the message without
+ * letting child `postMessage` a signal first.
+ *
+ * It's much easier to make sure parent window is ready (listening) before iframe is loaded, so `MessageChannel` is designed to be created from iframe's side.
+ *
+ * It's a good practice to call `destroy()` on either side of the channel to close `MessageChannel` and release resources.
+ */
+declare class IframeParentIO implements DestroyableIoInterface {
+    private targetWindow;
+    name: string;
+    private messageQueue;
+    private resolveRead;
+    private port;
+    /**
+     * @example
+     * ```ts
+     * const io = new IframeParentIO(iframeRef.contentWindow);
+     * const rpc = new RPCChannel(io, {
+     *   expose: {
+     *     add: (a: number, b: number) => Promise.resolve(a + b),
+     *   },
+     * });
+     * ```
+     */
+    constructor(targetWindow: Window);
+    private handleMessage;
+    read(): Promise<string | null>;
+    write(data: string): Promise<void>;
+    destroy(): void;
+    signalDestroy(): void;
+}
+declare class IframeChildIO implements DestroyableIoInterface {
+    name: string;
+    private messageQueue;
+    private resolveRead;
+    private port;
+    private pendingMessages;
+    private initialized;
+    private channel;
+    constructor();
+    private handleMessage;
+    read(): Promise<string | null>;
+    write(data: string): Promise<void>;
+    destroy(): void;
+    signalDestroy(): void;
+}
+
+export { DestroyableIoInterface, IframeChildIO, IframeParentIO };