livekit-client 0.17.5 → 0.17.6-rc1

package/dist/room/utils.js

@@ -1,79 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClientInfo = exports.getIntersectionObserver = exports.getResizeObserver = exports.isWeb = exports.isMobile = exports.isSafari = exports.isFireFox = exports.sleep = exports.unpackStreamId = void 0;
-const livekit_models_1 = require("../proto/livekit_models");
-const version_1 = require("../version");
-const separator = '|';
-function unpackStreamId(packed) {
-    const parts = packed.split(separator);
-    if (parts.length > 1) {
-        return [parts[0], packed.substr(parts[0].length + 1)];
-    }
-    return [packed, ''];
-}
-exports.unpackStreamId = unpackStreamId;
-function sleep(duration) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve) => setTimeout(resolve, duration));
-    });
-}
-exports.sleep = sleep;
-function isFireFox() {
-    return navigator.userAgent.indexOf('Firefox') !== -1;
-}
-exports.isFireFox = isFireFox;
-function isSafari() {
-    return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-}
-exports.isSafari = isSafari;
-function isMobile() {
-    return /Tablet|iPad|Mobile|Android|BlackBerry/.test(navigator.userAgent);
-}
-exports.isMobile = isMobile;
-function isWeb() {
-    return typeof document !== 'undefined';
-}
-exports.isWeb = isWeb;
-function roDispatchCallback(entries) {
-    for (const entry of entries) {
-        entry.target.handleResize(entry);
-    }
-}
-function ioDispatchCallback(entries) {
-    for (const entry of entries) {
-        entry.target.handleVisibilityChanged(entry);
-    }
-}
-let resizeObserver = null;
-const getResizeObserver = () => {
-    if (!resizeObserver)
-        resizeObserver = new ResizeObserver(roDispatchCallback);
-    return resizeObserver;
-};
-exports.getResizeObserver = getResizeObserver;
-let intersectionObserver = null;
-const getIntersectionObserver = () => {
-    if (!intersectionObserver)
-        intersectionObserver = new IntersectionObserver(ioDispatchCallback);
-    return intersectionObserver;
-};
-exports.getIntersectionObserver = getIntersectionObserver;
-function getClientInfo() {
-    const info = livekit_models_1.ClientInfo.fromPartial({
-        sdk: livekit_models_1.ClientInfo_SDK.JS,
-        protocol: version_1.protocolVersion,
-        version: version_1.version,
-    });
-    return info;
-}
-exports.getClientInfo = getClientInfo;
-//# sourceMappingURL=utils.js.map

package/dist/room/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/room/utils.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,4DAAqE;AACrE,wCAAsD;AAEtD,MAAM,SAAS,GAAG,GAAG,CAAC;AAEtB,SAAgB,cAAc,CAAC,MAAc;IAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACtC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QACpB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;KACvD;IACD,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACtB,CAAC;AAND,wCAMC;AAED,SAAsB,KAAK,CAAC,QAAgB;;QAC1C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;IACjE,CAAC;CAAA;AAFD,sBAEC;AAED,SAAgB,SAAS;IACvB,OAAO,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC;AAFD,8BAEC;AAED,SAAgB,QAAQ;IACtB,OAAO,gCAAgC,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AACpE,CAAC;AAFD,4BAEC;AAED,SAAgB,QAAQ;IACtB,OAAO,uCAAuC,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AAC3E,CAAC;AAFD,4BAEC;AAED,SAAgB,KAAK;IACnB,OAAO,OAAO,QAAQ,KAAK,WAAW,CAAC;AACzC,CAAC;AAFD,sBAEC;AAED,SAAS,kBAAkB,CAAC,OAA8B;IACxD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;QAC1B,KAAK,CAAC,MAAiC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;KAC9D;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,OAAoC;IAC9D,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;QAC1B,KAAK,CAAC,MAAiC,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC;KACzE;AACH,CAAC;AAED,IAAI,cAAc,GAA0B,IAAI,CAAC;AAC1C,MAAM,iBAAiB,GAAG,GAAG,EAAE;IACpC,IAAI,CAAC,cAAc;QAAE,cAAc,GAAG,IAAI,cAAc,CAAC,kBAAkB,CAAC,CAAC;IAC7E,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC;AAHW,QAAA,iBAAiB,qBAG5B;AAEF,IAAI,oBAAoB,GAAgC,IAAI,CAAC;AACtD,MAAM,uBAAuB,GAAG,GAAG,EAAE;IAC1C,IAAI,CAAC,oBAAoB;QAAE,oBAAoB,GAAG,IAAI,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;IAC/F,OAAO,oBAAoB,CAAC;AAC9B,CAAC,CAAC;AAHW,QAAA,uBAAuB,2BAGlC;AAOF,SAAgB,aAAa;IAC3B,MAAM,IAAI,GAAG,2BAAU,CAAC,WAAW,CAAC;QAClC,GAAG,EAAE,+BAAc,CAAC,EAAE;QACtB,QAAQ,EAAE,yBAAe;QACzB,OAAO,EAAP,iBAAO;KACR,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AACd,CAAC;AAPD,sCAOC"}

