@reactoo/watchtogether-sdk-js 2.7.42 → 2.7.44-beta.1

package/dist/watchtogether-sdk.js

@@ -1,6 +1,6 @@
 /*!
  *  @reactoo/watchtogether-sdk-js
- *  @version 2.7.40
+ *  @version 2.7.43
  */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
@@ -16718,10 +16718,22 @@ let iot = function () {
       this.__privates.iot.log('Updating Credentials...');
       interruptCount = 0;
       isReconnecting = true;
-      return this.iot.getCredentials().then(response => this.__privates.iot.updateWebSocketCredentials(response.data.credentials.accessKeyId, response.data.credentials.secretAccessKey, response.data.credentials.sessionToken, response.data.credentials.expiration)).catch(error => {
-        this.__privates.iot.log('Failed to update credentials:', error);
+      this.iot.$emit('isReconnecting', isReconnecting);
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new Error('Updating Credentials Timeout...'));
+        }, 10000); // 10 seconds timeout is enough
+        this.iot.getCredentials().then(response => this.__privates.iot.updateWebSocketCredentials(response.data.credentials.accessKeyId, response.data.credentials.secretAccessKey, response.data.credentials.sessionToken, response.data.credentials.expiration)).then(() => {
+          clearTimeout(timeoutId);
+          resolve();
+        }).catch(error => {
+          clearTimeout(timeoutId);
+          this.__privates.iot.log('Failed to update credentials:', error);
+          reject(error);
+        });
       }).finally(() => {
         isReconnecting = false;
+        this.iot.$emit('isReconnecting', isReconnecting);
       });
     },
     getCredentials: () => {
@@ -16774,10 +16786,7 @@ let iot = function () {
           return Promise.all([response.data.suggestedTopics, _this.__privates.iot.connect(response.data.endpoint, response.data.clientId, response.data.region, response.data.credentials.accessKeyId, response.data.credentials.secretAccessKey, response.data.credentials.sessionToken, response.data.credentials.expiration)]);
         }).then(resolve).catch(reject);
       });
-      let __currentTopicsCopy = new Set(__currentTopics); // Keep this line
       __currentTopics.clear();
-      _this.iot.setupVisibilityChangeListener();
-      _this.iot.setupKeepAliveInterval();
       _this.iot.$on('connect', _this.iot.onConnect, _this);
       _this.iot.$on('closed', _this.iot.onClosed, _this);
       _this.iot.$on('error', _this.iot.onError, _this);
