@portal-hq/connect 0.3.1 → 0.3.3

package/lib/commonjs/index.js

@@ -11,6 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 class PortalConnect {
     constructor({ portal, websocketServer = 'connect.portalhq.io', }) {
+        this.connected = false;
+        this.events = {};
         this.portal = portal;
         this.websocketServer = websocketServer;
     }
@@ -25,10 +27,93 @@ class PortalConnect {
             if (this.socket) {
                 this.socket.close();
             }
-            this.socket = new WebSocket(`wss://${this.websocketServer}`);
+            const protocol = this.websocketServer.startsWith('localhost') ? 'ws' : 'wss';
+            // @ts-ignore
+            this.socket = new WebSocket(`${protocol}://${this.websocketServer}/`, null, 
+            // @ts-ignore
+            {
+                headers: {
+                    Authorization: `Bearer ${this.portal.apiKey}`,
+                },
+            });
             this.bindToSocketEvents(this.socket, uri);
         });
     }
+    /**
+     * Invokes all registered event handlers with the data provided
+     * - If any `once` handlers exist, they are removed after all handlers are invoked
+     *
+     * @param event The name of the event to be handled
+     * @param data The data to be passed to registered event handlers
+     * @returns BaseProvider
+     */
+    emit(event, data) {
+        // Grab the registered event handlers if any are available
+        const handlers = this.events[event] || [];
+        // Execute every event handler
+        for (const registeredEventHandler of handlers) {
+            registeredEventHandler.handler(data);
+        }
+        // Remove any registered event handlers with the `once` flag
+        this.events[event] = handlers.filter((handler) => !handler.once);
+        return this;
+    }
+    /**
+     * Registers an event handler for the provided event
+     *
+     * @param event The event name to add a handler to
+     * @param callback The callback to be invoked when the event is emitted
+     * @returns BaseProvider
+     */
+    on(event, callback) {
+        // If no handlers are registered for this event, create an entry for the event
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        // Register event handler with the rudimentary event bus
+        if (typeof callback !== 'undefined') {
+            this.events[event].push({
+                handler: callback,
+                once: false,
+            });
+        }
+        return this;
+    }
+    /**
+     * Registers a single-execution event handler for the provided event
+     *
+     * @param event The event name to add a handler to
+     * @param callback The callback to be invoked the next time the event is emitted
+     * @returns BaseProvider
+     */
+    once(event, callback) {
+        // If no handlers are registered for this event, create an entry for the event
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        // Register event handler with the rudimentary event bus
+        if (typeof callback !== 'undefined') {
+            this.events[event].push({
+                handler: callback,
+                once: true,
+            });
+        }
+        return this;
+    }
+    removeEventListener(event, listenerToRemove) {
+        if (!this.events[event]) {
+            return;
+        }
+        if (!listenerToRemove) {
+            this.events[event] = [];
+        }
+        else {
+            const filterEventHandlers = (registeredEventHandler) => {
+                return registeredEventHandler.handler !== listenerToRemove;
+            };
+            this.events[event] = this.events[event].filter(filterEventHandlers);
+        }
+    }
     /**
      * Adds event bindings to a websocket connection
      * - on open, a `connect` event is dispatched via the socket to establish a bridge connection
@@ -72,6 +157,17 @@ class PortalConnect {
                         console.warn(`PortalConnect could not establish a connection to the relay.`);
                         return;
                     }
+                    this.connected = true;
+                    this.emit('connect', {
+                        uri,
+                    });
+                    break;
+                case 'disconnect':
+                    socket.close();
+                    this.connected = false;
+                    this.emit('disconnect', {
+                        uri,
+                    });
                     break;
                 case 'session_request':
                     const { id, params, topic } = message.data;

package/lib/esm/index.js

@@ -9,6 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 class PortalConnect {
     constructor({ portal, websocketServer = 'connect.portalhq.io', }) {
+        this.connected = false;
+        this.events = {};
         this.portal = portal;
         this.websocketServer = websocketServer;
     }
@@ -23,10 +25,93 @@ class PortalConnect {
             if (this.socket) {
                 this.socket.close();
             }
-            this.socket = new WebSocket(`wss://${this.websocketServer}`);
+            const protocol = this.websocketServer.startsWith('localhost') ? 'ws' : 'wss';
+            // @ts-ignore
+            this.socket = new WebSocket(`${protocol}://${this.websocketServer}/`, null, 
+            // @ts-ignore
+            {
+                headers: {
+                    Authorization: `Bearer ${this.portal.apiKey}`,
+                },
+            });
             this.bindToSocketEvents(this.socket, uri);
         });
     }
+    /**
+     * Invokes all registered event handlers with the data provided
+     * - If any `once` handlers exist, they are removed after all handlers are invoked
+     *
+     * @param event The name of the event to be handled
+     * @param data The data to be passed to registered event handlers
+     * @returns BaseProvider
+     */
+    emit(event, data) {
+        // Grab the registered event handlers if any are available
+        const handlers = this.events[event] || [];
+        // Execute every event handler
+        for (const registeredEventHandler of handlers) {
+            registeredEventHandler.handler(data);
+        }
+        // Remove any registered event handlers with the `once` flag
+        this.events[event] = handlers.filter((handler) => !handler.once);
+        return this;
+    }
+    /**
+     * Registers an event handler for the provided event
+     *
+     * @param event The event name to add a handler to
+     * @param callback The callback to be invoked when the event is emitted
+     * @returns BaseProvider
+     */
+    on(event, callback) {
+        // If no handlers are registered for this event, create an entry for the event
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        // Register event handler with the rudimentary event bus
+        if (typeof callback !== 'undefined') {
+            this.events[event].push({
+                handler: callback,
+                once: false,
+            });
+        }
+        return this;
+    }
+    /**
+     * Registers a single-execution event handler for the provided event
+     *
+     * @param event The event name to add a handler to
+     * @param callback The callback to be invoked the next time the event is emitted
+     * @returns BaseProvider
+     */
+    once(event, callback) {
+        // If no handlers are registered for this event, create an entry for the event
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        // Register event handler with the rudimentary event bus
+        if (typeof callback !== 'undefined') {
+            this.events[event].push({
+                handler: callback,
+                once: true,
+            });
+        }
+        return this;
+    }
+    removeEventListener(event, listenerToRemove) {
+        if (!this.events[event]) {
+            return;
+        }
+        if (!listenerToRemove) {
+            this.events[event] = [];
+        }
+        else {
+            const filterEventHandlers = (registeredEventHandler) => {
+                return registeredEventHandler.handler !== listenerToRemove;
+            };
+            this.events[event] = this.events[event].filter(filterEventHandlers);
+        }
+    }
     /**
      * Adds event bindings to a websocket connection
      * - on open, a `connect` event is dispatched via the socket to establish a bridge connection
@@ -70,6 +155,17 @@ class PortalConnect {
                         console.warn(`PortalConnect could not establish a connection to the relay.`);
                         return;
                     }
+                    this.connected = true;
+                    this.emit('connect', {
+                        uri,
+                    });
+                    break;
+                case 'disconnect':
+                    socket.close();
+                    this.connected = false;
+                    this.emit('disconnect', {
+                        uri,
+                    });
                     break;
                 case 'session_request':
                     const { id, params, topic } = message.data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portal-hq/connect",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
   "source": "src/index",
@@ -21,6 +21,7 @@
   "devDependencies": {
     "@babel/preset-typescript": "^7.18.6",
     "@types/jest": "^29.2.0",
+    "@types/ws": "^8.5.4",
     "jest": "^29.2.1",
     "jest-environment-jsdom": "^29.2.2",
     "ts-jest": "^29.0.3",

package/src/index.ts

@@ -1,20 +1,27 @@
 import Portal from '@portal-hq/core'
 import type {
   ConnectResult,
+  EventHandler,
   PortalConnectOptions,
+  RegisteredEventHandler,
   SessionRequest,
   WebsocketMessage,
-} from '../types'
+} from '../types.d'
 
 class PortalConnect {
+  public connected: boolean
   public portal: Portal
   public socket?: WebSocket
   public websocketServer: string
 
+  private events: Record<string, RegisteredEventHandler[]>
+
   constructor({
     portal,
     websocketServer = 'connect.portalhq.io',
   }: PortalConnectOptions) {
+    this.connected = false
+    this.events = {}
     this.portal = portal
     this.websocketServer = websocketServer
   }
@@ -30,10 +37,113 @@ class PortalConnect {
       this.socket.close()
     }
 
-    this.socket = new WebSocket(`wss://${this.websocketServer}`)
+    const protocol = this.websocketServer.startsWith('localhost') ? 'ws' : 'wss'
+    // @ts-ignore
+    this.socket = new WebSocket(
+      `${protocol}://${this.websocketServer}/`,
+      null,
+      // @ts-ignore
+      {
+        headers: {
+          Authorization: `Bearer ${this.portal.apiKey}`,
+        },
+      },
+    )
     this.bindToSocketEvents(this.socket, uri)
   }
 
+  /**
+   * Invokes all registered event handlers with the data provided
+   * - If any `once` handlers exist, they are removed after all handlers are invoked
+   *
+   * @param event The name of the event to be handled
+   * @param data The data to be passed to registered event handlers
+   * @returns BaseProvider
+   */
+  public emit(event: string, data: any): PortalConnect {
+    // Grab the registered event handlers if any are available
+    const handlers = this.events[event] || []
+
+    // Execute every event handler
+    for (const registeredEventHandler of handlers) {
+      registeredEventHandler.handler(data)
+    }
+
+    // Remove any registered event handlers with the `once` flag
+    this.events[event] = handlers.filter((handler) => !handler.once)
+
+    return this
+  }
+
+  /**
+   * Registers an event handler for the provided event
+   *
+   * @param event The event name to add a handler to
+   * @param callback The callback to be invoked when the event is emitted
+   * @returns BaseProvider
+   */
+  public on(event: string, callback: EventHandler): PortalConnect {
+    // If no handlers are registered for this event, create an entry for the event
+    if (!this.events[event]) {
+      this.events[event] = []
+    }
+
+    // Register event handler with the rudimentary event bus
+    if (typeof callback !== 'undefined') {
+      this.events[event].push({
+        handler: callback,
+        once: false,
+      })
+    }
+
+    return this
+  }
+
+  /**
+   * Registers a single-execution event handler for the provided event
+   *
+   * @param event The event name to add a handler to
+   * @param callback The callback to be invoked the next time the event is emitted
+   * @returns BaseProvider
+   */
+  public once(event: string, callback: EventHandler): PortalConnect {
+    // If no handlers are registered for this event, create an entry for the event
+    if (!this.events[event]) {
+      this.events[event] = []
+    }
+
+    // Register event handler with the rudimentary event bus
+    if (typeof callback !== 'undefined') {
+      this.events[event].push({
+        handler: callback,
+        once: true,
+      })
+    }
+
+    return this
+  }
+
+  public removeEventListener(
+    event: string,
+    listenerToRemove?: EventHandler,
+  ): void {
+    if (!this.events[event]) {
+      return
+    }
+
+    if (!listenerToRemove) {
+      this.events[event] = []
+    } else {
+      const filterEventHandlers = (
+        registeredEventHandler: RegisteredEventHandler,
+      ) => {
+        return registeredEventHandler.handler !== listenerToRemove
+      }
+
+      this.events[event] = this.events[event].filter(filterEventHandlers)
+    }
+  }
+
   /**
    * Adds event bindings to a websocket connection
    * - on open, a `connect` event is dispatched via the socket to establish a bridge connection
@@ -68,7 +178,7 @@ class PortalConnect {
      * @param messageEvent
      * @returns
      */
