@calimero-network/mero-js 25.3.2 → 25.3.3

package/dist/events/sse.d.ts

@@ -91,6 +91,14 @@ export declare class SseClient {
     onMigrationEvent(handler: (e: GroupMigrationEventData) => void): () => void;
     private emit;
     connect(): Promise<void>;
+    /**
+     * Whether `controller`'s connection is no longer the one this client holds:
+     * closed, or replaced by a later connect. Its abort lands asynchronously,
+     * after a `close()` + `connect()` has already cleared `closed`, so `closed`
+     * alone cannot tell; reporting it, and reconnecting for it, would abort the
+     * live connection, whose own abort would do the same, without end.
+     */
+    private superseded;
     private readStream;
     private handleMessage;
     subscribe(idsOrOpts: string[] | {

package/dist/events/sse.js

@@ -142,7 +142,8 @@ export class SseClient {
             return;
         }
         this.closed = false;
-        this.abortController = new AbortController();
+        const controller = new AbortController();
+        this.abortController = controller;
         try {
             const url = `${this.baseUrl}/sse`;
             const headers = {
@@ -152,7 +153,7 @@ export class SseClient {
             const proofAttached = carriesProof(headers);
             const response = await this.fetchImpl(url, {
                 headers,
-                signal: this.abortController.signal,
+                signal: controller.signal,
                 ...(proofAttached && { redirect: 'manual' }),
             });
             if (proofAttached)
@@ -174,8 +175,8 @@ export class SseClient {
             if (!response.body) {
                 throw new Error('SSE response has no body');
             }
-            this.readStream(response.body).catch((err) => {
-                if (this.closed)
+            this.readStream(response.body, controller).catch((err) => {
+                if (this.superseded(controller))
                     return;
                 const error = err instanceof Error ? err : new Error(String(err));
                 this.emit('error', error);
@@ -183,7 +184,7 @@ export class SseClient {
             });
         }
         catch (err) {
-            if (this.closed)
+            if (this.superseded(controller))
                 return;
             const error = err instanceof Error ? err : new Error(String(err));
             this.emit('error', error);
@@ -195,7 +196,17 @@ export class SseClient {
             this.scheduleReconnect();
         }
     }
-    async readStream(body) {
+    /**
+     * Whether `controller`'s connection is no longer the one this client holds:
+     * closed, or replaced by a later connect. Its abort lands asynchronously,
+     * after a `close()` + `connect()` has already cleared `closed`, so `closed`
+     * alone cannot tell; reporting it, and reconnecting for it, would abort the
+     * live connection, whose own abort would do the same, without end.
+     */
+    superseded(controller) {
+        return this.closed || controller.signal.aborted || this.abortController !== controller;
+    }
+    async readStream(body, controller) {
         const reader = body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
@@ -227,13 +238,13 @@ export class SseClient {
             }
         }
         catch (err) {
-            if (this.closed)
+            if (this.superseded(controller))
                 return;
             const error = err instanceof Error ? err : new Error(String(err));
             this.emit('error', error);
         }
         // Stream ended, reconnect
-        if (!this.closed) {
+        if (!this.superseded(controller)) {
             this.scheduleReconnect();
         }
     }