From d88d19882dddbdc86733b9b10cde4ce40ca5b440 Mon Sep 17 00:00:00 2001
From: "@anulman" <anulman@gmail.com>
Date: Fri, 30 May 2025 03:20:18 -0400
Subject: [PATCH] add support for sharedworker

---
 src/guest.ts | 12 ++++++------
 src/host.ts  |  8 +++++---
 src/types.ts |  9 +++++----
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/guest.ts b/src/guest.ts
index c87ea3c..d8b7c6a 100644
--- a/src/guest.ts
+++ b/src/guest.ts
@@ -7,13 +7,13 @@ import {
   removeEventListener,
 } from "./helpers";
 import { registerLocalMethods, registerRemoteMethods } from "./rpc";
-import { actions, EventHandlers, events, Connection, Schema } from "./types";
+import { actions, GuestConnectOptions, events, Connection, Schema } from "./types";
 
-function connect(schema: Schema = {}, eventHandlers?: EventHandlers): Promise<Connection> {
+function connect(schema: Schema = {}, options?: GuestConnectOptions): Promise<Connection> {
   return new Promise(async (resolve) => {
     const localMethods = extractMethods(schema);
-    const sendTo = getTargetHost();
-    const listenTo = self || window;
+    const sendTo = options?.hostTarget ?? getTargetHost();
+    const listenTo = options?.hostTarget ?? (self || window);
 
     // on handshake response
     async function handleHandshakeResponse(event: any) {
@@ -27,13 +27,13 @@ function connect(schema: Schema = {}, eventHandlers?: EventHandlers): Promise<Co
         eventData.connectionID,
         event,
         listenTo,
-        sendTo,
+        sendTo
       );
 
       // register local methods, passing the remote object
       const unregisterLocal = registerLocalMethods(localMethods, eventData.connectionID, listenTo, sendTo, remote);
 
-      await eventHandlers?.onConnectionSetup?.(remote);
+      await options?.onConnectionSetup?.(remote);
 
       // send a HANDSHAKE REPLY to the host
       const payload = {
diff --git a/src/host.ts b/src/host.ts
index 2b6f880..0d4bd23 100644
--- a/src/host.ts
+++ b/src/host.ts
@@ -49,14 +49,16 @@ function connect(guest: Guest, schema: Schema = {}): Promise<Connection> {
 
   const guestIsWorker = isWorkerLike(guest);
 
-  const listenTo = guestIsWorker || isNodeEnv() ? (guest as Worker) : window;
+  const listenTo =
+    guestIsWorker || isNodeEnv() ? (guest as Worker) : guest instanceof SharedWorker ? guest.port : window;
 
   return new Promise((resolve) => {
     const connectionID = generateId();
 
     // on handshake request
     function handleHandshake(event: any) {
-      const sendTo = guestIsWorker || isNodeEnv() ? (guest as Worker) : event.source;
+      const sendTo =
+        guestIsWorker || isNodeEnv() ? (guest as Worker) : guest instanceof SharedWorker ? guest.port : event.source;
 
       if (!guestIsWorker && !isNodeEnv() && !isValidTarget(guest, event)) return;
 
@@ -74,7 +76,7 @@ function connect(guest: Guest, schema: Schema = {}): Promise<Connection> {
         connectionID,
         event,
         listenTo,
-        sendTo,
+        sendTo
       );
 
       // Now register local methods, passing the remote object
diff --git a/src/types.ts b/src/types.ts
index 9d328b0..35dab62 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -66,10 +66,11 @@ export interface RPCResolvePayload {
   connectionID: string;
 }
 
-export interface EventHandlers {
+export type GuestConnectOptions = {
+  hostTarget?: Target;
   onConnectionSetup: (remote: Schema) => Promise<void>;
-}
+};
 
 export type Guest = WorkerLike | HTMLIFrameElement;
-export type Target = Window | WorkerLike;
-export type Environment = Window | WorkerLike;
+export type Target = Window | WorkerLike | MessagePort;
+export type Environment = Window | WorkerLike | MessagePort;