socket-function 0.7.12 → 0.7.13

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.7.12",
+	"version": "0.7.13",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.ts

@@ -83,10 +83,10 @@ export interface SenderInterface {
 
     send(data: string | Buffer): void;
 
-    on(event: "open", listener: () => void): this;
-    on(event: "close", listener: (code: number, reason: Buffer) => void): this;
-    on(event: "error", listener: (err: Error) => void): this;
-    on(event: "message", listener: (data: ws.RawData, isBinary: boolean) => void): this;
+    addEventListener(event: "open", listener: () => void): void;
+    addEventListener(event: "close", listener: () => void): void;
+    addEventListener(event: "error", listener: (err: { message: string }) => void): void;
+    addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
 }
 
 async function createCallFactory(
@@ -205,20 +205,20 @@ async function createCallFactory(
                 let port = ports[reconnectAttempts % ports.length];
                 let newWebSocket = createWebsocket(location.address, port);
 
-                setupWebsocket(newWebSocket);
-
                 let connectError = await new Promise<string | undefined>(resolve => {
-                    newWebSocket.on("open", () => {
+                    newWebSocket.addEventListener("open", () => {
                         resolve(undefined);
                     });
-                    newWebSocket.on("close", () => {
+                    newWebSocket.addEventListener("close", () => {
                         resolve("Connection closed for non-error reason?");
                     });
-                    newWebSocket.on("error", e => {
-                        resolve(String(e.stack));
+                    newWebSocket.addEventListener("error", e => {
+                        resolve(String(e.message));
                     });
                 });
 
+                setupWebsocket(newWebSocket);
+
                 if (!connectError) {
                     console.log(`Reconnected to ${location.address}:${port}`);
 
@@ -266,22 +266,22 @@ async function createCallFactory(
     }
 
     function setupWebsocket(webSocket: SenderInterface) {
-        webSocket.on("error", e => {
+        webSocket.addEventListener("error", e => {
             console.log(`Websocket error for ${niceConnectionName}`, e);
         });
 
-        webSocket.on("close", async () => {
+        webSocket.addEventListener("close", async () => {
             console.log(`Websocket closed ${niceConnectionName}`);
             if (retriesEnabled) {
                 await tryToReconnect();
             }
         });
 
-        webSocket.on("message", onMessage);
+        webSocket.addEventListener("message", onMessage);
     }
 
 
-    async function onMessage(message: ws.RawData | MessageEvent | string) {
+    async function onMessage(message: ws.RawData | ws.MessageEvent | string) {
         try {
             if (!isNode()) {
                 if (typeof message === "object" && "data" in message) {

package/src/nodeAuthentication.ts

@@ -90,14 +90,7 @@ export function createWebsocket(address: string, port: number): SenderInterface
         // NOTE: We assume an HTTP request has already been made, which will setup a nodeId cookie
         //  (And as this point we can't even use peer certificates if we wanted to, as this must be done
         //      directly in the browser)
-        let webSocket = new WebSocket(`wss://${address}:${port}`);
-        return Object.assign(webSocket, {
-            on(event: string, callback: any) {
-                // TODO: Use better type safety here
-                (webSocket as any)["on" + event] = callback;
-                return this as any;
-            },
-        });
+        return new WebSocket(`wss://${address}:${port}`);
     } else {
         let { key, cert } = getCertKeyPair();
         return new ws.WebSocket(`wss://${address}:${port}`, {