kkrpc 0.0.9 → 0.0.10

package/dist/__tests__/bun.worker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bun.worker.test.d.ts.map

package/dist/__tests__/bun.worker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.worker.test.d.ts","sourceRoot":"","sources":["../../__tests__/bun.worker.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/http.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=http.test.d.ts.map

package/dist/__tests__/http.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.test.d.ts","sourceRoot":"","sources":["../../__tests__/http.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/scripts/api.d.ts

@@ -0,0 +1,19 @@
+export interface API {
+    echo(message: string): Promise<string>;
+    add(a: number, b: number): Promise<number>;
+    subtract(a: number, b: number): Promise<number>;
+    addCallback(a: number, b: number, callback: (result: number) => void): void;
+    math: {
+        grade1: {
+            add(a: number, b: number, callback?: (result: number) => void): Promise<number>;
+        };
+        grade2: {
+            multiply(a: number, b: number, callback?: (result: number) => void): Promise<number>;
+        };
+        grade3: {
+            divide(a: number, b: number, callback?: (result: number) => void): Promise<number>;
+        };
+    };
+}
+export declare const apiMethods: API;
+//# sourceMappingURL=api.d.ts.map

package/dist/__tests__/scripts/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../__tests__/scripts/api.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,GAAG;IACnB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACtC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC/C,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAA;IAC3E,IAAI,EAAE;QACL,MAAM,EAAE;YACP,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;SAC/E,CAAA;QACD,MAAM,EAAE;YACP,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;SACpF,CAAA;QACD,MAAM,EAAE;YACP,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;SAClF,CAAA;KACD,CAAA;CACD;AAGD,eAAO,MAAM,UAAU,EAAE,GA2BxB,CAAA"}

package/dist/__tests__/scripts/deno-api.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deno-api.d.ts.map

package/dist/__tests__/scripts/deno-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno-api.d.ts","sourceRoot":"","sources":["../../../__tests__/scripts/deno-api.ts"],"names":[],"mappings":""}

package/dist/__tests__/scripts/node-api.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=node-api.d.ts.map

package/dist/__tests__/scripts/node-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-api.d.ts","sourceRoot":"","sources":["../../../__tests__/scripts/node-api.ts"],"names":[],"mappings":""}

package/dist/__tests__/scripts/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/__tests__/scripts/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../__tests__/scripts/worker.ts"],"names":[],"mappings":""}

package/dist/__tests__/serialization.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serialization.test.d.ts.map

package/dist/__tests__/serialization.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.test.d.ts","sourceRoot":"","sources":["../../__tests__/serialization.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/stdio-rpc.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stdio-rpc.test.d.ts.map

package/dist/__tests__/stdio-rpc.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-rpc.test.d.ts","sourceRoot":"","sources":["../../__tests__/stdio-rpc.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/websocket.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=websocket.test.d.ts.map

package/dist/__tests__/websocket.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.test.d.ts","sourceRoot":"","sources":["../../__tests__/websocket.test.ts"],"names":[],"mappings":""}

package/dist/adapters/deno.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var node_buffer = require('node:buffer');
+
+/**
+ * Stdio implementation for Deno
+ * Deno doesn't have `process` object, and have a completely different stdio API,
+ * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
+ */
+class DenoIo {
+    readStream;
+    writeStream;
+    reader;
+    name = "deno-io";
+    constructor(readStream, writeStream) {
+        this.readStream = readStream;
+        this.writeStream = writeStream;
+        this.reader = this.readStream.getReader();
+        // const writer = this.writeStream.getWriter()
+        // const encoder = new TextEncoder()
+        // writer.write(encoder.encode("hello"))
+    }
+    async read() {
+        const { value, done } = await this.reader.read();
+        if (done) {
+            return null; // End of input
+        }
+        return node_buffer.Buffer.from(value);
+    }
+    write(data) {
+        const encoder = new TextEncoder();
+        const encodedData = encoder.encode(data + "\n");
+        Deno.stdout.writeSync(encodedData);
+        return Promise.resolve();
+    }
+}
+
+exports.DenoIo = DenoIo;

package/dist/adapters/deno.js

