livekit-client 0.17.3 → 0.17.6-rc1

package/src/connect.ts

@@ -1,100 +0,0 @@
-import log, { LogLevel, setLogLevel } from './logger';
-import {
-  ConnectOptions,
-} from './options';
-import { MediaDeviceFailure } from './room/errors';
-import { RoomEvent } from './room/events';
-import Room from './room/Room';
-
-export { version } from './version';
-
-/**
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
- */
-export async function connect(
-  url: string,
-  token: string,
-  options?: ConnectOptions,
-): Promise<Room> {
-  options ??= {};
-  if (options.adaptiveStream === undefined) {
-    options.adaptiveStream = options.autoManageVideo === true ? {} : undefined;
-  }
-  setLogLevel(options.logLevel ?? LogLevel.warn);
-
-  const config: RTCConfiguration = options.rtcConfig ?? {};
-  if (options.iceServers) {
-    config.iceServers = options.iceServers;
-  }
-
-  const room = new Room(options);
-
-  // connect to room
-  await room.connect(url, token, options);
-
-  const publishAudio: boolean = options.audio ?? false;
-  const publishVideo: boolean = options.video ?? false;
-
-  if (publishAudio || publishVideo) {
-    setTimeout(async () => {
-      // if publishing both
-      let err: any;
-      if (publishAudio && publishVideo) {
-        try {
-          await room.localParticipant.enableCameraAndMicrophone();
-        } catch (e) {
-          const errKind = MediaDeviceFailure.getFailure(e);
-          log.warn('received error while creating media', errKind);
-          if (e instanceof Error) {
-            log.warn(e.message);
-          }
-
-          // when it's a device issue, try to publish the other kind
-          if (errKind === MediaDeviceFailure.NotFound
-             || errKind === MediaDeviceFailure.DeviceInUse) {
-            try {
-              await room.localParticipant.setMicrophoneEnabled(true);
-            } catch (audioErr) {
-              err = audioErr;
-            }
-          } else {
-            err = e;
-          }
-        }
-      } else if (publishAudio) {
-        try {
-          await room.localParticipant.setMicrophoneEnabled(true);
-        } catch (e) {
-          err = e;
-        }
-      } else if (publishVideo) {
-        try {
-          await room.localParticipant.setCameraEnabled(true);
-        } catch (e) {
-          err = e;
-        }
-      }
-
-      if (err) {
-        room.emit(RoomEvent.MediaDevicesError, err);
-        log.error('could not create media', err);
-      }
-    });
-  }
-
-  return room;
-}

package/src/index.ts

