@marianmeres/webrtc 1.0.3 → 1.1.1

package/API.md

@@ -759,6 +759,13 @@ interface WebRtcManagerConfig {
   /** Initial reconnection delay in ms (doubles each attempt). Default: 1000 */
   reconnectDelay?: number;
 
+  /** Callback to control whether reconnection should proceed */
+  shouldReconnect?: (context: {
+    attempt: number;
+    maxAttempts: number;
+    strategy: "ice-restart" | "full";
+  }) => boolean;
+
   /** Enable debug logging. Default: false */
   debug?: boolean;
 
@@ -947,3 +954,31 @@ manager.on('reconnecting', ({ attempt, strategy }) => {
   }
 });
 ```
+
+### Conditional Reconnection
+
+Use the `shouldReconnect` callback to suppress reconnection when the peer disconnected intentionally:
+
+```typescript
+let peerLeftIntentionally = false;
+
+const manager = new WebRtcManager(factory, {
+  autoReconnect: true,
+  shouldReconnect: ({ attempt, maxAttempts, strategy }) => {
+    // Return false to suppress reconnection
+    return !peerLeftIntentionally;
+  },
+});
+
+// Track intentional disconnects via data channel
+manager.on('data_channel_message', ({ data }) => {
+  if (JSON.parse(data).type === 'bye') {
+    peerLeftIntentionally = true;
+  }
+});
+```
+
+The callback receives:
+- `attempt`: Current attempt number (1-based)
+- `maxAttempts`: Configured maximum attempts
+- `strategy`: `"ice-restart"` or `"full"`

package/README.md

@@ -51,6 +51,7 @@ const manager = new WebRtcManager(factory, config);
 - `autoReconnect`: Enable automatic reconnection (default: false)
 - `maxReconnectAttempts`: Max reconnection attempts (default: 5)
 - `reconnectDelay`: Initial reconnection delay in ms (default: 1000)
+- `shouldReconnect`: Callback to control whether reconnection should proceed (see below)
 - `debug`: Enable debug logging (default: false)
 - `logger`: Custom logger instance implementing `Logger` interface (default: console)
 
@@ -129,6 +130,37 @@ const unsub = manager.subscribe((state) => {
 - `EVENT_MICROPHONE_FAILED`
 - `EVENT_ERROR`
 
+### Controlling Reconnection
+
+When `autoReconnect` is enabled, you can use the `shouldReconnect` callback to conditionally suppress reconnection attempts. This is useful when the remote peer disconnected intentionally (e.g., left the call) rather than due to network failure.
+
+```typescript
+let peerLeftIntentionally = false;
+
+const manager = new WebRtcManager(factory, {
+  autoReconnect: true,
+  shouldReconnect: ({ attempt, maxAttempts, strategy }) => {
+    if (peerLeftIntentionally) {
+      return false; // Don't reconnect
+    }
+    return true;
+  },
+});
+
+// Listen for "goodbye" message from peer before they disconnect
+manager.on(WebRtcManager.EVENT_DATA_CHANNEL_MESSAGE, ({ data }) => {
+  const msg = JSON.parse(data);
+  if (msg.type === 'bye') {
+    peerLeftIntentionally = true;
+  }
+});
+```
+
+The callback receives:
+- `attempt`: Current reconnection attempt (1-based)
+- `maxAttempts`: Configured maximum attempts
+- `strategy`: `"ice-restart"` (attempts 1-2) or `"full"` (attempts 3+)
+
 ## Examples
 
 ### Basic Usage (Vanilla JavaScript)

package/dist/types.d.ts

@@ -26,6 +26,20 @@ export interface WebRtcManagerConfig {
     maxReconnectAttempts?: number;
     /** Initial reconnection delay in ms. Doubles with each attempt. Defaults to 1000. */
     reconnectDelay?: number;
+    /**
+     * Callback to determine whether reconnection should be attempted.
+     * Called before each reconnection attempt when autoReconnect is enabled.
+     * Return false to suppress reconnection (e.g., when peer disconnected intentionally).
+     * If not provided, reconnection proceeds automatically up to maxReconnectAttempts.
+     */
+    shouldReconnect?: (context: {
+        /** Current reconnection attempt number (1-based) */
+        attempt: number;
+        /** Maximum configured reconnection attempts */
+        maxAttempts: number;
+        /** Strategy that will be used: "ice-restart" for first attempts, "full" for later */
+        strategy: "ice-restart" | "full";
+    }) => boolean;
     /** Enable debug logging. Defaults to false. */
     debug?: boolean;
     /** Custom logger instance. If not provided, falls back to console. */

package/dist/webrtc-manager.js

@@ -800,6 +800,21 @@ export class WebRtcManager {
             });
             return;
         }
+        // Determine strategy for this attempt (next attempt number is current + 1)
+        const nextAttempt = this.#reconnectAttempts + 1;
+        const strategy = nextAttempt <= 2 ? "ice-restart" : "full";
+        // Check shouldReconnect callback if provided
+        if (this.#config.shouldReconnect) {
+            const shouldProceed = this.#config.shouldReconnect?.({
+                attempt: nextAttempt,
+                maxAttempts,
+                strategy,
+            });
+            if (!shouldProceed) {
+                this.#debug("Reconnection suppressed by shouldReconnect callback");
+                return;
+            }
+        }
         // Transition to RECONNECTING state
         this.#dispatch(WebRtcFsmEvent.RECONNECTING);
         // Attempt reconnection with exponential backoff
@@ -838,6 +853,9 @@ export class WebRtcManager {
                 // perform the signaling handshake (create offer/answer exchange) to
                 // complete the reconnection.
                 try {
+                    // Clean up old connection and reset to IDLE so connect() creates a new PC
+                    this.#cleanup();
+                    this.#dispatch(WebRtcFsmEvent.RESET);
                     await this.connect();
                     // If successful, onconnectionstatechange will reset attempts
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@marianmeres/webrtc",
-	"version": "1.0.3",
+	"version": "1.1.1",
 	"type": "module",
 	"main": "dist/mod.js",
 	"types": "dist/mod.d.ts",