@@ -0,0 +1,36 @@
+import { Buffer } from 'node:buffer';
+
+/**
+ * Stdio implementation for Deno
+ * Deno doesn't have `process` object, and have a completely different stdio API,
+ * This implementation wrap Deno's `Deno.stdin` and `Deno.stdout` to follow StdioInterface
+ */
+class DenoIo {
+    readStream;
+    writeStream;
+    reader;
+    name = "deno-io";
+    constructor(readStream, writeStream) {
+        this.readStream = readStream;
+        this.writeStream = writeStream;
+        this.reader = this.readStream.getReader();
+        // const writer = this.writeStream.getWriter()
+        // const encoder = new TextEncoder()
+        // writer.write(encoder.encode("hello"))
+    }
+    async read() {
+        const { value, done } = await this.reader.read();
+        if (done) {
+            return null; // End of input
+        }
+        return Buffer.from(value);
+    }
+    write(data) {
+        const encoder = new TextEncoder();
+        const encodedData = encoder.encode(data + "\n");
+        Deno.stdout.writeSync(encodedData);
+        return Promise.resolve();
+    }
+}
+
+export { DenoIo };

package/dist/adapters/http.cjs

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * HTTP Client implementation of IoInterface
+ */
+class HTTPClientIO {
+    options;
+    name = "http-client-io";
+    messageQueue = [];
+    resolveRead = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async read() {
+        if (this.messageQueue.length > 0) {
+            return this.messageQueue.shift() ?? null;
+        }
+        return new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+    }
+    async write(data) {
+        try {
+            const response = await fetch(this.options.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.options.headers
+                },
+                body: data
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const responseText = await response.text();
+            if (this.resolveRead) {
+                this.resolveRead(responseText);
+                this.resolveRead = null;
+            }
+            else {
+                this.messageQueue.push(responseText);
+            }
+        }
+        catch (error) {
+            console.error("HTTP request failed:", error);
+            if (this.resolveRead) {
+                this.resolveRead(null);
+                this.resolveRead = null;
+            }
+        }
+    }
+}
+/**
+ * HTTP Server implementation of IoInterface
+ */
+class HTTPServerIO {
+    name = "http-server-io";
+    messageQueue = [];
+    resolveRead = null;
+    pendingResponses = new Map();
+    constructor() { }
+    async read() {
+        if (this.messageQueue.length > 0) {
+            return this.messageQueue.shift() ?? null;
+        }
+        return new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+    }
+    async write(data) {
+        // Parse the response to get the request ID
+        const response = JSON.parse(data);
+        const requestId = response.id;
+        const resolveResponse = this.pendingResponses.get(requestId);
+        if (resolveResponse) {
+            resolveResponse(data);
+            this.pendingResponses.delete(requestId);
+        }
+    }
+    async handleRequest(reqData) {
+        try {
+            // Parse the request to get its ID
+            const requestData = JSON.parse(reqData);
+            const requestId = requestData.id;
+            if (this.resolveRead) {
+                this.resolveRead(reqData);
+                this.resolveRead = null;
+            }
+            else {
+                this.messageQueue.push(reqData);
+            }
+            return new Promise((resolve) => {
+                this.pendingResponses.set(requestId, resolve);
+            });
+        }
+        catch (error) {
+            console.error("RPC processing error:", error);
+            throw new Error("Internal server error");
+        }
+    }
+}
+
+exports.HTTPClientIO = HTTPClientIO;
+exports.HTTPServerIO = HTTPServerIO;

package/dist/adapters/http.js

@@ -0,0 +1,101 @@
+/**
+ * HTTP Client implementation of IoInterface
+ */
+class HTTPClientIO {
+    options;
+    name = "http-client-io";
+    messageQueue = [];
+    resolveRead = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async read() {
+        if (this.messageQueue.length > 0) {
+            return this.messageQueue.shift() ?? null;
+        }
+        return new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+    }
+    async write(data) {
+        try {
+            const response = await fetch(this.options.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.options.headers
+                },
+                body: data
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const responseText = await response.text();
+            if (this.resolveRead) {
+                this.resolveRead(responseText);
+                this.resolveRead = null;
+            }
+            else {
+                this.messageQueue.push(responseText);
+            }
+        }
+        catch (error) {
+            console.error("HTTP request failed:", error);
+            if (this.resolveRead) {
+                this.resolveRead(null);
+                this.resolveRead = null;
+            }
+        }
+    }
+}
+/**
+ * HTTP Server implementation of IoInterface
+ */
+class HTTPServerIO {
+    name = "http-server-io";
+    messageQueue = [];
+    resolveRead = null;
+    pendingResponses = new Map();
+    constructor() { }
+    async read() {
+        if (this.messageQueue.length > 0) {
+            return this.messageQueue.shift() ?? null;
+        }
+        return new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+    }
+    async write(data) {
+        // Parse the response to get the request ID
+        const response = JSON.parse(data);
+        const requestId = response.id;
+        const resolveResponse = this.pendingResponses.get(requestId);
+        if (resolveResponse) {
+            resolveResponse(data);
+            this.pendingResponses.delete(requestId);
+        }
+    }
+    async handleRequest(reqData) {
+        try {
+            // Parse the request to get its ID
+            const requestData = JSON.parse(reqData);
+            const requestId = requestData.id;
+            if (this.resolveRead) {
+                this.resolveRead(reqData);
+                this.resolveRead = null;
+            }
+            else {
+                this.messageQueue.push(reqData);
+            }
+            return new Promise((resolve) => {
+                this.pendingResponses.set(requestId, resolve);
+            });
+        }
+        catch (error) {
+            console.error("RPC processing error:", error);
+            throw new Error("Internal server error");
+        }
+    }
+}
+
+export { HTTPClientIO, HTTPServerIO };

