livekit-client 1.4.4 → 1.5.0

package/dist/livekit-client.esm.mjs

@@ -12428,7 +12428,8 @@ function createBaseUpdateTrackSettings() {
     disabled: false,
     quality: 0,
     width: 0,
-    height: 0
+    height: 0,
+    fps: 0
   };
 }
 
@@ -12456,6 +12457,10 @@ const UpdateTrackSettings = {
       writer.uint32(48).uint32(message.height);
     }
 
+    if (message.fps !== 0) {
+      writer.uint32(56).uint32(message.fps);
+    }
+
     return writer;
   },
 
@@ -12488,6 +12493,10 @@ const UpdateTrackSettings = {
           message.height = reader.uint32();
           break;
 
+        case 7:
+          message.fps = reader.uint32();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -12503,7 +12512,8 @@ const UpdateTrackSettings = {
       disabled: isSet(object.disabled) ? Boolean(object.disabled) : false,
       quality: isSet(object.quality) ? videoQualityFromJSON(object.quality) : 0,
       width: isSet(object.width) ? Number(object.width) : 0,
-      height: isSet(object.height) ? Number(object.height) : 0
+      height: isSet(object.height) ? Number(object.height) : 0,
+      fps: isSet(object.fps) ? Number(object.fps) : 0
     };
   },
 
@@ -12520,11 +12530,12 @@ const UpdateTrackSettings = {
     message.quality !== undefined && (obj.quality = videoQualityToJSON(message.quality));
     message.width !== undefined && (obj.width = Math.round(message.width));
     message.height !== undefined && (obj.height = Math.round(message.height));
+    message.fps !== undefined && (obj.fps = Math.round(message.fps));
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
 
     const message = createBaseUpdateTrackSettings();
     message.trackSids = ((_a = object.trackSids) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
@@ -12532,6 +12543,7 @@ const UpdateTrackSettings = {
     message.quality = (_c = object.quality) !== null && _c !== void 0 ? _c : 0;
     message.width = (_d = object.width) !== null && _d !== void 0 ? _d : 0;
     message.height = (_e = object.height) !== null && _e !== void 0 ? _e : 0;
+    message.fps = (_f = object.fps) !== null && _f !== void 0 ? _f : 0;
     return message;
   }
 
@@ -14466,6 +14478,11 @@ var RoomEvent;
    */
 
   RoomEvent["SignalConnected"] = "signalConnected";
+  /**
+   * Recording of a room has started/stopped.
+   */
+
+  RoomEvent["RecordingStatusChanged"] = "recordingStatusChanged";
 })(RoomEvent || (RoomEvent = {}));
 
 var ParticipantEvent;
@@ -15312,7 +15329,7 @@ var uaParser = {exports: {}};
 
 var UAParser = uaParser.exports;
 