package/dist/version.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.protocolVersion = exports.version = void 0;
-exports.version = '0.17.5';
-exports.protocolVersion = 7;
-//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,QAAQ,CAAC;AACnB,QAAA,eAAe,GAAG,CAAC,CAAC"}

package/jest.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-  clearMocks: true,
-  modulePathIgnorePatterns: ['<rootDir>/dist/'],
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-};

package/src/api/RequestQueue.ts

@@ -1,53 +0,0 @@
-import log from '../logger';
-
-export default class Queue {
-  private queue: Array<() => void>;
-
-  private running: boolean;
-
-  constructor() {
-    this.queue = [];
-    this.running = false;
-  }
-
-  enqueue(cb: () => void) {
-    log.trace('enqueuing request to fire later');
-    this.queue.push(cb);
-  }
-
-  dequeue() {
-    const evt = this.queue.shift();
-    if (evt) evt();
-    log.trace('firing request from queue');
-  }
-
-  async run() {
-    if (this.running) return;
-    log.trace('start queue');
-    this.running = true;
-    while (this.running && this.queue.length > 0) {
-      this.dequeue();
-    }
-    this.running = false;
-    log.trace('queue finished');
-  }
-
-  pause() {
-    log.trace('pausing queue');
-    this.running = false;
-  }
-
-  reset() {
-    log.trace('resetting queue');
-    this.running = false;
-    this.queue = [];
-  }
-
-  isRunning() {
-    return this.running;
-  }
-
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-}

package/src/api/SignalClient.ts

