@100mslive/react-native-hms 1.4.0 → 1.6.0

package/lib/module/utils/emitter/EventEmitter.js

@@ -0,0 +1,151 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { EmitterSubscription } from './_EmitterSubscription';
+import { EventSubscriptionVendor } from './_EventSubscriptionVendor';
+const sparseFilterPredicate = () => true;
+export { EmitterSubscription } from './_EmitterSubscription';
+
+/**
+ * @class EventEmitter
+ * @description
+ * An EventEmitter is responsible for managing a set of listeners and publishing
+ * events to them when it is told that such events happened. In addition to the
+ * data for the given event it also sends a event control object which allows
+ * the listeners/handlers to prevent the default behavior of the given event.
+ *
+ * The emitter is designed to be generic enough to support all the different
+ * contexts in which one might want to emit events. It is a simple multicast
+ * mechanism on top of which extra functionality can be composed. For example, a
+ * more advanced emitter may use an EventHolder and EventFactory.
+ */
+export class EventEmitter {
+  /**
+   * @constructor
+   *
+   * @param {EventSubscriptionVendor} subscriber - Optional subscriber instance
+   *   to use. If omitted, a new subscriber will be created for the emitter.
+   */
+  constructor(subscriber) {
+    _defineProperty(this, "_subscriber", void 0);
+    this._subscriber = subscriber || new EventSubscriptionVendor();
+  }
+
+  /**
+   * Adds a listener to be invoked when events of the specified type are
+   * emitted. An optional calling context may be provided. The data arguments
+   * emitted will be passed to the listener function.
+   *
+   * TODO: Annotate the listener arg's type. This is tricky because listeners
+   *       can be invoked with varargs.
+   *
+   * @param {string} eventType - Name of the event to listen to
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  addListener(eventType, listener, context) {
+    return this._subscriber.addSubscription(eventType, new EmitterSubscription(this, this._subscriber, listener, context));
+  }
+
+  /**
+   * Removes all of the registered listeners, including those registered as
+   * listener maps.
+   *
+   * @param {?string} eventType - Optional name of the event whose registered
+   *   listeners to remove
+   */
+  removeAllListeners(eventType) {
+    this._subscriber.removeAllSubscriptions(eventType);
+  }
+
+  /**
+   * Removes a specific subscription. Called by the `remove()` method of the
+   * subscription itself to ensure any necessary cleanup is performed.
+   */
+  removeSubscription(subscription) {
+    if (subscription.emitter !== this) {
+      console.warn('Subscription does not belong to this emitter.'); // TODO: use HMSLogger here
+      return;
+    }
+    this._subscriber.removeSubscription(subscription);
+  }
+
+  /**
+   * Returns the number of listeners that are currently registered for the given
+   * event.
+   *
+   * @param {string} eventType - Name of the event to query
+   * @returns {number}
+   */
+  listenerCount(eventType) {
+    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+    return subscriptions ?
+    // We filter out missing entries because the array is sparse.
+    // "callbackfn is called only for elements of the array which actually
+    // exist; it is not called for missing elements of the array."
+    // https://www.ecma-international.org/ecma-262/9.0/index.html#sec-array.prototype.filter
+    subscriptions.filter(sparseFilterPredicate).length : 0;
+  }
+
+  /**
+   * Emits an event of the given type with the given data. All handlers of that
+   * particular type will be notified.
+   *
+   * @param {string} eventType - Name of the event to emit
+   * @param {...*} Arbitrary arguments to be passed to each registered listener
+   *
+   * @example
+   *   emitter.addListener('someEvent', function(message) {
+   *     console.log(message);
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   */
+  emit(eventType) {
+    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+    if (subscriptions) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      for (let i = 0, l = subscriptions.length; i < l; i++) {
+        const subscription = subscriptions[i];
+
+        // The subscription may have been removed during this event loop.
+        if (subscription && subscription.listener) {
+          subscription.listener.apply(subscription.context, args);
+        }
+      }
+    }
+  }
+
+  /**
+   * Removes the given listener for event of specific type.
+   *
+   * @param {string} eventType - Name of the event to emit
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   *
+   * @example
+   *   emitter.removeListener('someEvent', function(message) {
+   *     console.log(message);
+   *   }); // removes the listener if already registered
+   *
+   */
+  removeListener(eventType, listener) {
+    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+    if (subscriptions) {
+      for (let i = 0, l = subscriptions.length; i < l; i++) {
+        const subscription = subscriptions[i];
+
+        // The subscription may have been removed during this event loop.
+        // its listener matches the listener in method parameters
+        if (subscription && subscription.listener === listener) {
+          subscription.remove();
+        }
+      }
+    }
+  }
+}
+//# sourceMappingURL=EventEmitter.js.map