-    socket.onmessage = async (messageEvent: MessageEvent) => {
+    socket.onmessage = async (messageEvent: WebSocketMessageEvent) => {
       const message = JSON.parse(messageEvent.data) as WebsocketMessage
 
       switch (message.event) {
@@ -84,6 +194,19 @@ class PortalConnect {
             )
             return
           }
+
+          this.connected = true
+          this.emit('connect', {
+            uri,
+          })
+          break
+        case 'disconnect':
+          socket.close()
+          this.connected = false
+          this.emit('disconnect', {
+            uri,
+          })
+
           break
         case 'session_request':
           const { id, params, topic } = message.data as SessionRequest

package/types.d.ts

@@ -1,6 +1,8 @@
 import Portal from '@portal-hq/core'
 
-interface ConnectResult {
+export type EventHandler = (data: any) => void
+
+export interface ConnectResult {
   active: boolean
   expiry: number
   peerMetadata: PeerMetadata
@@ -8,40 +10,50 @@ interface ConnectResult {
   topic: string
 }
 
-interface PeerMetadata {
+export interface DisconnectResult {
+  id: number
+  topic: string
+}
+
+export interface PeerMetadata {
   name: string
   description: string
   url: string
   icons: string[]
 }
 
-interface PortalConnectOptions {
+export interface PortalConnectOptions {
   portal: Portal
   websocketServer?: string
 }
 
-interface ProtocolOptions {
+export interface ProtocolOptions {
   protocol: string
   data?: string
 }
 
-interface ProviderRequestPayload {
+export interface ProviderRequestPayload {
   chainId: string
   request: ProviderRequestData
 }
 
-interface ProviderRequestData {
+export interface ProviderRequestData {
   method: string
   params: any
 }
 
-interface SessionRequest {
+export interface RegisteredEventHandler {
+  handler: EventHandler
+  once?: boolean
+}
+
+export interface SessionRequest {
   id: string
   params: ProviderRequestPayload
   topic: string
 }
 
-interface WebsocketMessage {
+export interface WebsocketMessage {
   event: string
-  data: ConnectResult | SessionRequest
+  data: ConnectResult | DisconnectResult | SessionRequest
 }