livekit-client 1.15.9 → 1.15.11

package/dist/livekit-client.esm.mjs

@@ -10614,7 +10614,7 @@ function getMatch(exp, ua) {
   return match && match.length >= id && match[id] || '';
 }
 
-var version$1 = "1.15.9";
+var version$1 = "1.15.11";
 
 const version = version$1;
 const protocolVersion = 11;
@@ -14938,7 +14938,7 @@ class SignalClient {
         abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
         this.log.debug("connecting to ".concat(url + params), this.logContext);
         if (this.ws) {
-          yield this.close();
+          yield this.close(false);
         }
         this.ws = new WebSocket(url + params);
         this.ws.binaryType = 'arraybuffer';
@@ -15005,7 +15005,7 @@ class SignalClient {
                 shouldProcessMessage = true;
               }
             } else if (this.isEstablishingConnection && resp.message.case === 'leave') {
-              reject(new ConnectionError('Received leave request while trying to (re)connect'));
+              reject(new ConnectionError('Received leave request while trying to (re)connect', 4 /* ConnectionErrorReason.LeaveRequest */));
             } else if (!opts.reconnect) {
               // non-reconnect case, should receive join response first
               reject(new ConnectionError("did not receive join response, got ".concat((_d = resp.message) === null || _d === void 0 ? void 0 : _d.case, " instead")));
@@ -15035,10 +15035,13 @@ class SignalClient {
     }));
   }
   close() {
+    let updateState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.closingLock.lock();
       try {
-        this.state = SignalConnectionState.DISCONNECTING;
+        if (updateState) {
+          this.state = SignalConnectionState.DISCONNECTING;
+        }
         if (this.ws) {
           this.ws.onmessage = null;
           this.ws.onopen = null;
@@ -15061,7 +15064,9 @@ class SignalClient {
           this.ws = undefined;
         }
       } finally {
-        this.state = SignalConnectionState.DISCONNECTED;
+        if (updateState) {
+          this.state = SignalConnectionState.DISCONNECTED;
+        }
         this.clearPingInterval();
         unlock();
       }
@@ -17781,6 +17786,9 @@ class RTCEngine extends eventsExports.EventEmitter {
         if (error instanceof ConnectionError && error.reason === 0 /* ConnectionErrorReason.NotAllowed */) {
           throw new UnexpectedConnectionState('could not reconnect, token might be expired');
         }
+        if (error instanceof ConnectionError && error.reason === 4 /* ConnectionErrorReason.LeaveRequest */) {
+          throw error;
+        }
         throw new SignalReconnectError(message);
       }
       this.emit(EngineEvent.SignalResumed);
@@ -21758,6 +21766,7 @@ class Room extends eventsExports.EventEmitter {
     this.audioEnabled = true;
     this.isVideoPlaybackBlocked = false;
     this.log = livekitLogger;
+    this.bufferedEvents = [];
     this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       var _c;
       // In case a disconnect called happened right before the connect call, make sure the disconnect is completed first by awaiting its lock
@@ -22034,10 +22043,15 @@ class Room extends eventsExports.EventEmitter {
             }
             // set the srcObject to null on page hide in order to prevent lock screen controls to show up for it
             dummyAudioEl.srcObject = document.hidden ? null : stream;
+            if (!document.hidden) {
+              this.log.debug('page visible again, triggering startAudio to resume playback and update playback status', this.logContext);
+              this.startAudio();
+            }
           });
           document.body.append(dummyAudioEl);
           this.once(RoomEvent.Disconnected, () => {
             dummyAudioEl === null || dummyAudioEl === void 0 ? void 0 : dummyAudioEl.remove();
+            dummyAudioEl = null;
           });
         }
         elements.push(dummyAudioEl);
@@ -22098,7 +22112,7 @@ class Room extends eventsExports.EventEmitter {
       this.log.debug("signal reconnected to server, region ".concat(joinResponse.serverRegion), Object.assign(Object.assign({}, this.logContext), {
         region: joinResponse.serverRegion
       }));
-      this.cachedParticipantSids = [];
+      this.bufferedEvents = [];
       this.applyJoinResponse(joinResponse);
       try {
         // unpublish & republish tracks
@@ -22120,10 +22134,7 @@ class Room extends eventsExports.EventEmitter {
       this.setAndEmitConnectionState(ConnectionState.Connected);
       this.emit(RoomEvent.Reconnected);
       this.registerConnectionReconcile();
-      // emit participant connected events after connection has been re-established
-      this.participants.forEach(participant => {
-        this.emit(RoomEvent.ParticipantConnected, participant);
-      });
+      this.emitBufferedEvents();
     });
     this.handleParticipantUpdates = participantInfos => {
       // handle changes to participant state, and send events
@@ -22352,7 +22363,6 @@ class Room extends eventsExports.EventEmitter {
     };
     this.setMaxListeners(100);
     this.participants = new Map();
-    this.cachedParticipantSids = [];
     this.identityToSid = new Map();
     this.options = Object.assign(Object.assign({}, roomOptionDefaults), options);
     this.log = getLogger((_a = this.options.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Room);
@@ -22455,17 +22465,14 @@ class Room extends eventsExports.EventEmitter {
       if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
         this.emit(RoomEvent.Reconnecting);
       }
-      this.cachedParticipantSids = Array.from(this.participants.keys());
     }).on(EngineEvent.Resumed, () => {
       this.setAndEmitConnectionState(ConnectionState.Connected);
       this.emit(RoomEvent.Reconnected);
       this.registerConnectionReconcile();
       this.updateSubscriptions();
-      // once reconnected, figure out if any participants connected during reconnect and emit events for it
-      const diffParticipants = Array.from(this.participants.values()).filter(p => !this.cachedParticipantSids.includes(p.sid));
-      diffParticipants.forEach(p => this.emit(RoomEvent.ParticipantConnected, p));
-      this.cachedParticipantSids = [];
+      this.emitBufferedEvents();
     }).on(EngineEvent.SignalResumed, () => {
+      this.bufferedEvents = [];
       if (this.state === ConnectionState.Reconnecting) {
         this.sendSyncState();
       }
@@ -22774,6 +22781,7 @@ class Room extends eventsExports.EventEmitter {
     // clear out existing remote participants, since they may have attached
     // the old engine
     this.participants.clear();
+    this.bufferedEvents = [];
     this.maybeCreateEngine();
   }
   onTrackAdded(mediaTrack, stream, receiver) {
@@ -22832,6 +22840,7 @@ class Room extends eventsExports.EventEmitter {
     let reason = arguments.length > 1 ? arguments[1] : undefined;
     var _a;
     this.clearConnectionReconcile();
+    this.bufferedEvents = [];
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
@@ -23056,12 +23065,22 @@ class Room extends eventsExports.EventEmitter {
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
     return true;
   }
+  emitBufferedEvents() {
+    this.bufferedEvents.forEach(_ref2 => {
+      let [ev, args] = _ref2;
+      this.emit(ev, ...args);
+    });
+    this.bufferedEvents = [];
+  }
   emitWhenConnected(event) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
     if (this.state === ConnectionState.Connected) {
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
-      }
       return this.emit(event, ...args);
+    } else if (this.state === ConnectionState.Reconnecting) {
+      // in case the room is reconnecting, buffer the events by firing them later after emitting RoomEvent.Reconnected
+      this.bufferedEvents.push([event, args]);
     }
     return false;
   }