fix handshake reply

Author: anulman

src/guest.ts

@@ -14,16 +14,16 @@ function connect(schema: Schema = {}, eventHandlers?: EventHandlers): Promise<Co
       if (eventData?.action !== actions.HANDSHAKE_REPLY) return;
 
       // register local methods
-      const unregisterLocal = registerLocalMethods(schema, localMethods, eventData.connectionID, listenTo, sendTo);
+      const unregisterLocal = registerLocalMethods(localMethods, eventData.connectionID, listenTo, sendTo);
 
       // register remote methods
       const { remote, unregisterRemote } = registerRemoteMethods(
         eventData.schema,
-        eventData.methods,
+        eventData.methodNames,
         eventData.connectionID,
         event,
         listenTo,
-        sendTo,
+        sendTo
       );
 
       await eventHandlers?.onConnectionSetup?.(remote);
@@ -53,8 +53,8 @@ function connect(schema: Schema = {}, eventHandlers?: EventHandlers): Promise<Co
 
     const payload = {
       action: actions.HANDSHAKE_REQUEST,
-      methods: localMethods,
-      schema: JSON.parse(JSON.stringify(schema)),
+      methodNames: Object.keys(localMethods),
+      schema: schema,
     };
 
     postMessageToTarget(sendTo, payload);

src/helpers.ts

@@ -34,19 +34,20 @@ export function isIframe() {
  * @param obj
  */
 export function extractMethods(obj: any) {
-  const paths: string[] = [];
+  const methods: Record<string, (...args: any) => any> = {};
   (function parse(obj: any, path = "") {
     Object.keys(obj).forEach((prop) => {
       const propPath = path ? `${path}.${prop}` : prop;
       if (obj[prop] === Object(obj[prop])) {
         parse(obj[prop], propPath);
       }
       if (typeof obj[prop] === "function") {
-        paths.push(propPath);
+        methods[propPath] = obj[prop];
+        delete obj[prop];
       }
     });
   })(obj);
-  return paths;
+  return methods;
 }
 
 const urlRegex = /^(https?:|file:)?\/\/([^/:]+)?(:(\d+))?/;

src/host.ts

@@ -66,24 +66,24 @@ function connect(guest: Guest, schema: Schema = {}): Promise<Connection> {
 
       // register local methods
       const localMethods = extractMethods(schema);
-      const unregisterLocal = registerLocalMethods(schema, localMethods, connectionID, listenTo, sendTo);
+      const unregisterLocal = registerLocalMethods(localMethods, connectionID, listenTo, sendTo);
 
       // register remote methods
       const { remote, unregisterRemote } = registerRemoteMethods(
         eventData.schema,
-        eventData.methods,
+        eventData.methodNames,
         connectionID,
         event,
         listenTo,
-        sendTo,
+        sendTo
       );
 
       // send a HANDSHAKE REPLY to the guest
       const payload = {
         action: actions.HANDSHAKE_REPLY,
         connectionID,
-        schema,
-        methods: localMethods,
+        schema: schema,
+        methodNames: Object.keys(localMethods),
       };
 
       postMessageToTarget(sendTo, payload, event.origin);

src/rpc.ts

@@ -1,12 +1,4 @@
-import {
-  addEventListener,
-  generateId,
-  get,
-  getEventData,
-  postMessageToTarget,
-  removeEventListener,
-  set,
-} from "./helpers";
+import { addEventListener, generateId, getEventData, postMessageToTarget, removeEventListener, set } from "./helpers";
 import {
   actions,
   Environment,
@@ -19,24 +11,22 @@ import {
 } from "./types";
 
 /**
- * for each function in the schema
+ * for each function in methods
  * 1. subscribe to an event that the remote can call
  * 2. listen for calls from the remote. When called execute the function and emit the results.
  *
- * @param methods an array of method ids from the local schema
+ * @param methods an object of method ids : methods from the local schema
  * @param rpcConnectionID
  * @return a function to cancel all subscriptions
  */
 export function registerLocalMethods(
-  schema: Schema = {},
-  methods: string[] = [],
+  methods: Record<string, (...args: any[]) => any> = {},
   rpcConnectionID: string,
   listenTo: Environment,
-  sendTo: Target,
+  sendTo: Target
 ) {
   const listeners: any[] = [];
-
-  methods.forEach((methodName) => {
+  for (const [methodName, method] of Object.entries(methods)) {
     // handle a remote calling a local method
     async function handleCall(event: any) {
       const eventData = getEventData(event);
@@ -58,7 +48,7 @@ export function registerLocalMethods(
 
       // run function and return the results to the remote
       try {
-        const result = await get(schema, methodName)(...args);
+        const result = await method(...args);
 
         if (!result) {
           // if the result is falsy (null, undefined, "", etc), set it directly
@@ -78,7 +68,7 @@ export function registerLocalMethods(
     // subscribe to the call event
     addEventListener(listenTo, events.MESSAGE, handleCall);
     listeners.push(() => removeEventListener(listenTo, events.MESSAGE, handleCall));
-  });
+  }
 
   return () => listeners.forEach((unregister) => unregister());
 }
@@ -101,7 +91,7 @@ export function createRPC(
   event: RimlessEvent,
   listeners: Array<() => void> = [],
   listenTo: Environment,
-  sendTo: Target,
+  sendTo: Target
 ) {
   return (...args: any) => {
     return new Promise((resolve, reject) => {
@@ -140,7 +130,7 @@ export function createRPC(
 }
 
 /**
- * create an object based on the remote schema and methods. Functions in that object will
+ * create an object based on the remote schema's methods. Functions in that object will
  * emit an event that will trigger the RPC on the remote.
  *
  * @param schema
@@ -151,19 +141,19 @@ export function createRPC(
  */
 export function registerRemoteMethods(
   schema: Schema = {},
-  methods: string[] = [],
+  methodNames: Iterable<string> = [],
   connectionID: string,
   event: RimlessEvent,
   listenTo: Environment,
-  sendTo: Target,
+  sendTo: Target
 ) {
   const remote = { ...schema };
   const listeners: Array<() => void> = [];
 
-  methods.forEach((methodName) => {
+  for (const methodName of methodNames) {
     const rpc = createRPC(methodName, connectionID, event, listeners, listenTo, sendTo);
     set(remote, methodName, rpc);
-  });
+  }
 
   return {
     remote,

src/types.ts

@@ -38,14 +38,14 @@ export interface RimlessEvent extends EventListener {
 export interface HandshakeRequestPayload {
   action: actions.HANDSHAKE_REQUEST;
   connectionID: string;
-  methods: string[];
+  methodNames: string[];
   schema: Schema;
 }
 
 export interface HandshakeConfirmationPayload {
   action: actions.HANDSHAKE_REPLY;
   connectionID: string;
-  methods: string[];
+  methodNames: string[];
   schema: Schema;
 }