@formant/data-sdk 0.0.101 → 0.0.103

package/dist/data-sdk.es.js

@@ -19034,6 +19034,13 @@ class Device {
       throw new Error(`Already created realtime connection to device ${this.id}`);
     }
   }
+  async sendRealtimeMessage(message, config = {
+    channelLabel: "stream.reliable"
+  }) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.send(defined(devicePeer).id, message, config);
+  }
   addRealtimeListener(listener) {
     this.realtimeListeners.push(listener);
   }
@@ -19907,6 +19914,140 @@ class KeyValue {
     }
   }
 }
+function stringToArrayBuffer(input) {
+  return Uint8Array.from(atob(input), (_) => _.charCodeAt(0));
+}
+function fork(_) {
+  return void 0;
+}
+function browser() {
+  const { userAgent } = navigator;
+  if (userAgent.includes("Firefox/")) {
+    return "Firefox";
+  } else if (userAgent.includes("Edg/")) {
+    return "Edge";
+  } else if (userAgent.includes("Chrome/")) {
+    return "Chrome";
+  } else if (userAgent.includes("Safari/")) {
+    return "Safari";
+  } else if (userAgent.includes("MSIE/") || userAgent.includes("Trident/")) {
+    return "IE";
+  } else {
+    return "Other";
+  }
+}
+const rtcAudioChunkStreamType = "audio-chunk";
+class AudioPlayer {
+  constructor(device, stream) {
+    __publicField(this, "muted", false);
+    __publicField(this, "hasReceivedData", false);
+    __publicField(this, "audioContext");
+    __publicField(this, "chunks", []);
+    __publicField(this, "isPlaying", false);
+    __publicField(this, "startTime", 0);
+    __publicField(this, "lastChunkOffset", 0);
+    __publicField(this, "bufferSize", 3);
+    __publicField(this, "receive", async (msg) => {
+      var _a;
+      const data = (_a = msg.payload.audioChunk) == null ? void 0 : _a.chunk_data;
+      if (!data) {
+        return;
+      }
+      if (!this.hasReceivedData) {
+        this.hasReceivedData = true;
+      }
+      const { audioContext, muted } = this;
+      if (!audioContext || msg.header.stream.streamType !== rtcAudioChunkStreamType || muted !== false) {
+        return;
+      }
+      const arrayBuffer = stringToArrayBuffer(data);
+      try {
+        await audioContext.decodeAudioData(arrayBuffer.buffer, this.scheduleChunk);
+      } catch (error) {
+        console.warn("Error decoding audio buffer, changing audioWireFormat on agent", { error });
+        this.changeAudioWireFormat("wav");
+      }
+    });
+    __publicField(this, "scheduleChunk", (buffer) => {
+      const { audioContext } = this;
+      if (!audioContext) {
+        return;
+      }
+      if (this.chunks.length > this.bufferSize || this.isPlaying === false) {
+        this.chunks.forEach((c) => {
+          c.stop();
+        });
+        this.isPlaying = false;
+        this.chunks = [];
+      }
+      const chunk = this.createChunk(buffer);
+      if (!chunk) {
+        return;
+      }
+      if (!chunk.buffer) {
+        return;
+      }
+      if (this.isPlaying === false) {
+        this.startTime = audioContext.currentTime;
+        this.lastChunkOffset = 0;
+        this.isPlaying = true;
+      }
+      chunk.start(this.startTime + this.lastChunkOffset, 0, buffer.duration);
+      this.lastChunkOffset += chunk.buffer.duration;
+      this.chunks.push(chunk);
+    });
+    this.device = device;
+    this.stream = stream;
+    this.device.startListeningToRealtimeDataStream(stream);
+    this.device.addRealtimeListener((_peerId, msg) => {
+      this.receive(msg);
+    });
+    if (browser() === "Safari" || browser() === "IE") {
+      this.changeAudioWireFormat("wav");
+    } else {
+      this.changeAudioWireFormat("opus");
+    }
+    const AudioContext = window.AudioContext || window.webkitAudioContext;
+    this.audioContext = new AudioContext();
+  }
+  async play() {
+    var _a, _b;
+    if (((_a = this.audioContext) == null ? void 0 : _a.state) === "suspended") {
+      await ((_b = this.audioContext) == null ? void 0 : _b.resume());
+    }
+    this.muted = false;
+  }
+  async pause() {
+    await this.audioContext.suspend();
+    this.muted = true;
+  }
+  destroy() {
+    this.device.stopListeningToRealtimeDataStream(this.stream);
+  }
+  createChunk(buffer) {
+    const { audioContext } = this;
+    if (!audioContext) {
+      return;
+    }
+    const source = audioContext.createBufferSource();
+    source.buffer = buffer;
+    source.connect(audioContext.destination);
+    source.loop = false;
+    source.onended = (_) => {
+      this.chunks.splice(this.chunks.indexOf(source), 1);
+      if (this.chunks.length === 0) {
+        this.isPlaying = false;
+      }
+    };
+    return source;
+  }
+  changeAudioWireFormat(newFormat) {
+    const { stream } = this;
+    fork((async () => {
+      await this.device.changeStreamAudioType(stream.name, newFormat);
+    })());
+  }
+}
 const accessLevels = ["viewer", "operator", "administrator"];
 const viewer = "viewer";
 const operator = "operator";
@@ -19958,4 +20099,7 @@ const moduleName = urlParams.get("module");
 if (moduleName) {
   Authentication.listenForRefresh();
 }
-export { App, Authentication, BinaryRequestDataChannel, CaptureStream, DataChannel, Device, Fleet, KeyValue, Manipulator, PeerDevice, SessionType, TextRequestDataChannel, accessLevels, administrator, aggregateLevels, annotationTypes, eventTypes, healthStatuses, interventionTypes, operator, severities, videoMimeTypes, viewer };
+var IRtcSendConfiguration = dist.exports.IRtcSendConfiguration;
+var IRtcStreamMessage = dist.exports.IRtcStreamMessage;
+var IRtcStreamPayload = dist.exports.IRtcStreamPayload;
+export { App, AudioPlayer, Authentication, BinaryRequestDataChannel, CaptureStream, DataChannel, Device, Fleet, IRtcSendConfiguration, IRtcStreamMessage, IRtcStreamPayload, KeyValue, Manipulator, PeerDevice, SessionType, TextRequestDataChannel, accessLevels, administrator, aggregateLevels, annotationTypes, eventTypes, healthStatuses, interventionTypes, operator, severities, videoMimeTypes, viewer };