@whitewall/blip-sdk 0.0.180 → 0.0.181

package/src/sender/websocket/websocketsender.ts

@@ -39,7 +39,7 @@ export class WebSocketSender extends OpenConnectionSender {
                     authentication: options.authentication,
                 })
             },
-            () => this.envelopeResolver.rejectPendingEnvelopes('Connection was closed'),
+            () => this.rejectPending('Connection was closed'),
             (envelope: Envelope) => {
                 if (this.sessionNegotiator?.negotiating) {
                     return this.sessionNegotiator.handleEnvelope(envelope)
@@ -139,7 +139,10 @@ class WebSocketHandle<T> {
     }
 
     public get() {
-        return this.currentWebSocketPromise!
+        if (!this.currentWebSocketPromise) {
+            throw new Error('WebSocket connection is not available.')
+        }
+        return this.currentWebSocketPromise
     }
 
     public async close() {
@@ -159,31 +162,54 @@ class WebSocketHandle<T> {
         const connection = new WebSocket(url, 'lime')
 
         await new Promise<void>((resolve, reject) => {
+            let connected = false
+
             connection.onopen = () => {
+                connected = true
                 resolve()
             }
+            connection.onerror = (err) => {
+                if (!connected) {
+                    reject('message' in err ? new Error(`WebSocket error: ${err.message}`, { cause: err }) : err)
+                }
+                // Post-open errors are followed by 'close', which drives reconnect.
+            }
             connection.onclose = () => {
                 if (!this.closing) {
-                    this.connectionAttempts++
-
-                    if (this.connectionAttempts < 3) {
-                        this.currentWebSocketPromise = this.connect(url, onConnected, onClose, onMessage)
-                    } else {
-                        reject(new Error('Failed to connect to WebSocket'))
-                    }
+                    if (connected) onClose()
 
-                    onClose()
+                    this.connectionAttempts++
+                    // Swallow the rejection of the now-orphaned previous promise; any
+                    // in-flight get() awaiter still sees it via their captured reference.
+                    const previous = this.currentWebSocketPromise
+                    this.currentWebSocketPromise =
+                        this.connectionAttempts < 3 ? this.connect(url, onConnected, onClose, onMessage) : null
+                    previous?.catch(() => undefined)
                 }
+
+                if (!connected) reject(new Error('WebSocket closed before open'))
             }
             connection.onmessage = (event) => {
                 onMessage(JSON.parse(event.data))
             }
-            connection.onerror = (err) => {
-                reject('message' in err ? new Error(`WebSocket error: ${err.message}`, { cause: err }) : err)
-            }
         })
 
-        await onConnected(connection)
+        try {
+            await onConnected(connection)
+        } catch (err) {
+            // Handshake failures leave the socket open otherwise; tear it down so
+            // the 'onclose' handler drives reconnect. Prefer ws.terminate() (hard
+            // kill, Node only) to avoid waiting on the graceful close handshake
+            // with a peer that just failed to negotiate; fall back to close() in
+            // browsers where terminate() doesn't exist.
+            const terminable = connection as WebSocket & { terminate?: () => void }
+            if (terminable.terminate) {
+                terminable.terminate()
+            } else {
+                connection.close()
+            }
+            throw err
+        }
         this.connectionAttempts = 0
 
         return connection