@reactoo/watchtogether-sdk-js 2.7.49 → 2.7.50

package/dist/f8d53dc60757998a740a.js

@@ -0,0 +1,222 @@
+import { mqtt, iot } from 'aws-iot-device-sdk-v2';
+import { Buffer } from 'buffer';
+import process from 'process';
+
+// Provide a global object for the worker environment
+self.global = self;
+self.Buffer = Buffer;
+self.process = process;
+console.log('Worker: Starting up');
+let connection = null;
+self.onmessage = function (event) {
+  const {
+    type,
+    params,
+    topic,
+    message
+  } = event.data;
+  console.log(`Worker: Received message of type: ${type}`);
+  switch (type) {
+    case 'connect':
+      connect(params);
+      break;
+    case 'disconnect':
+      disconnect();
+      break;
+    case 'is_connected':
+      isConnected();
+      break;
+    case 'clear_topics':
+      // No action needed in the worker
+      break;
+    case 'subscribe':
+      subscribe(topic);
+      break;
+    case 'unsubscribe':
+      unsubscribe(topic);
+      break;
+    case 'send':
+      send(topic, message);
+      break;
+  }
+};
+function connect(params) {
+  console.log('Worker: Attempting to connect');
+  const {
+    apiMqttUrl,
+    apiMqttClientId,
+    region,
+    accessKeyId,
+    secretAccessKey,
+    sessionToken
+  } = params;
+  const configBuilder = iot.AwsIotMqttConnectionConfigBuilder.new_with_websockets();
+  configBuilder.with_clean_session(true);
+  configBuilder.with_client_id(apiMqttClientId);
+  configBuilder.with_endpoint(apiMqttUrl);
+  configBuilder.with_credentials(region, accessKeyId, secretAccessKey, sessionToken);
+  configBuilder.with_keep_alive_seconds(30);
+  configBuilder.with_ping_timeout_ms(3000);
+  configBuilder.with_reconnect_max_sec(5);
+  configBuilder.with_reconnect_min_sec(1);
+  const config = configBuilder.build();
+  const client = new mqtt.MqttClient();
+  connection = client.new_connection(config);
+  setupConnectionListeners();
+  connection.connect().then(() => {
+    console.log('Worker: Connection successful');
+    self.postMessage({
+      type: 'connect_result',
+      success: true
+    });
+  }).catch(error => {
+    console.error('Worker: Connection failed', error);
+    self.postMessage({
+      type: 'connect_result',
+      success: false,
+      error: error.message
+    });
+  });
+}
+function disconnect() {
+  if (connection) {
+    connection.disconnect().then(() => {
+      self.postMessage({
+        type: 'disconnect_result',
+        success: true
+      });
+    }).catch(error => {
+      self.postMessage({
+        type: 'disconnect_result',
+        success: false,
+        error: error.message
+      });
+    });
+  } else {
+    self.postMessage({
+      type: 'disconnect_result',
+      success: true
+    });
+  }
+}
+function isConnected() {
+  const connected = connection && connection.currentState === 0 && connection.desiredState === 0;
+  self.postMessage({
+    type: 'is_connected_result',
+    connected
+  });
+}
+function subscribe(topic) {
+  if (connection && connection.currentState === 0 && connection.desiredState === 0) {
+    connection.subscribe(topic, mqtt.QoS.AtLeastOnce).then(() => {
+      self.postMessage({
+        type: 'subscribe_result',
+        success: true
+      });
+    }).catch(error => {
+      self.postMessage({
+        type: 'subscribe_result',
+        success: false,
+        error: error.message
+      });
+    });
+  } else {
+    self.postMessage({
+      type: 'subscribe_result',
+      success: false,
+      error: 'Not connected'
+    });
+  }
+}
+function unsubscribe(topic) {
+  if (connection && connection.currentState === 0 && connection.desiredState === 0) {
+    connection.unsubscribe(topic).then(() => {
+      self.postMessage({
+        type: 'unsubscribe_result',
+        success: true
+      });
+    }).catch(error => {
+      self.postMessage({
+        type: 'unsubscribe_result',
+        success: false,
+        error: error.message
+      });
+    });
+  } else {
+    self.postMessage({
+      type: 'unsubscribe_result',
+      success: false,
+      error: 'Not connected'
+    });
+  }
+}
+function send(topic, message) {
+  if (connection && connection.currentState === 0 && connection.desiredState === 0) {
+    connection.publish(topic, message, mqtt.QoS.AtLeastOnce, false);
+  } else {
+    console.error('Cannot send message: Not connected');
+  }
+}
+function setupConnectionListeners() {
+  connection.on('connect', () => {
+    self.postMessage({
+      type: 'connect'
+    });
+  });
+  connection.on('disconnect', () => {
+    self.postMessage({
+      type: 'disconnect'
+    });
+  });
+  connection.on('error', error => {
+    self.postMessage({
+      type: 'error',
+      data: error
+    });
+  });
+  connection.on('interrupt', error => {
+    self.postMessage({
+      type: 'interrupt',
+      data: error
+    });
+  });
+  connection.on('resume', error => {
+    self.postMessage({
+      type: 'resume',
+      data: error
+    });
+  });
+  connection.on('message', (topic, payload) => {
+    self.postMessage({
+      type: 'message',
+      data: {
+        topic,
+        payload
+      }
+    });
+  });
+  connection.on('connection_success', error => {
+    self.postMessage({
+      type: 'connection_success',
+      data: error
+    });
+  });
+  connection.on('connection_failure', error => {
+    self.postMessage({
+      type: 'connection_failure',
+      data: error
+    });
+  });
+
+  // Add a general error handler for uncaught exceptions
+  self.addEventListener('error', error => {
+    console.error('Worker: Uncaught error', error);
+    self.postMessage({
+      type: 'uncaught_error',
+      error: error.message
+    });
+  });
+}
+
+// Add this at the end of the file
+console.log('Worker: Setup complete');