bunite-core 0.0.11 → 0.0.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "type": "module",
   "scripts": {
     "setup:cef": "bun ../tools/bunite-dev/scripts/setup-cef.ts",

package/src/bun/core/BrowserView.ts

@@ -2,7 +2,7 @@ import { ptr } from "bun:ffi";
 import { buildViewPreloadScript } from "../preload/inline";
 import { log } from "../../shared/log";
 import { buniteEventEmitter } from "../events/eventEmitter";
-import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport, type RPCRequestHandler } from "../../shared/rpc";
+import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport } from "../../shared/rpc";
 import { createWebRPCHandler } from "../../shared/webRpcHandler";
 import { ensureNativeRuntime, getNativeLibrary, toCString, waitForViewReady, cancelWaitForViewReady } from "../proc/native";
 import { attachBrowserViewRegistry, getRPCPort, sendMessageToView } from "./Socket";
@@ -165,8 +165,11 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
     config: BuniteRPCConfig<Schema, "bun">
   ) {
     const rpc = defineBuniteRPC("bun", config);
+    const webRpc = createWebRPCHandler<Schema>(config);
     return Object.assign(rpc, {
-      webHandler: createWebRPCHandler((config.handlers.requests ?? {}) as any)
+      webHandler: webRpc,
+      webClients: webRpc.webClients,
+      broadcast: webRpc.broadcast,
     });
   }
 

package/src/shared/rpc.ts

@@ -80,6 +80,8 @@ export type BuniteRPCSchema = {
   webview: RPCSchema;
 };
 
+type RemoteSideOf<S extends "bun" | "webview"> = S extends "bun" ? "webview" : "bun";
+
 export type BuniteRPCConfig<
   Schema extends BuniteRPCSchema,
   Side extends "bun" | "webview"
@@ -88,13 +90,13 @@ export type BuniteRPCConfig<
   handlers: {
     requests?: RPCRequestHandler<Schema[Side]["requests"]>;
     messages?: {
-      [K in keyof Schema[Side]["messages"]]?: (
-        payload: MessagePayload<Schema[Side]["messages"], K>
+      [K in keyof Schema[RemoteSideOf<Side>]["messages"]]?: (
+        payload: MessagePayload<Schema[RemoteSideOf<Side>]["messages"], K>
       ) => void;
     } & {
       "*"?: (
-        messageName: keyof Schema[Side]["messages"],
-        payload: MessagePayload<Schema[Side]["messages"], keyof Schema[Side]["messages"]>
+        messageName: keyof Schema[RemoteSideOf<Side>]["messages"],
+        payload: MessagePayload<Schema[RemoteSideOf<Side>]["messages"], keyof Schema[RemoteSideOf<Side>]["messages"]>
       ) => void;
     };
   };

package/src/shared/webRpcHandler.ts

@@ -1,48 +1,92 @@
+import {
+  defineBuniteRPC,
+  type BuniteRPCConfig,
+  type BuniteRPCSchema,
+  type RPCTransport,
+  type RPCPacket
+} from "./rpc";
 import { decodeRPCPacket, encodeRPCPacket, asUint8Array } from "./rpcWire";
 
-type WebRPCHandlers = Record<string, (params?: unknown) => unknown>;
+type WebRPCSocket = { send(data: Uint8Array | ArrayBuffer): void | number };
 
-/** Minimal ws interface compatible with Bun's ServerWebSocket. */
-type WebRPCSocket = { send(data: Uint8Array): void | number };
+export type WebRPCClient<Schema extends BuniteRPCSchema = BuniteRPCSchema> = {
+  ws: WebRPCSocket;
+  rpc: ReturnType<typeof defineBuniteRPC<Schema, "bun">>;
+  handlePacket: (packet: RPCPacket) => void | Promise<void>;
+};
 
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
+export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
+  config: BuniteRPCConfig<Schema, "bun"> & {
+    extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
+  }
+) {
+  const connections = new WeakMap<WebRPCSocket, WebRPCClient<Schema>>();
+  const webClients = new Set<WebRPCClient<Schema>>();
+
+  const handler = {
+    open(ws: WebRPCSocket) {
+      let handlePacket: ((packet: RPCPacket) => void | Promise<void>) | undefined;
+
+      const transport: RPCTransport = {
+        send(packet) {
+          ws.send(encodeRPCPacket(packet));
+        },
+        registerHandler(h) {
+          handlePacket = h;
+        },
+        unregisterHandler() {
+          handlePacket = undefined;
+        }
+      };
+
+      const rpc = defineBuniteRPC("bun", config);
+      rpc.setTransport(transport);
+
+      const client: WebRPCClient<Schema> = {
+        ws,
+        rpc: rpc as WebRPCClient<Schema>["rpc"],
+        handlePacket: (packet) => handlePacket?.(packet)
+      };
+
+      connections.set(ws, client);
+      webClients.add(client);
+      handler.onWebClientConnected?.(client);
+    },
 
-export function createWebRPCHandler(handlers: WebRPCHandlers) {
-  return {
-    message(ws: WebRPCSocket, raw: string | Buffer) {
+    message(ws: WebRPCSocket, raw: string | Buffer | ArrayBuffer | Uint8Array) {
       if (typeof raw === "string") return;
 
-      let packet;
+      const client = connections.get(ws);
+      if (!client) return;
+
       try {
-        packet = decodeRPCPacket(asUint8Array(raw));
+        client.handlePacket(decodeRPCPacket(asUint8Array(raw)));
       } catch {
-        return;
+        // malformed packet
       }
+    },
 
-      if (packet.type !== "request" || typeof packet.method !== "string") return;
+    close(ws: WebRPCSocket) {
+      const client = connections.get(ws);
+      if (!client) return;
 
-      const handler = handlers[packet.method];
-      if (!handler) {
-        ws.send(
-          encodeRPCPacket({ type: "response", id: packet.id, success: false, error: `Unknown method: ${packet.method}` })
-        );
-        return;
-      }
+      webClients.delete(client);
+      handler.onWebClientDisconnected?.(client);
+      client.rpc.setTransport({});
+      connections.delete(ws);
+    },
 
-      try {
-        Promise.resolve(handler(packet.params)).then(
-          (payload) =>
-            ws.send(encodeRPCPacket({ type: "response", id: packet.id, success: true, payload })),
-          (error) =>
-            ws.send(encodeRPCPacket({ type: "response", id: packet.id, success: false, error: errorMessage(error) }))
-        );
-      } catch (error) {
-        ws.send(
-          encodeRPCPacket({ type: "response", id: packet.id, success: false, error: errorMessage(error) })
-        );
+    webClients: webClients as ReadonlySet<WebRPCClient<Schema>>,
+
+    broadcast(messageName: string, payload?: unknown) {
+      for (const client of webClients) {
+        (client.rpc.send as any)(messageName, payload);
       }
-    }
+    },
+
+    onWebClientConnected: undefined as ((client: WebRPCClient<Schema>) => void) | undefined,
+    onWebClientDisconnected: undefined as ((client: WebRPCClient<Schema>) => void) | undefined,
   };
+
+  return handler;
 }