-var version$1 = "1.4.4";
+var version$1 = "1.5.0";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -15766,25 +15783,6 @@ class DeviceManager {
 
     if (kind) {
       devices = devices.filter(device => device.kind === kind);
-    } // Chrome returns 'default' devices, we would filter them out, but put the default
-    // device at first
-    // we would only do this if there are more than 1 device though
-
-
-    if (devices.length > 1 && devices[0].deviceId === defaultId) {
-      // find another device with matching group id, and move that to 0
-      const defaultDevice = devices[0];
-
-      for (let i = 1; i < devices.length; i += 1) {
-        if (devices[i].groupId === defaultDevice.groupId) {
-          const temp = devices[0];
-          devices[0] = devices[i];
-          devices[i] = temp;
-          break;
-        }
-      }
-
-      return devices.filter(device => device !== defaultDevice);
     }
 
     return devices;
@@ -16748,7 +16746,9 @@ class LocalTrack extends Track {
       await this.sender.replaceTrack(track);
     }
 
-    this._mediaStreamTrack = track;
+    this._mediaStreamTrack = track; // sync muted state with the enabled state of the newly provided track
+
+    this._mediaStreamTrack.enabled = !this.isMuted;
     await this.resumeUpstream();
     this.attachedElements.forEach(el => {
       attachToElement(track, el);
@@ -19195,6 +19195,23 @@ class RemoteTrackPublication extends TrackPublication {
     this.emitTrackUpdate();
   }
 
+  setVideoFPS(fps) {
+    if (!this.isManualOperationAllowed()) {
+      return;
+    }
+
+    if (!(this.track instanceof RemoteVideoTrack)) {
+      return;
+    }
+
+    if (this.fps === fps) {
+      return;
+    }
+
+    this.fps = fps;
+    this.emitTrackUpdate();
+  }
+
   get videoQuality() {
     return this.currentVideoQuality;
   }
@@ -19298,7 +19315,8 @@ class RemoteTrackPublication extends TrackPublication {
   emitTrackUpdate() {
     const settings = UpdateTrackSettings.fromPartial({
       trackSids: [this.trackSid],
-      disabled: this.disabled
+      disabled: this.disabled,
+      fps: this.fps
     });
 
     if (this.videoDimensions) {
@@ -19936,6 +19954,9 @@ class LocalParticipant extends Participant {
           const publishPromises = [];
 
           for (const localTrack of localTracks) {
+            livekitLogger.info('publishing track', {
+              localTrack
+            });
             publishPromises.push(this.publishTrack(localTrack, publishOptions));
           }
 
@@ -20077,14 +20098,28 @@ class LocalParticipant extends Participant {
     let videoConstraints = true;
 
     if (options.resolution) {
-      videoConstraints = {
-        width: options.resolution.width,
-        height: options.resolution.height,
-        frameRate: options.resolution.frameRate
-      };
-    } // typescript definition is missing getDisplayMedia: https://github.com/microsoft/TypeScript/issues/33232
-    // @ts-ignore
-
+      if (isSafari()) {
+        videoConstraints = {
+          width: {
+            max: options.resolution.width
+          },
+          height: {
+            max: options.resolution.height
+          },
+          frameRate: options.resolution.frameRate
+        };
+      } else {
+        videoConstraints = {
+          width: {
+            ideal: options.resolution.width
+          },
+          height: {
+            ideal: options.resolution.height
+          },
+          frameRate: options.resolution.frameRate
+        };
+      }
+    }
 
     const stream = await navigator.mediaDevices.getDisplayMedia({
       audio: (_a = options.audio) !== null && _a !== void 0 ? _a : false,
@@ -20939,8 +20974,8 @@ class SignalClient {
       await sleep(this.signalLatency);
     }
 
-    if (!this.ws) {
-      livekitLogger.error('cannot send signal request before connected');
+    if (!this.ws || this.ws.readyState < this.ws.OPEN) {
+      livekitLogger.error("cannot send signal request before connected, type: ".concat(message === null || message === void 0 ? void 0 : message.$case));
       return;
     }
 
@@ -23275,6 +23310,7 @@ class Room extends events.exports.EventEmitter {
     /** room metadata */
 
     this.metadata = undefined;
+    this._isRecording = false;
     this.audioEnabled = true;
 
     this.connect = (url, token, opts) => {
@@ -23368,6 +23404,12 @@ class Room extends events.exports.EventEmitter {
           this.name = joinResponse.room.name;
           this.sid = joinResponse.room.sid;
           this.metadata = joinResponse.room.metadata;
+
+          if (this._isRecording !== joinResponse.room.activeRecording) {
+            this._isRecording = joinResponse.room.activeRecording;
+            this.emit(RoomEvent.RecordingStatusChanged, joinResponse.room.activeRecording);
+          }
+
           this.emit(RoomEvent.SignalConnected);
         } catch (err) {
           this.recreateEngine();
@@ -23682,8 +23724,15 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.handleRoomUpdate = r => {
-      this.metadata = r.metadata;
-      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
+      if (this._isRecording !== r.activeRecording) {
+        this._isRecording = r.activeRecording;
+        this.emit(RoomEvent.RecordingStatusChanged, r.activeRecording);
+      }
+
+      if (this.metadata !== r.metadata) {
+        this.metadata = r.metadata;
+        this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
+      }
     };
 
     this.handleConnectionQualityUpdate = update => {
@@ -23829,6 +23878,14 @@ class Room extends events.exports.EventEmitter {
   clearConnectionFutures() {
     this.connectFuture = undefined;
   }
+  /**
+   * if the current room has a participant with `recorder: true` in its JWT grant
+   **/
+
+
+  get isRecording() {
+    return this._isRecording;
+  }
   /**
    * @internal for testing
    */
@@ -24469,5 +24526,420 @@ async function createLocalScreenTracks(options) {
   return localTracks;
 }
 
-export { AudioPresets, ConnectionError, ConnectionQuality, ConnectionState, DataPacket_Kind, DefaultReconnectPolicy, DisconnectReason, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, NegotiationError, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isBackupCodec, isBrowserSupported, protocolVersion, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, version };
+var CheckStatus;
+
+(function (CheckStatus) {
+  CheckStatus[CheckStatus["IDLE"] = 0] = "IDLE";
+  CheckStatus[CheckStatus["RUNNING"] = 1] = "RUNNING";
+  CheckStatus[CheckStatus["SKIPPED"] = 2] = "SKIPPED";
+  CheckStatus[CheckStatus["SUCCESS"] = 3] = "SUCCESS";
+  CheckStatus[CheckStatus["FAILED"] = 4] = "FAILED";
+})(CheckStatus || (CheckStatus = {}));
+
+class Checker extends events.exports.EventEmitter {
+  constructor(url, token) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    super();
+    this.status = CheckStatus.IDLE;
+    this.logs = [];
+    this.errorsAsWarnings = false;
+    this.url = url;
+    this.token = token;
+    this.name = this.constructor.name;
+    this.room = new Room(options.roomOptions);
+    this.connectOptions = options.connectOptions;
+
+    if (options.errorsAsWarnings) {
+      this.errorsAsWarnings = options.errorsAsWarnings;
+    }
+  }
+
+  async run(onComplete) {
+    if (this.status !== CheckStatus.IDLE) {
+      throw Error('check is running already');
+    }
+
+    this.setStatus(CheckStatus.RUNNING);
+    this.appendMessage("".concat(this.name, " started."));
+
+    try {
+      await this.perform();
+    } catch (err) {
+      if (err instanceof Error) {
+        if (this.errorsAsWarnings) {
+          this.appendWarning(err.message);
+        } else {
+          this.appendError(err.message);
+        }
+      }
+    }
+
+    await this.disconnect(); // sleep for a bit to ensure disconnect
+
+    await new Promise(resolve => setTimeout(resolve, 500)); // @ts-ignore
+
+    if (this.status !== CheckStatus.SKIPPED) {
+      this.setStatus(this.isSuccess() ? CheckStatus.SUCCESS : CheckStatus.FAILED);
+    }
+
+    if (onComplete) {
+      onComplete();
+    }
+
+    return this.getInfo();
+  }
+
+  isSuccess() {
+    return !this.logs.some(l => l.level === 'error');
+  }
+
+  async connect() {
+    if (this.room.state === ConnectionState.Connected) {
+      return this.room;
+    }
+
+    await this.room.connect(this.url, this.token);
+    return this.room;
+  }
+
+  async disconnect() {
+    if (this.room && this.room.state !== ConnectionState.Disconnected) {
+      await this.room.disconnect(); // wait for it to go through
+
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  }
+
+  skip() {
+    this.setStatus(CheckStatus.SKIPPED);
+  }
+
+  appendMessage(message) {
+    this.logs.push({
+      level: 'info',
+      message
+    });
+    this.emit('update', this.getInfo());
+  }
+
+  appendWarning(message) {
+    this.logs.push({
+      level: 'warning',
+      message
+    });
+    this.emit('update', this.getInfo());
+  }
+
+  appendError(message) {
+    this.logs.push({
+      level: 'error',
+      message
+    });
+    this.emit('update', this.getInfo());
+  }
+
+  setStatus(status) {
+    this.status = status;
+    this.emit('update', this.getInfo());
+  }
+
+  get engine() {
+    var _a;
+
+    return (_a = this.room) === null || _a === void 0 ? void 0 : _a.engine;
+  }
+
+  getInfo() {
+    return {
+      logs: this.logs,
+      name: this.name,
+      status: this.status,
+      description: this.description
+    };
+  }
+
+}
+
+class PublishAudioCheck extends Checker {
+  get description() {
+    return 'Can publish audio';
+  }
+
+  async perform() {
+    var _a;
+
+    const room = await this.connect();
+    const track = await createLocalAudioTrack();
+    room.localParticipant.publishTrack(track); // wait for a few seconds to publish
+
+    await new Promise(resolve => setTimeout(resolve, 3000)); // verify RTC stats that it's publishing
+
+    const stats = await ((_a = track.sender) === null || _a === void 0 ? void 0 : _a.getStats());
+
+    if (!stats) {
+      throw new Error('Could not get RTCStats');
+    }
+
+    let numPackets = 0;
+    stats.forEach(stat => {
+      if (stat.type === 'outbound-rtp' && stat.mediaType === 'audio') {
+        numPackets = stat.packetsSent;
+      }
+    });
+
+    if (numPackets === 0) {
+      throw new Error('Could not determine packets are sent');
+    }
+
+    this.appendMessage("published ".concat(numPackets, " audio packets"));
+  }
+
+}
+
+class PublishVideoCheck extends Checker {
+  get description() {
+    return 'Can publish video';
+  }
+
+  async perform() {
+    var _a;
+
+    const room = await this.connect();
+    const track = await createLocalVideoTrack();
+    room.localParticipant.publishTrack(track); // wait for a few seconds to publish
+
+    await new Promise(resolve => setTimeout(resolve, 3000)); // verify RTC stats that it's publishing
+
+    const stats = await ((_a = track.sender) === null || _a === void 0 ? void 0 : _a.getStats());
+
+    if (!stats) {
+      throw new Error('Could not get RTCStats');
+    }
+
+    let numPackets = 0;
+    stats.forEach(stat => {
+      if (stat.type === 'outbound-rtp' && stat.mediaType === 'video') {
+        numPackets = stat.packetsSent;
+      }
+    });
+
+    if (numPackets === 0) {
+      throw new Error('Could not determine packets are sent');
+    }
+
+    this.appendMessage("published ".concat(numPackets, " video packets"));
+  }
+
+}
+
+class ReconnectCheck extends Checker {
+  get description() {
+    return 'Resuming connection after interruption';
+  }
+
+  async perform() {
+    var _a;
+
+    const room = await this.connect();
+    let reconnectingTriggered = false;
+    let reconnected = false;
+    let reconnectResolver;
+    const reconnectTimeout = new Promise(resolve => {
+      setTimeout(resolve, 5000);
+      reconnectResolver = resolve;
+    });
+    room.on(RoomEvent.Reconnecting, () => {
+      reconnectingTriggered = true;
+    }).on(RoomEvent.Reconnected, () => {
+      reconnected = true;
+      reconnectResolver(true);
+    });
+    (_a = room.engine.client.ws) === null || _a === void 0 ? void 0 : _a.close();
+    const onClose = room.engine.client.onClose;
+
+    if (onClose) {
+      onClose('');
+    }
+
+    await reconnectTimeout;
+
+    if (!reconnectingTriggered) {
+      throw new Error('Did not attempt to reconnect');
+    } else if (!reconnected || room.state !== ConnectionState.Connected) {
+      this.appendWarning('reconnection is only possible in Redis-based configurations');
+      throw new Error('Not able to reconnect');
+    }
+  }
+
+}
+
+class TURNCheck extends Checker {
+  get description() {
+    return 'Can connect via TURN';
+  }
+
+  async perform() {
+    var _a, _b;
+
+    const signalClient = new SignalClient();
+    const joinRes = await signalClient.join(this.url, this.token, {
+      autoSubscribe: true,
+      maxRetries: 0
+    });
+    let hasTLS = false;
+    let hasTURN = false;
+    let hasSTUN = false;
+
+    for (let iceServer of joinRes.iceServers) {
+      for (let url of iceServer.urls) {
+        if (url.startsWith('turn:')) {
+          hasTURN = true;
+          hasSTUN = true;
+        } else if (url.startsWith('turns:')) {
+          hasTURN = true;
+          hasSTUN = true;
+          hasTLS = true;
+        }
+
+        if (url.startsWith('stun:')) {
+          hasSTUN = true;
+        }
+      }
+    }
+
+    if (!hasSTUN) {
+      this.appendWarning('No STUN servers configured on server side.');
+    } else if (hasTURN && !hasTLS) {
+      this.appendWarning('TURN is configured server side, but TURN/TLS is unavailable.');
+    }
+
+    signalClient.close();
+
+    if (((_b = (_a = this.connectOptions) === null || _a === void 0 ? void 0 : _a.rtcConfig) === null || _b === void 0 ? void 0 : _b.iceServers) || hasTURN) {
+      await this.room.connect(this.url, this.token, {
+        rtcConfig: {
+          iceTransportPolicy: 'relay'
+        }
+      });
+    } else {
+      this.appendWarning('No TURN servers configured.');
+      this.skip();
+      await new Promise(resolve => setTimeout(resolve, 0));
+    }
+  }
+
+}
+
+class WebRTCCheck extends Checker {
+  get description() {
+    return 'Establishing WebRTC connection';
+  }
+
+  async perform() {
+    try {
+      console.log('initiating room connection');
+      this.room = await this.connect();
+      console.log('now the room is connected');
+    } catch (err) {
+      this.appendWarning('ports need to be open on firewall in order to connect.');
+      throw err;
+    }
+  }
+
+}
+
+class WebSocketCheck extends Checker {
+  get description() {
+    return 'Connecting to signal connection via WebSocket';
+  }
+
+  async perform() {
+    if (this.url.startsWith('ws:') || this.url.startsWith('http:')) {
+      this.appendWarning('Server is insecure, clients may block connections to it');
+    }
+
+    let signalClient = new SignalClient();
+    const joinRes = await signalClient.join(this.url, this.token, {
+      autoSubscribe: true,
+      maxRetries: 0
+    });
+    this.appendMessage("Connected to server, version ".concat(joinRes.serverVersion, "."));
+    signalClient.close();
+  }
+
+}
+
+class ConnectionCheck extends events.exports {
+  constructor(url, token) {
+    super();
+    this.checkResults = new Map();
+    this.url = url;
+    this.token = token;
+  }
+
+  getNextCheckId() {
+    const nextId = this.checkResults.size;
+    this.checkResults.set(nextId, {
+      logs: [],
+      status: CheckStatus.IDLE,
+      name: '',
+      description: ''
+    });
+    return nextId;
+  }
+
+  updateCheck(checkId, info) {
+    this.checkResults.set(checkId, info);
+    this.emit('checkUpdate', checkId, info);
+  }
+
+  isSuccess() {
+    return Array.from(this.checkResults.values()).every(r => r.status !== CheckStatus.FAILED);
+  }
+
+  getResults() {
+    return Array.from(this.checkResults.values());
+  }
+
+  async createAndRunCheck(check) {
+    const checkId = this.getNextCheckId();
+    const test = new check(this.url, this.token);
+
+    const handleUpdate = info => {
+      this.updateCheck(checkId, info);
+    };
+
+    test.on('update', handleUpdate);
+    const result = await test.run();
+    test.off('update', handleUpdate);
+    return result;
+  }
+
+  async checkWebsocket() {
+    return this.createAndRunCheck(WebSocketCheck);
+  }
+
+  async checkWebRTC() {
+    return this.createAndRunCheck(WebRTCCheck);
+  }
+
+  async checkTURN() {
+    return this.createAndRunCheck(TURNCheck);
+  }
+
+  async checkReconnect() {
+    return this.createAndRunCheck(ReconnectCheck);
+  }
+
+  async checkPublishAudio() {
+    return this.createAndRunCheck(PublishAudioCheck);
+  }
+
+  async checkPublishVideo() {
+    return this.createAndRunCheck(PublishVideoCheck);
+  }
+
+}
+
+export { AudioPresets, ConnectionCheck, ConnectionError, ConnectionQuality, ConnectionState, DataPacket_Kind, DefaultReconnectPolicy, DisconnectReason, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, NegotiationError, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isBackupCodec, isBrowserSupported, protocolVersion, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, version };
 //# sourceMappingURL=livekit-client.esm.mjs.map