@@ -1,499 +0,0 @@
-import log from '../logger';
-import {
-  ClientInfo,
-  ParticipantInfo, Room, SpeakerInfo, VideoLayer,
-} from '../proto/livekit_models';
-import {
-  AddTrackRequest,
-  ConnectionQualityUpdate,
-  JoinResponse,
-  LeaveRequest,
-  SessionDescription,
-  SignalRequest,
-  SignalResponse,
-  SignalTarget, SimulateScenario,
-  StreamStateUpdate,
-  SubscribedQualityUpdate,
-  SubscriptionPermissionUpdate, SyncState, TrackPermission,
-  TrackPublishedResponse,
-  TrackUnpublishedResponse,
-  UpdateSubscription, UpdateTrackSettings,
-} from '../proto/livekit_rtc';
-import { ConnectionError } from '../room/errors';
-import { getClientInfo, isWeb, sleep } from '../room/utils';
-import Queue from './RequestQueue';
-
-if (isWeb()) {
-  import('webrtc-adapter');
-}
-
-// internal options
-interface ConnectOpts {
-  autoSubscribe?: boolean;
-  /** internal */
-  reconnect?: boolean;
-
-  publishOnly?: string;
-}
-
-// public options
-export interface SignalOptions {
-  autoSubscribe?: boolean;
-  publishOnly?: string;
-}
-
-const passThroughQueueSignals: Array<keyof SignalRequest> = [
-  'syncState',
-  'trickle',
-  'offer',
-  'answer',
-  'simulate',
-  'leave',
-];
-
-function canPassThroughQueue(req: SignalRequest): boolean {
-  const canPass = Object.keys(req)
-    .find((key) => passThroughQueueSignals.includes(key as keyof SignalRequest)) !== undefined;
-  log.trace('request allowed to bypass queue:', canPass, req);
-  return canPass;
-}
-
-/** @internal */
-export class SignalClient {
-  isConnected: boolean;
-
-  isReconnecting: boolean;
-
-  requestQueue: Queue;
-
-  useJSON: boolean;
-
-  /** simulate signaling latency by delaying messages */
-  signalLatency?: number;
-
-  onClose?: (reason: string) => void;
-
-  onAnswer?: (sd: RTCSessionDescriptionInit) => void;
-
-  onOffer?: (sd: RTCSessionDescriptionInit) => void;
-
-  // when a new ICE candidate is made available
-  onTrickle?: (sd: RTCIceCandidateInit, target: SignalTarget) => void;
-
-  onParticipantUpdate?: (updates: ParticipantInfo[]) => void;
-
-  onLocalTrackPublished?: (res: TrackPublishedResponse) => void;
-
-  onNegotiateRequested?: () => void;
-
-  onSpeakersChanged?: (res: SpeakerInfo[]) => void;
-
-  onRemoteMuteChanged?: (trackSid: string, muted: boolean) => void;
-
-  onRoomUpdate?: (room: Room) => void;
-
-  onConnectionQuality?: (update: ConnectionQualityUpdate) => void;
-
-  onStreamStateUpdate?: (update: StreamStateUpdate) => void;
-
-  onSubscribedQualityUpdate?: (update: SubscribedQualityUpdate) => void;
-
-  onSubscriptionPermissionUpdate?: (update: SubscriptionPermissionUpdate) => void;
-
-  onLocalTrackUnpublished?: (res: TrackUnpublishedResponse) => void;
-
-  onTokenRefresh?: (token: string) => void;
-
-  onLeave?: (leave: LeaveRequest) => void;
-
-  ws?: WebSocket;
-
-  constructor(useJSON: boolean = false) {
-    this.isConnected = false;
-    this.isReconnecting = false;
-    this.useJSON = useJSON;
-    this.requestQueue = new Queue();
-  }
-
-  async join(
-    url: string,
-    token: string,
-    opts?: SignalOptions,
-  ): Promise<JoinResponse> {
-    // during a full reconnect, we'd want to start the sequence even if currently
-    // connected
-    this.isConnected = false;
-    const res = await this.connect(url, token, {
-      autoSubscribe: opts?.autoSubscribe,
-      publishOnly: opts?.publishOnly,
-    });
-    return res as JoinResponse;
-  }
-
-  async reconnect(url: string, token: string): Promise<void> {
-    this.isReconnecting = true;
-    await this.connect(url, token, {
-      reconnect: true,
-    });
-  }
-
-  connect(
-    url: string,
-    token: string,
-    opts: ConnectOpts,
-  ): Promise<JoinResponse | void> {
-    if (url.startsWith('http')) {
-      url = url.replace('http', 'ws');
-    }
-    // strip trailing slash
-    url = url.replace(/\/$/, '');
-    url += '/rtc';
-
-    const clientInfo = getClientInfo();
-    const params = createConnectionParams(token, clientInfo, opts);
-
-    return new Promise<JoinResponse | void>((resolve, reject) => {
-      log.debug('connecting to', url + params);
-      this.ws = undefined;
-      const ws = new WebSocket(url + params);
-      ws.binaryType = 'arraybuffer';
-
-      ws.onerror = async (ev: Event) => {
-        if (!this.ws) {
-          try {
-            const resp = await fetch(`http${url.substring(2)}/validate${params}`);
-            if (!resp.ok) {
-              const msg = await resp.text();
-              reject(new ConnectionError(msg));
-            } else {
-              reject(new ConnectionError('Internal error'));
-            }
-          } catch (e) {
-            reject(new ConnectionError('server was not reachable'));
-          }
-          return;
-        }
-        // other errors, handle
-        this.handleWSError(ev);
-      };
-
-      ws.onopen = () => {
-        this.ws = ws;
-        if (opts.reconnect) {
-          // upon reconnection, there will not be additional handshake
-          this.isConnected = true;
-          resolve();
-        }
-      };
-
-      ws.onmessage = async (ev: MessageEvent) => {
-        // not considered connected until JoinResponse is received
-        let msg: SignalResponse;
-        if (typeof ev.data === 'string') {
-          const json = JSON.parse(ev.data);
-          msg = SignalResponse.fromJSON(json);
-        } else if (ev.data instanceof ArrayBuffer) {
-          msg = SignalResponse.decode(new Uint8Array(ev.data));
-        } else {
-          log.error('could not decode websocket message', typeof ev.data);
-          return;
-        }
-
-        if (!this.isConnected) {
-          // handle join message only
-          if (msg.join) {
-            this.isConnected = true;
-            resolve(msg.join);
-          } else {
-            reject(new ConnectionError('did not receive join response'));
-          }
-          return;
-        }
-
-        if (this.signalLatency) {
-          await sleep(this.signalLatency);
-        }
-        this.handleSignalResponse(msg);
-      };
-
-      ws.onclose = (ev: CloseEvent) => {
-        if (!this.isConnected || this.ws !== ws) return;
-
-        log.debug('websocket connection closed', ev.reason);
-        this.isConnected = false;
-        if (this.onClose) this.onClose(ev.reason);
-        if (this.ws === ws) {
-          this.ws = undefined;
-        }
-      };
-    });
-  }
-
-  close() {
-    this.isConnected = false;
-    if (this.ws) this.ws.onclose = null;
-    this.ws?.close();
-    this.ws = undefined;
-  }
-
-  // initial offer after joining
-  sendOffer(offer: RTCSessionDescriptionInit) {
-    log.debug('sending offer', offer);
-    this.sendRequest({
-      offer: toProtoSessionDescription(offer),
-    });
-  }
-
-  // answer a server-initiated offer
-  sendAnswer(answer: RTCSessionDescriptionInit) {
-    log.debug('sending answer');
-    this.sendRequest({
-      answer: toProtoSessionDescription(answer),
-    });
-  }
-
-  sendIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget) {
-    log.trace('sending ice candidate', candidate);
-    this.sendRequest({
-      trickle: {
-        candidateInit: JSON.stringify(candidate),
-        target,
-      },
-    });
-  }
-
-  sendMuteTrack(trackSid: string, muted: boolean) {
-    this.sendRequest({
-      mute: {
-        sid: trackSid,
-        muted,
-      },
-    });
-  }
-
-  sendAddTrack(req: AddTrackRequest): void {
-    this.sendRequest({
-      addTrack: AddTrackRequest.fromPartial(req),
-    });
-  }
-
-  sendUpdateTrackSettings(settings: UpdateTrackSettings) {
-    this.sendRequest({ trackSetting: settings });
-  }
-
-  sendUpdateSubscription(sub: UpdateSubscription) {
-    this.sendRequest({ subscription: sub });
-  }
-
-  sendSyncState(sync: SyncState) {
-    this.sendRequest({ syncState: sync });
-  }
-
-  sendUpdateVideoLayers(trackSid: string, layers: VideoLayer[]) {
-    this.sendRequest({
-      updateLayers: {
-        trackSid,
-        layers,
-      },
-    });
-  }
-
-  sendUpdateSubscriptionPermissions(
-    allParticipants: boolean,
-    trackPermissions: TrackPermission[],
-  ) {
-    this.sendRequest({
-      subscriptionPermission: {
-        allParticipants,
-        trackPermissions,
-      },
-    });
-  }
-
-  sendSimulateScenario(scenario: SimulateScenario) {
-    this.sendRequest({
-      simulate: scenario,
-    });
-  }
-
-  sendLeave() {
-    this.sendRequest(SignalRequest.fromPartial({ leave: {} }));
-  }
-
-  async sendRequest(req: SignalRequest, fromQueue: boolean = false) {
-    // capture all requests while reconnecting and put them in a queue.
-    // keep order by queueing up new events as long as the queue is not empty
-    // unless the request originates from the queue, then don't enqueue again
-    const canQueue = !fromQueue && !canPassThroughQueue(req);
-    if (canQueue && (this.isReconnecting || (!this.requestQueue.isEmpty()))) {
-      this.requestQueue.enqueue(() => this.sendRequest(req, true));
-      return;
-    }
-    if (this.signalLatency) {
-      await sleep(this.signalLatency);
-    }
-    if (!this.ws) {
-      log.error('cannot send signal request before connected');
-      return;
-    }
-
-    try {
-      if (this.useJSON) {
-        this.ws.send(JSON.stringify(SignalRequest.toJSON(req)));
-      } else {
-        this.ws.send(SignalRequest.encode(req).finish());
-      }
-    } catch (e) {
-      log.error('error sending signal message', e);
-    }
-  }
-
-  private handleSignalResponse(msg: SignalResponse) {
-    if (msg.answer) {
-      const sd = fromProtoSessionDescription(msg.answer);
-      if (this.onAnswer) {
-        this.onAnswer(sd);
-      }
-    } else if (msg.offer) {
-      const sd = fromProtoSessionDescription(msg.offer);
-      if (this.onOffer) {
-        this.onOffer(sd);
-      }
-    } else if (msg.trickle) {
-      const candidate: RTCIceCandidateInit = JSON.parse(
-        msg.trickle.candidateInit,
-      );
-      if (this.onTrickle) {
-        this.onTrickle(candidate, msg.trickle.target);
-      }
-    } else if (msg.update) {
-      if (this.onParticipantUpdate) {
-        this.onParticipantUpdate(msg.update.participants);
-      }
-    } else if (msg.trackPublished) {
-      if (this.onLocalTrackPublished) {
-        this.onLocalTrackPublished(msg.trackPublished);
-      }
-    } else if (msg.speakersChanged) {
-      if (this.onSpeakersChanged) {
-        this.onSpeakersChanged(msg.speakersChanged.speakers);
-      }
-    } else if (msg.leave) {
-      if (this.onLeave) {
-        this.onLeave(msg.leave);
-      }
-    } else if (msg.mute) {
-      if (this.onRemoteMuteChanged) {
-        this.onRemoteMuteChanged(msg.mute.sid, msg.mute.muted);
-      }
-    } else if (msg.roomUpdate) {
-      if (this.onRoomUpdate) {
-        this.onRoomUpdate(msg.roomUpdate.room!);
-      }
-    } else if (msg.connectionQuality) {
-      if (this.onConnectionQuality) {
-        this.onConnectionQuality(msg.connectionQuality);
-      }
-    } else if (msg.streamStateUpdate) {
-      if (this.onStreamStateUpdate) {
-        this.onStreamStateUpdate(msg.streamStateUpdate);
-      }
-    } else if (msg.subscribedQualityUpdate) {
-      if (this.onSubscribedQualityUpdate) {
-        this.onSubscribedQualityUpdate(msg.subscribedQualityUpdate);
-      }
-    } else if (msg.subscriptionPermissionUpdate) {
-      if (this.onSubscriptionPermissionUpdate) {
-        this.onSubscriptionPermissionUpdate(msg.subscriptionPermissionUpdate);
-      }
-    } else if (msg.refreshToken) {
-      if (this.onTokenRefresh) {
-        this.onTokenRefresh(msg.refreshToken);
-      }
-    } else if (msg.trackUnpublished) {
-      if (this.onLocalTrackUnpublished) {
-        this.onLocalTrackUnpublished(msg.trackUnpublished);
-      }
-    } else {
-      log.debug('unsupported message', msg);
-    }
-  }
-
-  setReconnected() {
-    this.isReconnecting = false;
-    this.requestQueue.run();
-  }
-
-  private handleWSError(ev: Event) {
-    log.error('websocket error', ev);
-  }
-}
-
-function fromProtoSessionDescription(
-  sd: SessionDescription,
-): RTCSessionDescriptionInit {
-  const rsd: RTCSessionDescriptionInit = {
-    type: 'offer',
-    sdp: sd.sdp,
-  };
-  switch (sd.type) {
-    case 'answer':
-    case 'offer':
-    case 'pranswer':
-    case 'rollback':
-      rsd.type = sd.type;
-      break;
-    default:
-      break;
-  }
-  return rsd;
-}
-
-export function toProtoSessionDescription(
-  rsd: RTCSessionDescription | RTCSessionDescriptionInit,
-): SessionDescription {
-  const sd: SessionDescription = {
-    sdp: rsd.sdp!,
-    type: rsd.type!,
-  };
-  return sd;
-}
-
-function createConnectionParams(token: string, info: ClientInfo, opts?: ConnectOpts): string {
-  const params = new URLSearchParams();
-  params.set('access_token', token);
-
-  // opts
-  if (opts?.reconnect) {
-    params.set('reconnect', '1');
-  }
-  if (opts?.autoSubscribe !== undefined) {
-    params.set('auto_subscribe', opts.autoSubscribe ? '1' : '0');
-  }
-
-  // ClientInfo
-  params.set('sdk', 'js');
-  params.set('version', info.version);
-  params.set('protocol', info.protocol.toString());
-  if (info.deviceModel) {
-    params.set('device_model', info.deviceModel);
-  }
-  if (info.os) {
-    params.set('os', info.os);
-  }
-  if (info.osVersion) {
-    params.set('os_version', info.osVersion);
-  }
-  if (info.browser) {
-    params.set('browser', info.browser);
-  }
-  if (info.browserVersion) {
-    params.set('browser_version', info.browserVersion);
-  }
-
-  if (opts?.publishOnly !== undefined) {
-    params.set('publish', opts.publishOnly);
-  }
-
-  return `?${params.toString()}`;
-}