package/lib/module/utils/emitter/EventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EmitterSubscription","EventSubscriptionVendor","sparseFilterPredicate","EventEmitter","constructor","subscriber","_defineProperty","_subscriber","addListener","eventType","listener","context","addSubscription","removeAllListeners","removeAllSubscriptions","removeSubscription","subscription","emitter","console","warn","listenerCount","subscriptions","getSubscriptionsForType","filter","length","emit","_len","arguments","args","Array","_key","i","l","apply","removeListener","remove"],"sources":["EventEmitter.ts"],"sourcesContent":["import { EmitterSubscription } from './_EmitterSubscription';\nimport { EventSubscriptionVendor } from './_EventSubscriptionVendor';\n\nconst sparseFilterPredicate = () => true;\n\nexport { EmitterSubscription } from './_EmitterSubscription';\n\n/**\n * @class EventEmitter\n * @description\n * An EventEmitter is responsible for managing a set of listeners and publishing\n * events to them when it is told that such events happened. In addition to the\n * data for the given event it also sends a event control object which allows\n * the listeners/handlers to prevent the default behavior of the given event.\n *\n * The emitter is designed to be generic enough to support all the different\n * contexts in which one might want to emit events. It is a simple multicast\n * mechanism on top of which extra functionality can be composed. For example, a\n * more advanced emitter may use an EventHolder and EventFactory.\n */\nexport class EventEmitter {\n  _subscriber: EventSubscriptionVendor;\n\n  /**\n   * @constructor\n   *\n   * @param {EventSubscriptionVendor} subscriber - Optional subscriber instance\n   *   to use. If omitted, a new subscriber will be created for the emitter.\n   */\n  constructor(subscriber?: EventSubscriptionVendor | null) {\n    this._subscriber = subscriber || new EventSubscriptionVendor();\n  }\n\n  /**\n   * Adds a listener to be invoked when events of the specified type are\n   * emitted. An optional calling context may be provided. The data arguments\n   * emitted will be passed to the listener function.\n   *\n   * TODO: Annotate the listener arg's type. This is tricky because listeners\n   *       can be invoked with varargs.\n   *\n   * @param {string} eventType - Name of the event to listen to\n   * @param {function} listener - Function to invoke when the specified event is\n   *   emitted\n   * @param {*} context - Optional context object to use when invoking the\n   *   listener\n   */\n  addListener(\n    eventType: string,\n    listener: Function,\n    context: Object | null | undefined\n  ): EmitterSubscription {\n    return this._subscriber.addSubscription(\n      eventType,\n      new EmitterSubscription(this, this._subscriber, listener, context)\n    ) as EmitterSubscription;\n  }\n\n  /**\n   * Removes all of the registered listeners, including those registered as\n   * listener maps.\n   *\n   * @param {?string} eventType - Optional name of the event whose registered\n   *   listeners to remove\n   */\n  removeAllListeners(eventType: string | undefined | null) {\n    this._subscriber.removeAllSubscriptions(eventType);\n  }\n\n  /**\n   * Removes a specific subscription. Called by the `remove()` method of the\n   * subscription itself to ensure any necessary cleanup is performed.\n   */\n  removeSubscription(subscription: EmitterSubscription) {\n    if (subscription.emitter !== this) {\n      console.warn('Subscription does not belong to this emitter.'); // TODO: use HMSLogger here\n      return;\n    }\n\n    this._subscriber.removeSubscription(subscription);\n  }\n\n  /**\n   * Returns the number of listeners that are currently registered for the given\n   * event.\n   *\n   * @param {string} eventType - Name of the event to query\n   * @returns {number}\n   */\n  listenerCount(eventType: string): number {\n    const subscriptions = this._subscriber.getSubscriptionsForType(eventType);\n    return subscriptions\n      ? // We filter out missing entries because the array is sparse.\n        // \"callbackfn is called only for elements of the array which actually\n        // exist; it is not called for missing elements of the array.\"\n        // https://www.ecma-international.org/ecma-262/9.0/index.html#sec-array.prototype.filter\n        subscriptions.filter(sparseFilterPredicate).length\n      : 0;\n  }\n\n  /**\n   * Emits an event of the given type with the given data. All handlers of that\n   * particular type will be notified.\n   *\n   * @param {string} eventType - Name of the event to emit\n   * @param {...*} Arbitrary arguments to be passed to each registered listener\n   *\n   * @example\n   *   emitter.addListener('someEvent', function(message) {\n   *     console.log(message);\n   *   });\n   *\n   *   emitter.emit('someEvent', 'abc'); // logs 'abc'\n   */\n  emit(eventType: string, ...args: any[]) {\n    const subscriptions = this._subscriber.getSubscriptionsForType(\n      eventType\n    ) as EmitterSubscription[] | null | undefined;\n    if (subscriptions) {\n      for (let i = 0, l = subscriptions.length; i < l; i++) {\n        const subscription = subscriptions[i];\n\n        // The subscription may have been removed during this event loop.\n        if (subscription && subscription.listener) {\n          subscription.listener.apply(subscription.context, args);\n        }\n      }\n    }\n  }\n\n  /**\n   * Removes the given listener for event of specific type.\n   *\n   * @param {string} eventType - Name of the event to emit\n   * @param {function} listener - Function to invoke when the specified event is\n   *   emitted\n   *\n   * @example\n   *   emitter.removeListener('someEvent', function(message) {\n   *     console.log(message);\n   *   }); // removes the listener if already registered\n   *\n   */\n  removeListener(eventType: string, listener: Function) {\n    const subscriptions = this._subscriber.getSubscriptionsForType(\n      eventType\n    ) as EmitterSubscription[] | null | undefined;\n    if (subscriptions) {\n      for (let i = 0, l = subscriptions.length; i < l; i++) {\n        const subscription = subscriptions[i];\n\n        // The subscription may have been removed during this event loop.\n        // its listener matches the listener in method parameters\n        if (subscription && subscription.listener === listener) {\n          subscription.remove();\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/module/utils/emitter/_EmitterSubscription.js

@@ -0,0 +1,39 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { EventSubscription } from './_EventSubscription';
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+export class EmitterSubscription extends EventSubscription {
+  /**
+   * @param {EventEmitter} emitter - The event emitter that registered this
+   *   subscription
+   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+   *   this subscription
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  constructor(emitter, subscriber, listener, context) {
+    super(subscriber);
+    _defineProperty(this, "emitter", void 0);
+    _defineProperty(this, "listener", void 0);
+    _defineProperty(this, "context", void 0);
+    this.emitter = emitter;
+    this.listener = listener;
+    this.context = context;
+  }
+
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * Note: we're overriding the `remove()` method of EventSubscription here
+   * but deliberately not calling `super.remove()` as the responsibility
+   * for removing the subscription lies with the EventEmitter.
+   */
+  remove() {
+    this.emitter.removeSubscription(this);
+  }
+}
+//# sourceMappingURL=_EmitterSubscription.js.map

package/lib/module/utils/emitter/_EmitterSubscription.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventSubscription","EmitterSubscription","constructor","emitter","subscriber","listener","context","_defineProperty","remove","removeSubscription"],"sources":["_EmitterSubscription.ts"],"sourcesContent":["import { EventSubscription } from './_EventSubscription';\nimport type { EventEmitter } from './EventEmitter';\nimport type { EventSubscriptionVendor } from './_EventSubscriptionVendor';\n\n/**\n * EmitterSubscription represents a subscription with listener and context data.\n */\nexport class EmitterSubscription extends EventSubscription {\n  emitter: EventEmitter;\n  listener: Function;\n  context: Object | null | undefined;\n\n  /**\n   * @param {EventEmitter} emitter - The event emitter that registered this\n   *   subscription\n   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls\n   *   this subscription\n   * @param {function} listener - Function to invoke when the specified event is\n   *   emitted\n   * @param {*} context - Optional context object to use when invoking the\n   *   listener\n   */\n  constructor(\n    emitter: EventEmitter,\n    subscriber: EventSubscriptionVendor,\n    listener: Function,\n    context: Object | undefined | null\n  ) {\n    super(subscriber);\n    this.emitter = emitter;\n    this.listener = listener;\n    this.context = context;\n  }\n\n  /**\n   * Removes this subscription from the emitter that registered it.\n   * Note: we're overriding the `remove()` method of EventSubscription here\n   * but deliberately not calling `super.remove()` as the responsibility\n   * for removing the subscription lies with the EventEmitter.\n   */\n  remove() {\n    this.emitter.removeSubscription(this);\n  }\n}\n"],"mappings":";;;AAAA,SAASA,iBAAiB,QAAQ,sBAAsB;AAIxD;AACA;AACA;AACA,OAAO,MAAMC,mBAAmB,SAASD,iBAAiB,CAAC;EAKzD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,WAAWA,CACTC,OAAqB,EACrBC,UAAmC,EACnCC,QAAkB,EAClBC,OAAkC,EAClC;IACA,KAAK,CAACF,UAAU,CAAC;IAACG,eAAA;IAAAA,eAAA;IAAAA,eAAA;IAClB,IAAI,CAACJ,OAAO,GAAGA,OAAO;IACtB,IAAI,CAACE,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACC,OAAO,GAAGA,OAAO;EACxB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEE,MAAMA,CAAA,EAAG;IACP,IAAI,CAACL,OAAO,CAACM,kBAAkB,CAAC,IAAI,CAAC;EACvC;AACF"}

package/lib/module/utils/emitter/_EventSubscription.js

@@ -0,0 +1,29 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+export class EventSubscription {
+  /**
+   * @param {EventSubscriptionVendor} subscriber the subscriber that controls
+   *   this subscription.
+   */
+  constructor(subscriber) {
+    // @ts-ignore this value is assigned after creating instance of class
+    _defineProperty(this, "eventType", void 0);
+    // @ts-ignore this value is assigned after creating instance of class
+    _defineProperty(this, "key", void 0);
+    _defineProperty(this, "subscriber", void 0);
+    this.subscriber = subscriber;
+  }
+
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+  remove() {
+    this.subscriber.removeSubscription(this);
+  }
+}
+//# sourceMappingURL=_EventSubscription.js.map

package/lib/module/utils/emitter/_EventSubscription.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventSubscription","constructor","subscriber","_defineProperty","remove","removeSubscription"],"sources":["_EventSubscription.ts"],"sourcesContent":["import type { EventSubscriptionVendor } from './_EventSubscriptionVendor';\n\n/**\n * EventSubscription represents a subscription to a particular event. It can\n * remove its own subscription.\n */\nexport class EventSubscription {\n  // @ts-ignore this value is assigned after creating instance of class\n  eventType: string;\n  // @ts-ignore this value is assigned after creating instance of class\n  key: number;\n  subscriber: EventSubscriptionVendor;\n\n  /**\n   * @param {EventSubscriptionVendor} subscriber the subscriber that controls\n   *   this subscription.\n   */\n  constructor(subscriber: EventSubscriptionVendor) {\n    this.subscriber = subscriber;\n  }\n\n  /**\n   * Removes this subscription from the subscriber that controls it.\n   */\n  remove() {\n    this.subscriber.removeSubscription(this);\n  }\n}\n"],"mappings":";;;AAEA;AACA;AACA;AACA;AACA,OAAO,MAAMA,iBAAiB,CAAC;EAO7B;AACF;AACA;AACA;EACEC,WAAWA,CAACC,UAAmC,EAAE;IAVjD;IAAAC,eAAA;IAEA;IAAAA,eAAA;IAAAA,eAAA;IASE,IAAI,CAACD,UAAU,GAAGA,UAAU;EAC9B;;EAEA;AACF;AACA;EACEE,MAAMA,CAAA,EAAG;IACP,IAAI,CAACF,UAAU,CAACG,kBAAkB,CAAC,IAAI,CAAC;EAC1C;AACF"}

package/lib/module/utils/emitter/_EventSubscriptionVendor.js

@@ -0,0 +1,83 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+export class EventSubscriptionVendor {
+  constructor() {
+    _defineProperty(this, "_subscriptionsForType", void 0);
+    _defineProperty(this, "_currentSubscription", void 0);
+    this._subscriptionsForType = {};
+    this._currentSubscription = null;
+  }
+
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   * @param {string} eventType
+   * @param {EventSubscription} subscription
+   */
+  addSubscription(eventType, subscription) {
+    if (subscription.subscriber !== this) {
+      console.warn('The subscriber of the subscription is incorrectly set.'); // TODO: throw error or use logger?
+    }
+
+    if (!this._subscriptionsForType[eventType]) {
+      this._subscriptionsForType[eventType] = [];
+    }
+    const eventSubscriptions = this._subscriptionsForType[eventType];
+    const key = eventSubscriptions.length;
+    eventSubscriptions.push(subscription);
+    subscription.eventType = eventType;
+    subscription.key = key;
+    return subscription;
+  }
+
+  /**
+   * Removes a bulk set of the subscriptions.
+   *
+   * @param {?string} eventType - Optional name of the event type whose
+   *   registered supscriptions to remove, if null or undefined remove all subscriptions.
+   */
+  removeAllSubscriptions(eventType) {
+    if (eventType === undefined || eventType === null) {
+      this._subscriptionsForType = {};
+    } else {
+      delete this._subscriptionsForType[eventType];
+    }
+  }
+
+  /**
+   * Removes a specific subscription. Instead of calling this function, call
+   * `subscription.remove()` directly.
+   *
+   * @param {object} subscription
+   */
+  removeSubscription(subscription) {
+    const eventType = subscription.eventType;
+    const key = subscription.key;
+    const subscriptionsForType = this._subscriptionsForType[eventType];
+    if (subscriptionsForType) {
+      delete subscriptionsForType[key];
+    }
+  }
+
+  /**
+   * Returns the array of subscriptions that are currently registered for the
+   * given event type.
+   *
+   * Note: This array can be potentially sparse as subscriptions are deleted
+   * from it when they are removed.
+   *
+   * TODO: This returns a nullable array. wat?
+   *
+   * @param {string} eventType
+   * @returns {?array}
+   */
+  getSubscriptionsForType(eventType) {
+    return this._subscriptionsForType[eventType];
+  }
+}
+//# sourceMappingURL=_EventSubscriptionVendor.js.map

package/lib/module/utils/emitter/_EventSubscriptionVendor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventSubscriptionVendor","constructor","_defineProperty","_subscriptionsForType","_currentSubscription","addSubscription","eventType","subscription","subscriber","console","warn","eventSubscriptions","key","length","push","removeAllSubscriptions","undefined","removeSubscription","subscriptionsForType","getSubscriptionsForType"],"sources":["_EventSubscriptionVendor.ts"],"sourcesContent":["import type { EventSubscription } from './_EventSubscription';\n\n/**\n * EventSubscriptionVendor stores a set of EventSubscriptions that are\n * subscribed to a particular event type.\n */\nexport class EventSubscriptionVendor {\n  _subscriptionsForType: Record<string, EventSubscription[] | null | undefined>;\n  _currentSubscription: EventSubscription | null | undefined;\n\n  constructor() {\n    this._subscriptionsForType = {};\n    this._currentSubscription = null;\n  }\n\n  /**\n   * Adds a subscription keyed by an event type.\n   *\n   * @param {string} eventType\n   * @param {EventSubscription} subscription\n   */\n  addSubscription(\n    eventType: string,\n    subscription: EventSubscription\n  ): EventSubscription {\n    if (subscription.subscriber !== this) {\n      console.warn('The subscriber of the subscription is incorrectly set.'); // TODO: throw error or use logger?\n    }\n    if (!this._subscriptionsForType[eventType]) {\n      this._subscriptionsForType[eventType] = [];\n    }\n    const eventSubscriptions = this._subscriptionsForType[\n      eventType\n    ] as EventSubscription[];\n    const key = eventSubscriptions.length;\n    eventSubscriptions.push(subscription);\n    subscription.eventType = eventType;\n    subscription.key = key;\n    return subscription;\n  }\n\n  /**\n   * Removes a bulk set of the subscriptions.\n   *\n   * @param {?string} eventType - Optional name of the event type whose\n   *   registered supscriptions to remove, if null or undefined remove all subscriptions.\n   */\n  removeAllSubscriptions(eventType: string | undefined | null) {\n    if (eventType === undefined || eventType === null) {\n      this._subscriptionsForType = {};\n    } else {\n      delete this._subscriptionsForType[eventType];\n    }\n  }\n\n  /**\n   * Removes a specific subscription. Instead of calling this function, call\n   * `subscription.remove()` directly.\n   *\n   * @param {object} subscription\n   */\n  removeSubscription(subscription: EventSubscription) {\n    const eventType = subscription.eventType;\n    const key = subscription.key;\n\n    const subscriptionsForType = this._subscriptionsForType[eventType];\n    if (subscriptionsForType) {\n      delete subscriptionsForType[key];\n    }\n  }\n\n  /**\n   * Returns the array of subscriptions that are currently registered for the\n   * given event type.\n   *\n   * Note: This array can be potentially sparse as subscriptions are deleted\n   * from it when they are removed.\n   *\n   * TODO: This returns a nullable array. wat?\n   *\n   * @param {string} eventType\n   * @returns {?array}\n   */\n  getSubscriptionsForType(\n    eventType: string\n  ): EventSubscription[] | null | undefined {\n    return this._subscriptionsForType[eventType];\n  }\n}\n"],"mappings":";;;AAEA;AACA;AACA;AACA;AACA,OAAO,MAAMA,uBAAuB,CAAC;EAInCC,WAAWA,CAAA,EAAG;IAAAC,eAAA;IAAAA,eAAA;IACZ,IAAI,CAACC,qBAAqB,GAAG,CAAC,CAAC;IAC/B,IAAI,CAACC,oBAAoB,GAAG,IAAI;EAClC;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEC,eAAeA,CACbC,SAAiB,EACjBC,YAA+B,EACZ;IACnB,IAAIA,YAAY,CAACC,UAAU,KAAK,IAAI,EAAE;MACpCC,OAAO,CAACC,IAAI,CAAC,wDAAwD,CAAC,CAAC,CAAC;IAC1E;;IACA,IAAI,CAAC,IAAI,CAACP,qBAAqB,CAACG,SAAS,CAAC,EAAE;MAC1C,IAAI,CAACH,qBAAqB,CAACG,SAAS,CAAC,GAAG,EAAE;IAC5C;IACA,MAAMK,kBAAkB,GAAG,IAAI,CAACR,qBAAqB,CACnDG,SAAS,CACa;IACxB,MAAMM,GAAG,GAAGD,kBAAkB,CAACE,MAAM;IACrCF,kBAAkB,CAACG,IAAI,CAACP,YAAY,CAAC;IACrCA,YAAY,CAACD,SAAS,GAAGA,SAAS;IAClCC,YAAY,CAACK,GAAG,GAAGA,GAAG;IACtB,OAAOL,YAAY;EACrB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEQ,sBAAsBA,CAACT,SAAoC,EAAE;IAC3D,IAAIA,SAAS,KAAKU,SAAS,IAAIV,SAAS,KAAK,IAAI,EAAE;MACjD,IAAI,CAACH,qBAAqB,GAAG,CAAC,CAAC;IACjC,CAAC,MAAM;MACL,OAAO,IAAI,CAACA,qBAAqB,CAACG,SAAS,CAAC;IAC9C;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEW,kBAAkBA,CAACV,YAA+B,EAAE;IAClD,MAAMD,SAAS,GAAGC,YAAY,CAACD,SAAS;IACxC,MAAMM,GAAG,GAAGL,YAAY,CAACK,GAAG;IAE5B,MAAMM,oBAAoB,GAAG,IAAI,CAACf,qBAAqB,CAACG,SAAS,CAAC;IAClE,IAAIY,oBAAoB,EAAE;MACxB,OAAOA,oBAAoB,CAACN,GAAG,CAAC;IAClC;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEO,uBAAuBA,CACrBb,SAAiB,EACuB;IACxC,OAAO,IAAI,CAACH,qBAAqB,CAACG,SAAS,CAAC;EAC9C;AACF"}

package/lib/module/utils/index.js

@@ -0,0 +1,2 @@
+export * from './emitter/EventEmitter';
+//# sourceMappingURL=index.js.map

package/lib/module/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from './emitter/EventEmitter';\n"],"mappings":"AAAA,cAAc,wBAAwB"}

package/lib/typescript/classes/HMSAudioTrackSettings.d.ts

@@ -1,11 +1,25 @@
+import type { HMSIOSAudioMode } from './HMSIOSAudioMode';
 import type { HMSTrackSettingsInitState } from './HMSTrackSettingsInitState';
+/**
+ * Customize local peer's Audio track settings before Joining the Room.
+ *
+ * Checkout Track Settings docs for more details {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/track/track-settings}
+ */
 export declare class HMSAudioTrackSettings {
     initialState?: HMSTrackSettingsInitState;
     useHardwareEchoCancellation?: boolean;
     audioSource?: string[];
+    /**
+     * [iOS only] `audioMode` allows you to capture audio in its highest quality
+     * by disabling voice processing and increasing the maximum bandwidth limit
+     *
+     * Checkout Music Mode docs for more details {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/configure-your-device/microphone/music-mode}
+     */
+    audioMode?: HMSIOSAudioMode;
     constructor(params: {
         initialState?: HMSTrackSettingsInitState;
         useHardwareEchoCancellation?: boolean;
         audioSource?: string[];
+        audioMode?: HMSIOSAudioMode;
     });
 }

package/lib/typescript/classes/HMSCameraControl.d.ts

@@ -0,0 +1,9 @@
+export declare class HMSCameraControl {
+    /**
+     * It captures the image from the device camera at max possible resolution.
+     *
+     * @param {boolean} [flash=false] flash - value indicating whether to use flash while capturing image or not
+     * @returns Promise - which is resolved with the file path of the captured image saved on the disk
+     */
+    static captureImageAtMaxSupportedResolution(flash?: boolean): Promise<string>;
+}

package/lib/typescript/classes/HMSEncoder.d.ts

@@ -28,10 +28,16 @@ import { HMSServerRecordingState } from './HMSServerRecordingState';
 import { HMSMessage } from './HMSMessage';
 import { HMSMessageRecipient } from './HMSMessageRecipient';
 import { HMSException } from './HMSException';
+import { HMSLocalAudioStats } from './HMSLocalAudioStats';
+import { HMSLocalVideoStats } from './HMSLocalVideoStats';
+import { HMSRemoteAudioStats } from './HMSRemoteAudioStats';
+import { HMSRemoteVideoStats } from './HMSRemoteVideoStats';
+import { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
+import { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 export declare class HMSEncoder {
     private static data;
     static clearData(): void;
-    static encodeHmsRoom(room: HMSRoom, id: string): HMSRoom;
+    static encodeHmsRoom(room: any, id: string): HMSRoom;
     static encodeHmsPeers(peers: any): HMSPeer[];
     static encodeHmsPeer(peer: any): HMSPeer;
     static encodeHmsPeerUpdate(hmsPeerUpdateOrdinal: string): import("./HMSPeerUpdate").HMSPeerUpdate | undefined;
@@ -69,4 +75,10 @@ export declare class HMSEncoder {
     static encodeHMSMessage(data: any): HMSMessage | undefined;
     static encodeHMSMessageRecipient(data: any): HMSMessageRecipient;
     static encodeHMSException(data: any): HMSException;
+    static encodeHMSLocalAudioStats(data: any): HMSLocalAudioStats;
+    static encodeHMSLocalVideoStats(data: any[]): HMSLocalVideoStats[];
+    static encodeHMSRemoteAudioStats(data: any): HMSRemoteAudioStats;
+    static encodeHMSRemoteVideoStats(data: any): HMSRemoteVideoStats;
+    static encodeHMSSimulcastLayerDefinition(data: any[]): HMSSimulcastLayerDefinition[];
+    static encodeHMSQualityLimitationReasons(data: any): HMSQualityLimitationReasons;
 }

package/lib/typescript/classes/HMSIOSAudioMode.d.ts

@@ -0,0 +1,4 @@
+export declare enum HMSIOSAudioMode {
+    VOICE = "voice",
+    MUSIC = "music"
+}

package/lib/typescript/classes/HMSLayer.d.ts

@@ -0,0 +1,5 @@
+export declare enum HMSLayer {
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH"
+}

package/lib/typescript/classes/HMSLocalVideoStats.d.ts

@@ -1,3 +1,5 @@
+import type { HMSLayer } from './HMSLayer';
+import type { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 import type { HMSVideoResolution } from './HMSVideoResolution';
 export declare class HMSLocalVideoStats {
     bitrate?: number;
@@ -5,11 +7,15 @@ export declare class HMSLocalVideoStats {
     roundTripTime?: number;
     frameRate?: number;
     resolution?: HMSVideoResolution;
+    qualityLimitationReasons?: HMSQualityLimitationReasons;
+    layer?: HMSLayer;
     constructor(params: {
         bitrate?: number;
         bytesSent?: number;
         roundTripTime?: number;
         frameRate?: number;
         resolution?: HMSVideoResolution;
+        qualityLimitationReasons?: HMSQualityLimitationReasons;
+        layer?: HMSLayer;
     });
 }

package/lib/typescript/classes/HMSPeer.d.ts

@@ -6,7 +6,7 @@ import type { HMSVideoTrack } from './HMSVideoTrack';
 export declare class HMSPeer {
     peerID: string;
     /**
-     * @deprecated customerDescription has been deprecated in favor of metadata
+     * @deprecated customerDescription property has been deprecated in favor of metadata property
      */
     customerDescription?: string;
     constructor(params: {

package/lib/typescript/classes/HMSPublishSettings.d.ts

@@ -1,14 +1,17 @@
 import type { HMSAudioSettings } from './HMSAudioSettings';
 import type { HMSVideoSettings } from './HMSVideoSettings';
+import type { HMSSimulcastSettings } from './HMSSimulcastSettings';
 export declare class HMSPublishSettings {
     audio?: HMSAudioSettings;
     video?: HMSVideoSettings;
     screen?: HMSVideoSettings;
     allowed?: string[];
+    simulcast?: HMSSimulcastSettings;
     constructor(params: {
         audio?: HMSAudioSettings;
         video?: HMSVideoSettings;
         screen?: HMSVideoSettings;
         allowed?: string[];
+        simulcast?: HMSSimulcastSettings;
     });
 }

package/lib/typescript/classes/HMSQualityLimitationReason.d.ts

@@ -0,0 +1,7 @@
+export declare enum HMSQualityLimitationReason {
+    BANDWIDTH = "BANDWIDTH",
+    CPU = "CPU",
+    NONE = "NONE",
+    OTHER = "OTHER",
+    UNKNOWN = "UNKNOWN"
+}

package/lib/typescript/classes/HMSQualityLimitationReasons.d.ts

@@ -0,0 +1,17 @@
+import type { HMSQualityLimitationReason } from './HMSQualityLimitationReason';
+export declare class HMSQualityLimitationReasons {
+    bandwidth?: number;
+    cpu?: number;
+    none?: number;
+    other?: number;
+    qualityLimitationResolutionChanges?: number;
+    reason: HMSQualityLimitationReason;
+    constructor(params: {
+        bandwidth?: number;
+        cpu?: number;
+        none?: number;
+        other?: number;
+        qualityLimitationResolutionChanges?: number;
+        reason: HMSQualityLimitationReason;
+    });
+}

package/lib/typescript/classes/HMSRemotePeer.d.ts

@@ -22,7 +22,6 @@ export declare class HMSRemotePeer extends HMSPeer {
             source?: number | string;
             trackDescription?: string;
             isMute?: boolean;
-            layer?: any;
             playbackAllowed?: boolean;
             id: string;
         };

package/lib/typescript/classes/HMSRemoteVideoTrack.d.ts

@@ -1,7 +1,8 @@
 import { HMSVideoTrack } from './HMSVideoTrack';
 import type { HMSTrackType } from './HMSTrackType';
+import type { HMSLayer } from './HMSLayer';
+import type { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
 export declare class HMSRemoteVideoTrack extends HMSVideoTrack {
-    layer?: any;
     /**
      * Switches Video of remote user on/off depending upon the value of playbackAllowed
      *
@@ -10,14 +11,17 @@ export declare class HMSRemoteVideoTrack extends HMSVideoTrack {
      */
     setPlaybackAllowed(playbackAllowed: boolean): void;
     isPlaybackAllowed: () => Promise<any>;
+    getLayer(): Promise<HMSLayer>;
+    getLayerDefinition(): Promise<HMSSimulcastLayerDefinition[]>;
+    setLayer(layer: HMSLayer): Promise<any>;
     constructor(params: {
         trackId: string;
         source?: number | string;
         trackDescription?: string;
         isMute?: boolean;
-        layer?: any;
         playbackAllowed?: boolean;
         id: string;
+        isDegraded?: boolean;
         type?: HMSTrackType;
     });
 }

package/lib/typescript/classes/HMSRoomUpdate.d.ts

@@ -5,5 +5,6 @@ export declare enum HMSRoomUpdate {
     RTMP_STREAMING_STATE_UPDATED = "RTMP_STREAMING_STATE_UPDATED",
     BROWSER_RECORDING_STATE_UPDATED = "BROWSER_RECORDING_STATE_UPDATED",
     HLS_STREAMING_STATE_UPDATED = "HLS_STREAMING_STATE_UPDATED",
-    HLS_RECORDING_STATE_UPDATED = "HLS_RECORDING_STATE_UPDATED"
+    HLS_RECORDING_STATE_UPDATED = "HLS_RECORDING_STATE_UPDATED",
+    ROOM_PEER_COUNT_UPDATED = "ROOM_PEER_COUNT_UPDATED"
 }