@@ -1,47 +0,0 @@
-import { setLogLevel } from './logger';
-import { DataPacket_Kind, VideoQuality } from './proto/livekit_models';
-import LocalParticipant from './room/participant/LocalParticipant';
-import Participant, { ConnectionQuality } from './room/participant/Participant';
-import { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';
-import RemoteParticipant from './room/participant/RemoteParticipant';
-import Room, { RoomState } from './room/Room';
-import LocalAudioTrack from './room/track/LocalAudioTrack';
-import LocalTrack from './room/track/LocalTrack';
-import LocalTrackPublication from './room/track/LocalTrackPublication';
-import LocalVideoTrack from './room/track/LocalVideoTrack';
-import RemoteAudioTrack from './room/track/RemoteAudioTrack';
-import RemoteTrack from './room/track/RemoteTrack';
-import RemoteTrackPublication from './room/track/RemoteTrackPublication';
-import RemoteVideoTrack from './room/track/RemoteVideoTrack';
-import { TrackPublication } from './room/track/TrackPublication';
-
-export * from './connect';
-export * from './options';
-export * from './room/errors';
-export * from './room/events';
-export * from './room/track/create';
-export * from './room/track/options';
-export * from './room/track/Track';
-export * from './room/track/types';
-export * from './version';
-export {
-  setLogLevel,
-  Room,
-  RoomState,
-  DataPacket_Kind,
-  Participant,
-  RemoteParticipant,
-  LocalParticipant,
-  LocalAudioTrack,
-  LocalVideoTrack,
-  LocalTrack,
-  LocalTrackPublication,
-  RemoteTrack,
-  RemoteAudioTrack,
-  RemoteVideoTrack,
-  RemoteTrackPublication,
-  ParticipantTrackPermission,
-  TrackPublication,
-  VideoQuality,
-  ConnectionQuality,
-};

package/src/logger.ts

@@ -1,22 +0,0 @@
-import log from 'loglevel';
-
-export type LogLevelDesc = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
-
-export enum LogLevel {
-  trace = 'trace',
-  debug = 'debug',
-  info = 'info',
-  warn = 'warn',
-  error = 'error',
-  silent = 'silent',
-}
-
-const livekitLogger = log.getLogger('livekit');
-
-livekitLogger.setLevel(LogLevel.info);
-
-export default livekitLogger;
-
-export function setLogLevel(level: LogLevel | LogLevelDesc) {
-  livekitLogger.setLevel(level);
-}

package/src/options.ts

@@ -1,149 +0,0 @@
-import { LogLevel, LogLevelDesc } from './logger';
-import {
-  AudioCaptureOptions,
-  CreateLocalTracksOptions,
-  TrackPublishDefaults,
-  VideoCaptureOptions,
-} from './room/track/options';
-import { AdaptiveStreamSettings } from './room/track/types';
-
-/**
- * Options for when creating a new room
- */
-export interface RoomOptions {
-  /**
-   * AdaptiveStream lets LiveKit automatically manage quality of subscribed
-   * video tracks to optimize for bandwidth and CPU.
-   * When attached video elements are visible, it'll choose an appropriate
-   * resolution based on the size of largest video element it's attached to.
-   *
-   * When none of the video elements are visible, it'll temporarily pause
-   * the data flow until they are visible again.
-   */
-  adaptiveStream?: AdaptiveStreamSettings | boolean;
-
-  /**
-   * enable Dynacast, off by default. With Dynacast dynamically pauses
-   * video layers that are not being consumed by any subscribers, significantly
-   * reducing publishing CPU and bandwidth usage.
-   */
-  dynacast?: boolean;
-
-  /**
-   * default options to use when capturing user's audio
-   */
-  audioCaptureDefaults?: AudioCaptureOptions;
-
-  /**
-   * default options to use when capturing user's video
-   */
-  videoCaptureDefaults?: VideoCaptureOptions;
-
-  /**
-   * default options to use when publishing tracks
-   */
-  publishDefaults?: TrackPublishDefaults;
-
-  /**
-   * should local tracks be stopped when they are unpublished. defaults to true
-   * set this to false if you would prefer to clean up unpublished local tracks manually.
-   */
-  stopLocalTrackOnUnpublish?: boolean;
-
-  /**
-   * @internal
-   * experimental flag, introduce a delay before sending signaling messages
-   */
-  expSignalLatency?: number;
-}
-
-/**
- * Options for Room.connect()
- */
-export interface RoomConnectOptions {
-  /** autosubscribe to room tracks after joining, defaults to true */
-  autoSubscribe?: boolean;
-
-  /**
-   * use to override any RTCConfiguration options.
-   */
-  rtcConfig?: RTCConfiguration;
-
-  /**
-   * publish only mode
-   */
-  publishOnly?: string;
-}
-
-/**
- * if video or audio tracks are created as part of [[connect]], it'll automatically
- * publish those tracks to the room.
- */
-export interface ConnectOptions extends CreateLocalTracksOptions {
-  /** autosubscribe to room tracks upon connect, defaults to true */
-  autoSubscribe?: boolean;
-
-  /**
-   * see [[RoomOptions.adaptiveStream]]
-   */
-  adaptiveStream?: AdaptiveStreamSettings | boolean;
-
-  /**
-   * alias for adaptiveStream
-   * @deprecated
-   */
-  autoManageVideo?: boolean;
-
-  /**
-   * see [[RoomOptions.dynacast]]
-   */
-  dynacast?: boolean;
-
-  /** configures LiveKit internal log level */
-  logLevel?: LogLevel | LogLevelDesc;
-
-  /**
-   * set ICE servers. When deployed correctly, LiveKit automatically uses the built-in TURN servers
-   */
-  iceServers?: RTCIceServer[];
-
-  /**
-   * use to override any RTCConfiguration options.
-   */
-  rtcConfig?: RTCConfiguration;
-
-  /**
-   * capture and publish audio track on connect, defaults to false
-   *
-   * If this option is used, you will not be notified if user denies capture permission.
-   */
-  audio?: boolean;
-
-  /**
-   * capture and publish video track on connect, defaults to false
-   *
-   * If this option is used, you will not be notified if user denies capture permission.
-   */
-  video?: boolean;
-
-  /**
-   * default options to use when capturing user's audio
-   */
-  audioCaptureDefaults?: AudioCaptureOptions;
-
-  /**
-   * default options to use when capturing user's video
-   */
-  videoCaptureDefaults?: VideoCaptureOptions;
-
-  /**
-   * default options to use when publishing tracks
-   */
-  publishDefaults?: TrackPublishDefaults;
-
-  /**
-   * should local tracks be stopped when they are unpublished. defaults to true
-   * set this to false if you would prefer to clean up unpublished local tracks manually.
-   */
-  stopLocalTrackOnUnpublish?: boolean;
-}

package/src/proto/google/protobuf/timestamp.ts

@@ -1,222 +0,0 @@
-/* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal";
-
-export const protobufPackage = "google.protobuf";
-
-/**
- * A Timestamp represents a point in time independent of any time zone or local
- * calendar, encoded as a count of seconds and fractions of seconds at
- * nanosecond resolution. The count is relative to an epoch at UTC midnight on
- * January 1, 1970, in the proleptic Gregorian calendar which extends the
- * Gregorian calendar backwards to year one.
- *
- * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
- * second table is needed for interpretation, using a [24-hour linear
- * smear](https://developers.google.com/time/smear).
- *
- * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
- * restricting to that range, we ensure that we can convert to and from [RFC
- * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
- *
- * # Examples
- *
- * Example 1: Compute Timestamp from POSIX `time()`.
- *
- *     Timestamp timestamp;
- *     timestamp.set_seconds(time(NULL));
- *     timestamp.set_nanos(0);
- *
- * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
- *
- *     struct timeval tv;
- *     gettimeofday(&tv, NULL);
- *
- *     Timestamp timestamp;
- *     timestamp.set_seconds(tv.tv_sec);
- *     timestamp.set_nanos(tv.tv_usec * 1000);
- *
- * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
- *
- *     FILETIME ft;
- *     GetSystemTimeAsFileTime(&ft);
- *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
- *
- *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
- *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
- *     Timestamp timestamp;
- *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
- *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
- *
- * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
- *
- *     long millis = System.currentTimeMillis();
- *
- *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
- *         .setNanos((int) ((millis % 1000) * 1000000)).build();
- *
- *
- * Example 5: Compute Timestamp from Java `Instant.now()`.
- *
- *     Instant now = Instant.now();
- *
- *     Timestamp timestamp =
- *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
- *             .setNanos(now.getNano()).build();
- *
- *
- * Example 6: Compute Timestamp from current time in Python.
- *
- *     timestamp = Timestamp()
- *     timestamp.GetCurrentTime()
- *
- * # JSON Mapping
- *
- * In JSON format, the Timestamp type is encoded as a string in the
- * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
- * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
- * where {year} is always expressed using four digits while {month}, {day},
- * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
- * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
- * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
- * is required. A proto3 JSON serializer should always use UTC (as indicated by
- * "Z") when printing the Timestamp type and a proto3 JSON parser should be
- * able to accept both UTC and other timezones (as indicated by an offset).
- *
- * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
- * 01:30 UTC on January 15, 2017.
- *
- * In JavaScript, one can convert a Date object to this format using the
- * standard
- * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
- * method. In Python, a standard `datetime.datetime` object can be converted
- * to this format using
- * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
- * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
- * the Joda Time's [`ISODateTimeFormat.dateTime()`](
- * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
- * ) to obtain a formatter capable of generating timestamps in this format.
- */
-export interface Timestamp {
-  /**
-   * Represents seconds of UTC time since Unix epoch
-   * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-   * 9999-12-31T23:59:59Z inclusive.
-   */
-  seconds: number;
-  /**
-   * Non-negative fractions of a second at nanosecond resolution. Negative
-   * second values with fractions must still have non-negative nanos values
-   * that count forward in time. Must be from 0 to 999,999,999
-   * inclusive.
-   */
-  nanos: number;
-}
-
-const baseTimestamp: object = { seconds: 0, nanos: 0 };
-
-export const Timestamp = {
-  encode(
-    message: Timestamp,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.seconds !== 0) {
-      writer.uint32(8).int64(message.seconds);
-    }
-    if (message.nanos !== 0) {
-      writer.uint32(16).int32(message.nanos);
-    }
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): Timestamp {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = { ...baseTimestamp } as Timestamp;
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.seconds = longToNumber(reader.int64() as Long);
-          break;
-        case 2:
-          message.nanos = reader.int32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): Timestamp {
-    const message = { ...baseTimestamp } as Timestamp;
-    if (object.seconds !== undefined && object.seconds !== null) {
-      message.seconds = Number(object.seconds);
-    } else {
-      message.seconds = 0;
-    }
-    if (object.nanos !== undefined && object.nanos !== null) {
-      message.nanos = Number(object.nanos);
-    } else {
-      message.nanos = 0;
-    }
-    return message;
-  },
-
-  toJSON(message: Timestamp): unknown {
-    const obj: any = {};
-    message.seconds !== undefined && (obj.seconds = message.seconds);
-    message.nanos !== undefined && (obj.nanos = message.nanos);
-    return obj;
-  },
-
-  fromPartial(object: DeepPartial<Timestamp>): Timestamp {
-    const message = { ...baseTimestamp } as Timestamp;
-    message.seconds = object.seconds ?? 0;
-    message.nanos = object.nanos ?? 0;
-    return message;
-  },
-};
-
-declare var self: any | undefined;
-declare var window: any | undefined;
-declare var global: any | undefined;
-var globalThis: any = (() => {
-  if (typeof globalThis !== "undefined") return globalThis;
-  if (typeof self !== "undefined") return self;
-  if (typeof window !== "undefined") return window;
-  if (typeof global !== "undefined") return global;
-  throw "Unable to locate global object";
-})();
-
-type Builtin =
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined;
-export type DeepPartial<T> = T extends Builtin
-  ? T
-  : T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends {}
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>;
-
-function longToNumber(long: Long): number {
-  if (long.gt(Number.MAX_SAFE_INTEGER)) {
-    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-  }
-  return long.toNumber();
-}
-
-if (_m0.util.Long !== Long) {
-  _m0.util.Long = Long as any;
-  _m0.configure();
-}