package/dist/adapters/iframe.cjs

@@ -0,0 +1,163 @@
+'use strict';
+
+const DESTROY_SIGNAL = "__DESTROY__";
+const PORT_INIT_SIGNAL = "__PORT_INIT__";
+/**
+ * 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.
+ */
+class IframeParentIO {
+    targetWindow;
+    name = "iframe-parent-io";
+    messageQueue = [];
+    resolveRead = null;
+    port = null;
+    /**
+     * @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);
+                }
+            }
+        });
+    }
+    handleMessage = (event) => {
+        const message = event.data;
+        // Handle destroy signal
+        if (message === DESTROY_SIGNAL) {
+            this.destroy();
+            return;
+        }
+        if (this.resolveRead) {
+            // If there's a pending read, resolve it immediately
+            this.resolveRead(message);
+            this.resolveRead = null;
+        }
+        else {
+            // Otherwise, queue the message
+            this.messageQueue.push(message);
+        }
+    };
+    async read() {
+        // If there are queued messages, return the first one
+        if (this.messageQueue.length > 0) {
+            return this.messageQueue.shift() ?? null;
+        }
+        // Otherwise, wait for the next message
+        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_SIGNAL);
+            this.port.close();
+        }
+    }
+    signalDestroy() {
+        if (this.port) {
+            this.port.postMessage(DESTROY_SIGNAL);
+        }
+    }
+}
+// Child frame version
+class IframeChildIO {
+    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;
+        // Handle destroy signal
+        if (message === DESTROY_SIGNAL) {
+            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_SIGNAL);
+            this.port.close();
+        }
+    }
+    signalDestroy() {
+        if (this.port) {
+            this.port.postMessage(DESTROY_SIGNAL);
+        }
+        else {
+            this.pendingMessages.push(DESTROY_SIGNAL);
+        }
+    }
+}
+
+exports.IframeChildIO = IframeChildIO;
+exports.IframeParentIO = IframeParentIO;

package/dist/adapters/iframe.js

@@ -0,0 +1,160 @@
+const DESTROY_SIGNAL = "__DESTROY__";
+const PORT_INIT_SIGNAL = "__PORT_INIT__";
+/**
+ * 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.
+ */
+class IframeParentIO {
+    targetWindow;
+    name = "iframe-parent-io";
+    messageQueue = [];
+    resolveRead = null;
+    port = null;
+    /**
+     * @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);
+                }
+            }
+        });
+    }
+    handleMessage = (event) => {
+        const message = event.data;
+        // Handle destroy signal
+        if (message === DESTROY_SIGNAL) {
+            this.destroy();
+            return;
+        }
+        if (this.resolveRead) {
+            // If there's a pending read, resolve it immediately
+            this.resolveRead(message);
+            this.resolveRead = null;
+        }
+        else {
+            // Otherwise, queue the message
+            this.messageQueue.push(message);
+        }
+    };
+    async read() {
+        // If there are queued messages, return the first one
+        if (this.messageQueue.length > 0) {
+            return this.messageQueue.shift() ?? null;
+        }
+        // Otherwise, wait for the next message
+        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_SIGNAL);
+            this.port.close();
+        }
+    }
+    signalDestroy() {
+        if (this.port) {
+            this.port.postMessage(DESTROY_SIGNAL);
+        }
+    }
+}
+// Child frame version
+class IframeChildIO {
+    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;
+        // Handle destroy signal
+        if (message === DESTROY_SIGNAL) {
+            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_SIGNAL);
+            this.port.close();
+        }
+    }
+    signalDestroy() {
+        if (this.port) {
+            this.port.postMessage(DESTROY_SIGNAL);
+        }
+        else {
+            this.pendingMessages.push(DESTROY_SIGNAL);
+        }
+    }
+}
+
+export { IframeChildIO, IframeParentIO };