@@ -16792,8 +16801,12 @@ let iot = function () {
         if (!subscribeToSuggestedTopics) {
           return Promise.resolve(instance);
         }
-        let topics = new Set([...suggestedTopic, ...__currentTopicsCopy]); // Filter out any undefined or null topics
+        let topics = new Set([...suggestedTopic]); // Filter out any undefined or null topics
         return Promise.all(Array.from(topics).map(topic => _this.iot.subscribe(topic))).then(() => instance);
+      }).then(instance => {
+        _this.iot.setupVisibilityChangeListener();
+        _this.iot.setupKeepAliveInterval();
+        return instance;
       }).catch(error => {
         _this.__privates.iot.log('MQTT Login Error:', error);
         throw error;
@@ -16807,9 +16820,9 @@ let iot = function () {
       }
       interruptCount = 0;
       shouldBeConnected = false;
+      _this.iot.disableVisibilityChangeListener();
+      _this.iot.disableKeepAliveInterval();
       return _this.__privates.iot.disconnect().then(() => {
-        _this.iot.disableVisibilityChangeListener();
-        _this.iot.disableKeepAliveInterval();
         _this.iot.$off('connect', _this.iot.onConnect, _this);
         _this.iot.$off('closed', _this.iot.onClosed, _this);
         _this.iot.$off('error', _this.iot.onError, _this);
@@ -16829,16 +16842,22 @@ let iot = function () {
     subscribe: topic => {
       if (!__currentTopics.has(topic)) {
         __currentTopics.add(topic);
-        if (!this.iot.__promise) return Promise.resolve('not_connected');
+        if (!this.iot.__promise) return Promise.reject('not_connected');
         // if subscription fails, remove the topic from the current topics
-        return this.iot.__promise.then(() => !this.__privates.iot.subscribe(topic) && __currentTopics.delete(topic));
+        return this.iot.__promise.then(() => this.__privates.iot.subscribe(topic)).catch(() => {
+          __currentTopics.delete(topic);
+          return Promise.reject('subscription_failed');
+        });
       }
     },
     unsubscribe: topic => {
       __currentTopics.delete(topic);
-      if (!this.iot.__promise) return Promise.resolve('not_connected');
+      if (!this.iot.__promise) return Promise.reject('not_connected');
       // if unsubscription fails add the topic back to the current topics
-      return this.iot.__promise.then(() => !this.__privates.iot.unsubscribe(topic) && __currentTopics.add(topic));
+      return this.iot.__promise.then(() => this.__privates.iot.unsubscribe(topic)).catch(() => {
+        __currentTopics.add(topic);
+        return Promise.reject('unsubscription_failed');
+      });
     },
     send: (topic, message) => {
       return this.iot.__promise.then(() => this.__privates.iot.send(topic, message));
@@ -16855,9 +16874,15 @@ let iot = function () {
     $clear: () => {
       return this.__privates.iot.clear();
     },
+    $emit: function (key) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return _this.__privates.iot.emit(key, ...args);
+    },
     checkConnection: () => {
       return this.__privates.iot.checkConnection().catch(error => {
-        if (!shouldBeConnected || isReconnecting) {
+        if (!shouldBeConnected) {
           this.__privates.iot.log('Ignoring connection check failure, not connected');
           return Promise.resolve();
         }
@@ -25338,23 +25363,29 @@ class Iot {
   subscribe(topic) {
     this.log('iot subscribe', topic);
     if (this.connection && this.connection.currentState === 0 && this.connection.desiredState === 0 && typeof topic === 'string' && topic.trim() !== '') {
-      this.connection.subscribe(topic, aws_iot_device_sdk_v2__WEBPACK_IMPORTED_MODULE_2__.mqtt.QoS.AtLeastOnce);
       this.subscribedTopics.add(topic);
-      return true;
+      return this.connection.subscribe(topic, aws_iot_device_sdk_v2__WEBPACK_IMPORTED_MODULE_2__.mqtt.QoS.AtLeastOnce).catch(err => {
+        this.log('Error subscribing to topic:', err);
+        this.subscribedTopics.delete(topic);
+        return Promise.reject(err);
+      });
     } else {
       this.log('Invalid topic or not connected:', topic);
-      return false;
+      return Promise.reject(new Error('Invalid topic or not connected'));
     }
   }
   unsubscribe(topic) {
     this.log('iot unsubscribe', topic);
     if (this.connection && this.connection.currentState === 0 && this.connection.desiredState === 0 && typeof topic === 'string' && topic.trim() !== '') {
-      this.connection.unsubscribe(topic);
       this.subscribedTopics.delete(topic);
-      return true;
+      return this.connection.unsubscribe(topic).catch(err => {
+        this.log('Error unsubscribing from topic:', err);
+        this.subscribedTopics.add(topic);
+        return Promise.reject(err);
+      });
     } else {
       this.log('Invalid topic or not connected:', topic);
-      return false;
+      return Promise.reject(new Error('Invalid topic or not connected'));
     }
   }
   send(topic, message) {
@@ -25487,6 +25518,7 @@ class Iot {
     return this.connect(this.lastConnectParams.apiMqttUrl, this.lastConnectParams.apiMqttClientId, this.lastConnectParams.region, accessKeyId, secretAccessKey, sessionToken, expiration).then(() => {
       // Resubscribe to topics
       currentTopics.forEach(topic => this.subscribe(topic));
+      return true;
     });
   }
   checkConnection() {