@stormstreaming/stormstreamer 0.9.0-beta.2 → 0.9.0-beta.3

package/dist/amd/index.js

@@ -4,8 +4,8 @@
  * contact@stormstreaming.com
  * https://stormstreaming.com
  *
- * Version: 0.9.0-beta.2
- * Version: 11/29/2024, 6:55:47 PM
+ * Version: 0.9.0-beta.3
+ * Version: 12/5/2024, 2:36:50 PM
  *
  * LEGAL NOTICE:
  * This software is subject to the terms and conditions defined in
@@ -1626,6 +1626,13 @@
           this.dispatchVolumeEvent();
         };
         this._videoElement.onpause = () => {};
+        this._videoElement.addEventListener('loadedmetadata', () => {
+          this._main.dispatchEvent("metadata", {
+            ref: this._main,
+            videoWidth: this._videoElement.videoWidth,
+            videoHeight: this._videoElement.videoHeight
+          });
+        });
         this._videoElement.ontimeupdate = function (event) {};
         this._videoElement.onended = event => {
           this._logger.info(this, "VideoElement :: onended");
@@ -1703,7 +1710,9 @@
         this._videoHeight = 0;
         this._scalingMode = ScalingType.FILL;
         this.isInFullScreenMode = false;
+        this._isResizing = false;
         this._autoResizeEnabled = true;
+        this._parentOriginalOverflow = '';
         this.onFullScreenChange = () => {
           if (document.fullscreenElement == null) {
             this.isInFullScreenMode = false;
@@ -1719,35 +1728,6 @@
             });
           }
         };
-        this.onResize = () => {
-          if (this._parentElement != null) {
-            const calcMethod = this._main.getConfigManager().getSettingsData().getVideoData().parentSizeCalculationMethod;
-            this._videoContainer.style.display = "none";
-            switch (calcMethod) {
-              case SizeCalculationType.CLIENT_DIMENSIONS:
-                this._tempContainerWidth = this._parentElement.clientWidth;
-                this._tempContainerHeight = this._parentElement.clientHeight;
-                break;
-              case SizeCalculationType.BOUNDING_BOX:
-                this._tempContainerWidth = this._parentElement.getBoundingClientRect().width;
-                this._tempContainerHeight = this._parentElement.getBoundingClientRect().height;
-                break;
-              case SizeCalculationType.FULL_BOX:
-                this._tempContainerWidth = DomUtilities.calculateDimensionsWithMargins(this._parentElement).width;
-                this._tempContainerHeight = DomUtilities.calculateDimensionsWithMargins(this._parentElement).height;
-                break;
-            }
-            this._logger.info(this, "onResize called: " + this._tempContainerWidth + "x" + this._tempContainerHeight + " (" + calcMethod + ")");
-            this.resizeVideoContainer();
-            this.scaleVideo();
-            this._videoContainer.style.display = "block";
-            this._main.dispatchEvent("resizeUpdate", {
-              ref: this._main,
-              width: this._tempContainerWidth,
-              height: this._tempContainerHeight
-            });
-          }
-        };
         this._main = main;
         this._logger = main.getLogger();
         this._logger.info(this, "Creating new StageController");
@@ -1767,14 +1747,14 @@
         const debounceValue = this._main.getConfigManager().getSettingsData().getVideoData().resizeDebounce;
         if (debounceValue > 0) {
           this._resizeObserver = new ResizeObserver(debounce$1(() => () => {
-            if (this._autoResizeEnabled) this.onResize();
+            if (this._autoResizeEnabled) this.handleResize();
           }, debounceValue, {
             leading: false,
             trailing: true
           }));
         } else {
           this._resizeObserver = new ResizeObserver(() => {
-            if (this._autoResizeEnabled) this.onResize();
+            if (this._autoResizeEnabled) this.handleResize();
           });
         }
         document.addEventListener('fullscreenchange', this.onFullScreenChange, false);
@@ -1782,6 +1762,11 @@
         document.addEventListener('mozfullscreenchange', this.onFullScreenChange, false);
         document.addEventListener('webkitendfullscreen', this.onFullScreenChange, false);
         this._screenElement.getVideoElement().addEventListener('webkitendfullscreen', this.onFullScreenChange, false);
+        this._main.addEventListener("metadata", event => {
+          this._videoWidth = event.videoWidth;
+          this._videoHeight = event.videoHeight;
+          this.handleResize();
+        }, false);
         if (containerID) {
           this.attachToParent(containerID);
         } else this._logger.warning(this, `Could not create HTMLObject for the library - "containerID" was not provided`);
@@ -1789,7 +1774,6 @@
       attachToParent(container) {
         let result = false;
         let tempParentElement = null;
-        console.log("xxxxxxxxx", container);
         if (typeof container === "string") {
           this._logger.info(this, "Attaching container to ID: " + container);
           tempParentElement = document.getElementById(container);
@@ -1807,13 +1791,13 @@
           this._parentElement.appendChild(this._videoContainer);
           this._resizeObserver.observe(this._parentElement);
           this._parentElement.addEventListener("transitionend", () => {
-            this.onResize();
+            this.handleResize();
           });
           this._main.dispatchEvent("containerChange", {
             ref: this._main,
             container: this._parentElement
           });
-          this.onResize();
+          this.handleResize();
           result = true;
         } else {
           console.log("tempParentElement", tempParentElement);
@@ -1831,7 +1815,7 @@
             this._resizeObserver.unobserve(this._parentElement);
             this._resizeObserver.disconnect();
           }
-          if (this._autoResizeEnabled) this._parentElement.removeEventListener("transitionend", this.onResize);
+          if (this._autoResizeEnabled) this._parentElement.removeEventListener("transitionend", this.handleResize);
           this._main.dispatchEvent("containerChange", {
             ref: this._main,
             container: null
@@ -1843,6 +1827,46 @@
         this._parentElement = null;
         return result;
       }
+      handleResize() {
+        if (!this._parentElement || this._isResizing) return;
+        this._isResizing = true;
+        this._parentOriginalOverflow = this._parentElement.style.overflow;
+        this._parentElement.style.overflow = 'hidden';
+        requestAnimationFrame(() => {
+          this.calculateNewDimensions();
+          this._parentElement.style.overflow = this._parentOriginalOverflow;
+          this._isResizing = false;
+          if (this._tempContainerWidth !== this._containerWidth || this._tempContainerHeight !== this._containerHeight) {
+            this._main.dispatchEvent("resizeUpdate", {
+              ref: this._main,
+              width: this._tempContainerWidth,
+              height: this._tempContainerHeight
+            });
+          }
+        });
+      }
+      calculateNewDimensions() {
+        const calcMethod = this._main.getConfigManager().getSettingsData().getVideoData().parentSizeCalculationMethod;
+        switch (calcMethod) {
+          case SizeCalculationType.CLIENT_DIMENSIONS:
+            this._tempContainerWidth = this._parentElement.clientWidth;
+            this._tempContainerHeight = this._parentElement.clientHeight;
+            break;
+          case SizeCalculationType.BOUNDING_BOX:
+            const rect = this._parentElement.getBoundingClientRect();
+            this._tempContainerWidth = rect.width;
+            this._tempContainerHeight = rect.height;
+            break;
+          case SizeCalculationType.FULL_BOX:
+            const dims = DomUtilities.calculateDimensionsWithMargins(this._parentElement);
+            this._tempContainerWidth = dims.width;
+            this._tempContainerHeight = dims.height;
+            break;
+        }
+        this._logger.info(this, `New dimensions calculated: ${this._tempContainerWidth}x${this._tempContainerHeight} (${calcMethod})`);
+        this.resizeVideoContainer();
+        this.scaleVideo();
+      }
       resizeVideoContainer() {
         const isWidthInPX = this._main.getConfigManager().getSettingsData().getVideoData().videoWidthInPixels;
         const isHeightInPX = this._main.getConfigManager().getSettingsData().getVideoData().videoHeightInPixels;
@@ -1877,8 +1901,6 @@
         }
         this._containerWidth = Math.ceil(finalVideoWidth);
         this._containerHeight = Math.ceil(finalVideoHeight);
-        this._videoWidth = this._containerWidth;
-        this._videoHeight = this._containerHeight;
         if (this._videoContainer !== null) {
           this._videoContainer.style.width = this._containerWidth + "px";
           this._videoContainer.style.height = this._containerHeight + "px";
@@ -2056,6 +2078,38 @@
     }
     StageController.LOG_ACTIVITY = true;
 
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol */
+
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
     class MungeSDP {
       constructor() {}
       addAudio(sdpStr, audioLine) {
@@ -2408,50 +2462,78 @@
 
     class SoundMeter {
       constructor(main) {
+        this._stream = null;
+        this._audioContext = null;
+        this._analyser = null;
+        this._microphone = null;
+        this._lastEventTime = 0;
+        this.THROTTLE_INTERVAL = 100;
         this._instant = 0.0;
         this._slow = 0.0;
-        this.clip = 0.0;
+        this._clip = 0.0;
         this._main = main;
       }
       attach(stream) {
         this._stream = stream;
-        this.audioContext = new AudioContext();
-        this.microphone = this.audioContext.createMediaStreamSource(stream);
-        this.processor = this.audioContext.createScriptProcessor(2048, 1, 1);
-        this.microphone.connect(this.processor);
-        this.processor.connect(this.audioContext.destination);
-        this.processor.onaudioprocess = event => {
-          this.onAudioProcess(event);
-        };
+        this._audioContext = new AudioContext();
+        this._microphone = this._audioContext.createMediaStreamSource(stream);
+        this._analyser = this._audioContext.createAnalyser();
+        this._analyser.fftSize = 2048;
+        this._analyser.smoothingTimeConstant = 0.3;
+        this._microphone.connect(this._analyser);
+        this.startMonitoring();
       }
       detach() {
-        if (this.microphone !== null) this.microphone.disconnect();
-        if (this.processor !== null) this.processor.disconnect();
+        if (this._microphone) {
+          this._microphone.disconnect();
+          this._microphone = null;
+        }
+        if (this._analyser) {
+          this._analyser.disconnect();
+          this._analyser = null;
+        }
+        if (this._audioContext) {
+          this._audioContext.close();
+          this._audioContext = null;
+        }
+        this._stream = null;
+        this.clear();
       }
       clear() {
         this._instant = 0;
         this._slow = 0;
-        this.clip = 0;
-      }
-      onAudioProcess(event) {
-        const input = event.inputBuffer.getChannelData(0);
-        let i;
-        let sum = 0.0;
-        let clipcount = 0;
-        for (i = 0; i < input.length; ++i) {
-          sum += input[i] * input[i];
-          if (Math.abs(input[i]) > 0.99) {
-            clipcount += 1;
-          }
-        }
-        this._instant = Math.sqrt(sum / input.length);
-        this._slow = 0.05 * this._instant + 0.95 * this._slow;
-        this.clip = clipcount / input.length;
-        this._main.dispatchEvent("soundMeter", {
-          ref: this._main,
-          high: this._instant,
-          low: this._slow
-        });
+        this._clip = 0;
+      }
+      startMonitoring() {
+        if (!this._analyser) return;
+        const dataArray = new Float32Array(this._analyser.frequencyBinCount);
+        const analyze = () => {
+          if (!this._analyser) return;
+          const now = Date.now();
+          this._analyser.getFloatTimeDomainData(dataArray);
+          let sum = 0.0;
+          let clipcount = 0;
+          for (let i = 0; i < dataArray.length; ++i) {
+            const amplitude = dataArray[i];
+            sum += amplitude * amplitude;
+            if (Math.abs(amplitude) > 0.99) {
+              clipcount += 1;
+            }
+          }
+          this._instant = Math.sqrt(sum / dataArray.length);
+          this._slow = 0.05 * this._instant + 0.95 * this._slow;
+          this._clip = clipcount / dataArray.length;
+          if (now - this._lastEventTime >= this.THROTTLE_INTERVAL) {
+            this._lastEventTime = now;
+            this._main.dispatchEvent("soundMeter", {
+              ref: this._main,
+              high: this._instant,
+              low: this._slow
+            });
+          }
+          requestAnimationFrame(analyze);
+        };
+        requestAnimationFrame(analyze);
       }
     }
 
@@ -2462,6 +2544,7 @@
           'iceServers': []
         };
         this._isMicrophoneMuted = false;
+        this._pendingMicrophoneState = null;
         this._constraints = {
           video: {
             width: {
@@ -2485,6 +2568,9 @@
         this._publishState = exports.PublishState.NOT_INITIALIZED;
         this.onServerDisconnect = () => {};
         this.onServerConnect = () => {
+          if (this._peerConnection) {
+            this.closeWebRTCConnection();
+          }
           this._peerConnection = new RTCPeerConnection(this._peerConnectionConfig);
           this._peerConnection.onicecandidate = event => {
             this.onIceCandidate(event);
@@ -2493,17 +2579,21 @@
             this.onConnectionStateChange(event);
           };
           this._peerConnection.onnegotiationneeded = event => {
-            this._peerConnection.createOffer(description => {
-              this.onDescriptionSuccess(description);
-            }, error => {
-              this.onDescriptionError(error);
-            }).catch(reason => {
-              console.log(reason);
-            });
+            if (this._peerConnection) {
+              this._peerConnection.createOffer(description => {
+                this.onDescriptionSuccess(description);
+              }, error => {
+                this.onDescriptionError(error);
+              }).catch(reason => {
+                console.log(reason);
+              });
+            }
           };
-          let localTracks = this._stream.getTracks();
-          for (let localTrack in localTracks) {
-            this._peerConnection.addTrack(localTracks[localTrack], this._stream);
+          if (this._stream) {
+            let localTracks = this._stream.getTracks();
+            for (let localTrack in localTracks) {
+              this._peerConnection.addTrack(localTracks[localTrack], this._stream);
+            }
           }
         };
         this.onDescriptionSuccess = description => {
@@ -2521,12 +2611,14 @@
             videoCodec: "42e01f",
             audioCodec: "opus"
           });
-          this._peerConnection.setLocalDescription(description).then(() => {
-            var _a;
-            (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.sendMessage('{"direction":"publish", "command":"sendOffer", "streamInfo":' + JSON.stringify(streamInfo) + ', "sdp":' + JSON.stringify(description) + '}');
-          }).catch(error => {
-            console.log(error);
-          });
+          if (this._peerConnection) {
+            this._peerConnection.setLocalDescription(description).then(() => {
+              var _a;
+              (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.sendMessage('{"direction":"publish", "command":"sendOffer", "streamInfo":' + JSON.stringify(streamInfo) + ', "sdp":' + JSON.stringify(description) + '}');
+            }).catch(error => {
+              console.log(error);
+            });
+          }
         };
         this.visibilityChange = () => {
           if (document.visibilityState === 'hidden') {
@@ -2555,7 +2647,7 @@
         this.initialize();
       }
       initialize() {
-        var _a, _b, _c;
+        var _a, _b;
         this._main.addEventListener("serverConnect", this.onServerConnect, false);
         this._main.addEventListener("serverDisconnect", this.onServerDisconnect, false);
         document.addEventListener("visibilitychange", this.visibilityChange);
@@ -2564,89 +2656,174 @@
         if ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData().autoConnect) {
           this._logger.info(this, "Initializing NetworkController (autoConnect is true)");
           (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.initialize();
-        } else this._logger.warning(this, "Warning - autoConnect is set to false, switching to standby mode!");
-        if (((_c = this._main.getConfigManager()) === null || _c === void 0 ? void 0 : _c.getStreamData().streamKey) != null) this.startWebRTC();
-      }
-      startWebRTC() {
-        try {
-          if (navigator.mediaDevices.getUserMedia) {
-            navigator.mediaDevices.getUserMedia(this._constraints).then(stream => {
-              this.onUserMediaSuccess(stream);
-            }).catch(error => {
-              this.onUserMediaError(error);
-            });
-          } else {
-            this._logger.error(this, "WebRTCStreamer :: Browser does not support WebRTC");
-            this._main.dispatchEvent("compatibilityError", {
-              ref: this._main,
-              message: "WebRTC is not supported"
-            });
-          }
-        } catch (error) {
-          this.onUserMediaError(error);
+        } else {
+          this._logger.warning(this, "Warning - autoConnect is set to false, switching to standby mode!");
         }
+        this.startCamera().then(() => {
+          var _a;
+          if (((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey) != null) {
+            this.initializeWebRTC();
+          }
+        });
       }
-      publish(streamKey) {
-        if (this._publishState == exports.PublishState.PUBLISHED) this.closeStream();
-        this._main.getConfigManager().getStreamData().streamKey = streamKey;
-        this.startWebRTC();
-      }
-      unpublish() {
-        this.closeStream();
-      }
-      onUserMediaSuccess(stream) {
-        var _a;
-        console.log('%c⏵ 🎥 onUserMediaSuccess', 'background: green; color: white;');
-        this._logger.success(this, "WebRTCStreamer :: WebRTC UserMedia successfully retrieved");
+      onCameraStreamSuccess(stream) {
+        this._logger.success(this, "Camera stream successfully retrieved");
         this._stream = stream;
-        this._soundMeter.attach(this._stream);
-        this.setPublishState(exports.PublishState.INITIALIZED);
-        if (this._cameraList == null || this._microphoneList == null) this.grabDevices();
+        if (this._pendingMicrophoneState !== null) {
+          this.applyMicrophoneState(this._pendingMicrophoneState);
+          this._pendingMicrophoneState = null;
+        } else {
+          this.applyMicrophoneState(!this._isMicrophoneMuted);
+        }
+        if (this._stream.getAudioTracks().length > 0) {
+          this._soundMeter.attach(this._stream);
+        }
+        if (this._cameraList == null || this._microphoneList == null) {
+          this.grabDevices();
+        }
         const videoElement = this._main.getStageController().getScreenElement().getVideoElement();
         videoElement.srcObject = stream;
         videoElement.autoplay = true;
         videoElement.playsInline = true;
         videoElement.disableRemotePlayback = true;
         videoElement.controls = false;
-        (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.start();
+        videoElement.muted = true;
+        this.setPublishState(exports.PublishState.INITIALIZED);
+      }
+      initializeWebRTC() {
+        var _a;
+        if (!this._stream) {
+          this._logger.error(this, "Cannot initialize WebRTC - no camera stream available");
+          return;
+        }
+        if (this._peerConnection) {
+          this._logger.info(this, "WebRTC connection already exists, updating stream");
+          this.updateWebRTCStream();
+        } else {
+          this._logger.info(this, "Initializing new WebRTC connection");
+          (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.start();
+        }
+      }
+      publish(streamKey) {
+        if (!this.isStreamReady(true, true)) {
+          this._logger.warning(this, "Cannot publish - stream not ready (missing video or audio track)");
+          return false;
+        }
+        this.closeWebRTCConnection();
+        this._main.getConfigManager().getStreamData().streamKey = streamKey;
+        this._main.dispatchEvent("publish", {
+          ref: this._main,
+          streamKey: streamKey
+        });
+        this.initializeWebRTC();
+        return true;
+      }
+      unpublish() {
+        this._main.getConfigManager().getStreamData().streamKey = null;
+        this._main.dispatchEvent("unpublish", {
+          ref: this._main
+        });
+        this.closeStream();
       }
       onUserMediaError(error) {
         console.log('%c⏵ 🎥 onUserMediaError: ' + JSON.stringify(error), 'background: green; color: white;');
-        switch (error.message) {
-          case "Permission denied":
-            this._logger.warning(this, "WebRTCStreamer :: No permission to access camera & microphone");
-            this._main.dispatchEvent("inputDeviceDenied", {
+        const errorName = error.name || '';
+        const errorMessage = error.message || '';
+        if (error.deviceType) {
+          if (error.deviceType === 'video') {
+            this._main.dispatchEvent("cameraAccessDenied", {
               ref: this._main
             });
-            break;
-          case "The request is not allowed by the user agent or the platform in the current context, possibly because the user denied permission.":
-            this._logger.warning(this, "WebRTCStreamer :: No permission to access camera & microphone");
-            this._main.dispatchEvent("inputDeviceDenied", {
+          } else if (error.deviceType === 'audio') {
+            this._main.dispatchEvent("microphoneAccessDenied", {
               ref: this._main
             });
-            break;
-          case "The request is not allowed by the user agent or the platform in the current context.":
-            this._logger.warning(this, "WebRTCStreamer :: No permission to access camera & microphone");
-            this._main.dispatchEvent("inputDeviceDenied", {
-              ref: this._main
-            });
-            break;
-          case "The object can not be found here.":
-            this._logger.warning(this, "WebRTCStreamer :: Could not access camera or microphone");
-            this._main.dispatchEvent("inputDeviceError", {
-              ref: this._main
+          }
+          this.grabDevices();
+          return;
+        }
+        if (errorName === 'NotAllowedError' || errorMessage.includes('Permission denied') || errorMessage.includes('not allowed')) {
+          this.checkIndividualDeviceAccess().then(results => {
+            if (!results.camera && !results.microphone) {
+              this._main.dispatchEvent("cameraAccessDenied", {
+                ref: this._main
+              });
+              this._main.dispatchEvent("microphoneAccessDenied", {
+                ref: this._main
+              });
+            } else {
+              if (!results.camera) {
+                this._main.dispatchEvent("cameraAccessDenied", {
+                  ref: this._main
+                });
+              }
+              if (!results.microphone) {
+                this._main.dispatchEvent("microphoneAccessDenied", {
+                  ref: this._main
+                });
+              }
+            }
+            this.grabDevices();
+          });
+          return;
+        }
+        if (errorName === 'NotFoundError' || errorMessage.includes('Requested device not found')) {
+          this.checkDeviceAvailability().then(results => {
+            if (!results.camera) {
+              this._main.dispatchEvent("noCameraFound", {
+                ref: this._main
+              });
+            }
+            if (!results.microphone) {
+              this._main.dispatchEvent("noMicrophoneFound", {
+                ref: this._main
+              });
+            }
+            this.grabDevices();
+          });
+          return;
+        }
+        this._logger.warning(this, "WebRTCStreamer :: Unsupported onUserMediaError: " + errorMessage);
+        this._main.dispatchEvent("inputDeviceError", {
+          ref: this._main
+        });
+        this.grabDevices();
+      }
+      checkIndividualDeviceAccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+          const results = {
+            camera: false,
+            microphone: false
+          };
+          try {
+            const videoStream = yield navigator.mediaDevices.getUserMedia({
+              video: true
             });
-            break;
-          case "Requested device not found":
-            this._logger.warning(this, "WebRTCStreamer :: Could not access camera or microphone");
-            this._main.dispatchEvent("inputDeviceError", {
-              ref: this._main
+            results.camera = true;
+            videoStream.getTracks().forEach(track => track.stop());
+          } catch (e) {
+            results.camera = false;
+          }
+          try {
+            const audioStream = yield navigator.mediaDevices.getUserMedia({
+              audio: true
             });
-            break;
-          default:
-            this._logger.warning(this, "WebRTCStreamer :: Unsupported onUserMediaError: " + error.message);
-            break;
-        }
+            results.microphone = true;
+            audioStream.getTracks().forEach(track => track.stop());
+          } catch (e) {
+            results.microphone = false;
+          }
+          return results;
+        });
+      }
+      checkDeviceAvailability() {
+        return __awaiter(this, void 0, void 0, function* () {
+          const devices = yield navigator.mediaDevices.enumerateDevices();
+          return {
+            camera: devices.some(device => device.kind === 'videoinput'),
+            microphone: devices.some(device => device.kind === 'audioinput')
+          };
+        });
       }
       onSocketMessage(data) {
         let msgJSON = JSON.parse(data);
@@ -2661,7 +2838,7 @@
             let iceCandidates = msgJSON['iceCandidates'];
             if (iceCandidates !== undefined) {
               for (let index in iceCandidates) {
-                this._peerConnection.addIceCandidate(new RTCIceCandidate(iceCandidates[index]));
+                if (this._peerConnection) this._peerConnection.addIceCandidate(new RTCIceCandidate(iceCandidates[index]));
               }
             }
             break;
@@ -2703,42 +2880,71 @@
         }
       }
       grabDevices() {
-        navigator.mediaDevices.enumerateDevices().then(devices => {
-          this._cameraList = new InputDeviceList();
-          this._microphoneList = new InputDeviceList();
-          for (let i = 0; i < devices.length; i++) {
+        return __awaiter(this, void 0, void 0, function* () {
+          try {
             try {
-              if (devices[i].kind === 'videoinput') {
-                let device = new InputDevice(devices[i], i);
-                this._cameraList.push(device);
-              } else if (devices[i].kind === 'audioinput') {
-                let device = new InputDevice(devices[i], i);
-                this._microphoneList.push(device);
+              yield navigator.mediaDevices.getUserMedia({
+                audio: true,
+                video: true
+              });
+            } catch (e) {}
+            const devices = yield navigator.mediaDevices.enumerateDevices();
+            this._cameraList = new InputDeviceList();
+            this._microphoneList = new InputDeviceList();
+            for (let device of devices) {
+              try {
+                if (device.deviceId && device.label) {
+                  if (device.kind === 'videoinput') {
+                    let inputDevice = new InputDevice(device, this._cameraList.getSize());
+                    this._cameraList.push(inputDevice);
+                  } else if (device.kind === 'audioinput') {
+                    let inputDevice = new InputDevice(device, this._microphoneList.getSize());
+                    this._microphoneList.push(inputDevice);
+                  }
+                }
+              } catch (error) {
+                this._logger.error(this, "WebRTCStreamer :: Input Device Error: " + error);
               }
-            } catch (error) {
-              this._logger.error(this, "WebRTCStreamer :: Input Device Error: " + error);
             }
-          }
-          if (this._cameraList.getSize() == 0) {
-            this._main.dispatchEvent("noCameraFound", {
-              ref: this._main
+            this._logger.info(this, "Camera list:");
+            for (let i = 0; i < this._cameraList.getSize(); i++) {
+              this._logger.info(this, "=> [" + i + "] InputDevice: " + this._cameraList.get(i).getLabel());
+            }
+            this._logger.info(this, "Microphone list:");
+            for (let k = 0; k < this._microphoneList.getSize(); k++) {
+              this._logger.info(this, "=> [" + k + "] InputDevice: " + this._microphoneList.get(k).getLabel());
+            }
+            if (this._cameraList.getSize() == 0) {
+              this._main.dispatchEvent("noCameraFound", {
+                ref: this._main
+              });
+            } else {
+              this._selectedCamera = this.pickCamera();
+            }
+            if (this._microphoneList.getSize() == 0) {
+              this._main.dispatchEvent("noMicrophoneFound", {
+                ref: this._main
+              });
+            } else {
+              this._selectedMicrophone = this.pickMicrophone();
+            }
+            this._main.dispatchEvent("deviceListUpdate", {
+              ref: this._main,
+              cameraList: this._cameraList.getArray(),
+              microphoneList: this._microphoneList.getArray()
+            });
+          } catch (error) {
+            if (!this._cameraList) this._cameraList = new InputDeviceList();
+            if (!this._microphoneList) this._microphoneList = new InputDeviceList();
+            this._main.dispatchEvent("deviceListUpdate", {
+              ref: this._main,
+              cameraList: this._cameraList.getArray(),
+              microphoneList: this._microphoneList.getArray()
             });
-          } else if (this._microphoneList.getSize() == 0) {
-            this._main.dispatchEvent("noMicrophoneFound", {
+            this._main.dispatchEvent("inputDeviceError", {
               ref: this._main
             });
-          } else {
-            this._logger.info(this, "Camera list:");
-            for (let i = 0; i < this._cameraList.getSize(); i++) this._logger.info(this, "=> [" + i + "] InputDevice: " + this._cameraList.get(i).getLabel());
-            this._logger.info(this, "Microphone list:");
-            for (let k = 0; k < this._microphoneList.getSize(); k++) this._logger.info(this, "=> [" + k + "] InputDevice: " + this._microphoneList.get(k).getLabel());
-            this._selectedCamera = this.pickCamera();
-            this._selectedMicrophone = this.pickMicrophone();
           }
-        }).catch(() => {
-          this._main.dispatchEvent("inputDeviceError", {
-            ref: this._main
-          });
         });
       }
       selectCamera(cameraID) {
@@ -2750,9 +2956,15 @@
             break;
           }
         }
-        this.closeStream();
+        const wasPublishing = this._publishState === exports.PublishState.PUBLISHED;
+        this.stopCameraStream();
         this._constraints.video.deviceId = this._selectedCamera.getID();
-        this.startWebRTC();
+        this.startCamera().then(() => {
+          var _a;
+          if (wasPublishing && ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey)) {
+            this.updateWebRTCStream();
+          }
+        });
       }
       selectMicrophone(micID) {
         var _a;
@@ -2763,18 +2975,126 @@
             break;
           }
         }
-        this.closeStream();
+        const wasPublishing = this._publishState === exports.PublishState.PUBLISHED;
+        this.stopCameraStream();
         this._constraints.audio = {
           deviceId: this._selectedMicrophone.getID()
         };
-        this.startWebRTC();
+        this.startCamera().then(() => {
+          var _a;
+          if (wasPublishing && ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey)) {
+            this.updateWebRTCStream();
+          }
+        });
+      }
+      startCamera() {
+        return __awaiter(this, void 0, void 0, function* () {
+          try {
+            const devices = yield navigator.mediaDevices.enumerateDevices();
+            const hasVideo = devices.some(device => device.kind === 'videoinput');
+            const hasAudio = devices.some(device => device.kind === 'audioinput');
+            let tracks = [];
+            let hadError = false;
+            if (hasVideo) {
+              try {
+                const videoStream = yield navigator.mediaDevices.getUserMedia({
+                  video: this._constraints.video
+                });
+                tracks.push(...videoStream.getTracks());
+              } catch (error) {
+                hadError = true;
+                this.onUserMediaError({
+                  name: error instanceof Error ? error.name : 'UnknownError',
+                  message: error instanceof Error ? error.message : 'Unknown error',
+                  deviceType: 'video'
+                });
+              }
+            }
+            if (hasAudio) {
+              try {
+                const audioStream = yield navigator.mediaDevices.getUserMedia({
+                  audio: this._constraints.audio
+                });
+                tracks.push(...audioStream.getTracks());
+              } catch (error) {
+                hadError = true;
+                this.onUserMediaError({
+                  name: error instanceof Error ? error.name : 'UnknownError',
+                  message: error instanceof Error ? error.message : 'Unknown error',
+                  deviceType: 'audio'
+                });
+              }
+            }
+            if (tracks.length > 0) {
+              this._stream = new MediaStream(tracks);
+              this.onCameraStreamSuccess(this._stream);
+            } else if (hadError) {
+              yield this.grabDevices();
+            }
+          } catch (error) {
+            if (error instanceof Error && !('deviceType' in error)) {
+              this.onUserMediaError({
+                name: error.name,
+                message: error.message
+              });
+            }
+            yield this.grabDevices();
+          }
+        });
+      }
+      stopCameraStream() {
+        if (this._stream) {
+          this._stream.getTracks().forEach(track => track.stop());
+          const videoElement = this._main.getStageController().getScreenElement().getVideoElement();
+          videoElement.srcObject = null;
+          this._soundMeter.detach();
+          this._stream = null;
+        }
+      }
+      updateWebRTCStream() {
+        if (!this._peerConnection || !this._stream) {
+          return;
+        }
+        const senders = this._peerConnection.getSenders();
+        senders.forEach(sender => {
+          if (this._peerConnection) this._peerConnection.removeTrack(sender);
+        });
+        this._stream.getTracks().forEach(track => {
+          if (this._stream != null && this._peerConnection) {
+            this._peerConnection.addTrack(track, this._stream);
+          }
+        });
+      }
+      closeStream() {
+        if (this._peerConnection !== undefined && this._peerConnection !== null) {
+          this._peerConnection.close();
+        }
+        this.setPublishState(exports.PublishState.UNPUBLISHED);
       }
       pickCamera() {
         var _a, _b;
-        for (let i = 0; i < this._cameraList.getSize(); i++) this._cameraList.get(i).setSelected(false);
+        for (let i = 0; i < this._cameraList.getSize(); i++) {
+          this._cameraList.get(i).setSelected(false);
+        }
         let savedCameraID = (_b = (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.getField("cameraID")) !== null && _b !== void 0 ? _b : null;
-        if (this._selectedCamera == null || savedCameraID == null) this._selectedCamera = this._cameraList.get(0);else this.selectCamera(savedCameraID);
-        this._selectedCamera.setSelected(true);
+        if (this._selectedCamera == null || savedCameraID == null) {
+          if (this._cameraList.getSize() > 0) {
+            this._selectedCamera = this._cameraList.get(0);
+            this._selectedCamera.setSelected(true);
+          }
+        } else {
+          for (let i = 0; i < this._cameraList.getSize(); i++) {
+            if (this._cameraList.get(i).getID() == savedCameraID) {
+              this._selectedCamera = this._cameraList.get(i);
+              this._selectedCamera.setSelected(true);
+              break;
+            }
+          }
+          if (!this._selectedCamera && this._cameraList.getSize() > 0) {
+            this._selectedCamera = this._cameraList.get(0);
+            this._selectedCamera.setSelected(true);
+          }
+        }
         this._main.dispatchEvent("deviceListUpdate", {
           ref: this._main,
           cameraList: this._cameraList.getArray(),
@@ -2784,10 +3104,28 @@
       }
       pickMicrophone() {
         var _a, _b;
-        for (let i = 0; i < this._microphoneList.getSize(); i++) this._microphoneList.get(i).setSelected(false);
+        for (let i = 0; i < this._microphoneList.getSize(); i++) {
+          this._microphoneList.get(i).setSelected(false);
+        }
         let savedMicID = (_b = (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.getField("microphoneID")) !== null && _b !== void 0 ? _b : null;
-        if (this._selectedMicrophone == null || savedMicID == null) this._selectedMicrophone = this._microphoneList.get(0);else this.selectMicrophone(savedMicID);
-        this._selectedMicrophone.setSelected(true);
+        if (this._selectedMicrophone == null || savedMicID == null) {
+          if (this._microphoneList.getSize() > 0) {
+            this._selectedMicrophone = this._microphoneList.get(0);
+            this._selectedMicrophone.setSelected(true);
+          }
+        } else {
+          for (let i = 0; i < this._microphoneList.getSize(); i++) {
+            if (this._microphoneList.get(i).getID() == savedMicID) {
+              this._selectedMicrophone = this._microphoneList.get(i);
+              this._selectedMicrophone.setSelected(true);
+              break;
+            }
+          }
+          if (!this._selectedMicrophone && this._microphoneList.getSize() > 0) {
+            this._selectedMicrophone = this._microphoneList.get(0);
+            this._selectedMicrophone.setSelected(true);
+          }
+        }
         this._main.dispatchEvent("deviceListUpdate", {
           ref: this._main,
           cameraList: this._cameraList.getArray(),
@@ -2795,45 +3133,60 @@
         });
         return this._selectedMicrophone;
       }
-      muteMicrophone(microphoneState) {
-        this._isMicrophoneMuted = microphoneState;
-        if (this._stream != null) {
-          if (microphoneState) {
-            this._logger.success(this, "WebRTCStreamer1 :: Unmuting microphone");
-          } else {
-            this._logger.success(this, "WebRTCStreamer1 :: Muting microphone");
-          }
-          if (this._stream.getAudioTracks() != null) {
-            for (let i = 0; i < this._stream.getAudioTracks().length; i++) this._stream.getAudioTracks()[i].enabled = microphoneState;
-          }
-          this._isMicrophoneMuted = !microphoneState;
+      muteMicrophone(shouldMute) {
+        if (this._isMicrophoneMuted === shouldMute) {
+          return;
+        }
+        this._isMicrophoneMuted = shouldMute;
+        if (this._stream) {
+          this.applyMicrophoneState(!shouldMute);
         } else {
-          this._logger.warning(this, "WebRTCStreamer :: Stream object not present!");
+          this._pendingMicrophoneState = !shouldMute;
+          this._logger.info(this, `WebRTCStreamer :: Stream not yet available, storing microphone state (muted: ${shouldMute})`);
         }
         this._main.dispatchEvent("microphoneStateChange", {
           ref: this._main,
           isMuted: this._isMicrophoneMuted
         });
       }
+      applyMicrophoneState(enabled) {
+        if (!this._stream) {
+          this._logger.warning(this, "WebRTCStreamer :: Cannot apply microphone state - stream not available");
+          return;
+        }
+        const audioTracks = this._stream.getAudioTracks();
+        if (audioTracks && audioTracks.length > 0) {
+          this._logger.success(this, `WebRTCStreamer :: ${enabled ? 'Unmuting' : 'Muting'} microphone`);
+          audioTracks.forEach(track => track.enabled = enabled);
+        } else {
+          this._logger.warning(this, "WebRTCStreamer :: No audio tracks found in stream");
+        }
+      }
       isMicrophoneMuted() {
         return this._isMicrophoneMuted;
       }
+      isStreamReady(requireVideo = true, requireAudio = true) {
+        if (!this._stream) {
+          return false;
+        }
+        const videoTracks = this._stream.getVideoTracks();
+        const audioTracks = this._stream.getAudioTracks();
+        const videoReady = !requireVideo || videoTracks.length > 0 && videoTracks[0].readyState === 'live';
+        const audioReady = !requireAudio || audioTracks.length > 0 && audioTracks[0].readyState === 'live';
+        return videoReady && audioReady;
+      }
+      closeWebRTCConnection() {
+        if (this._peerConnection) {
+          this._peerConnection.close();
+          this._peerConnection = null;
+        }
+      }
       onDescriptionError(error) {
         this._logger.info(this, "WebRTCStreamer :: onDescriptionError: " + JSON.stringify(error));
       }
       onIceCandidate(event) {
         if (event.candidate !== null) ;
       }
-      closeStream() {
-        if (this._stream) {
-          this._stream.getTracks().forEach(function (track) {
-            track.stop();
-          });
-        }
-        this._soundMeter.detach();
-        if (this._peerConnection !== undefined && this._peerConnection !== null) this._peerConnection.close();
-        this.setPublishState(exports.PublishState.UNPUBLISHED);
-      }
       getCurrentCamera() {
         return this._selectedCamera;
       }
@@ -2861,6 +3214,7 @@
       }
       destroy() {
         var _a;
+        this._pendingMicrophoneState = null;
         this.closeStream();
         (_a = this._selectedPlayer) === null || _a === void 0 ? void 0 : _a.clear();
         this._selectedPlayer = null;
@@ -3169,8 +3523,8 @@
       constructor(streamConfig, autoInitialize = false) {
         super();
         this.DEV_MODE = true;
-        this.STREAMER_VERSION = "0.9.0-beta.2";
-        this.COMPILE_DATE = "11/29/2024, 6:55:45 PM";
+        this.STREAMER_VERSION = "0.9.0-beta.3";
+        this.COMPILE_DATE = "12/5/2024, 2:36:49 PM";
         this.STREAMER_BRANCH = "Experimental";
         this.STREAMER_PROTOCOL_VERSION = 1;
         this._initialized = false;
@@ -3323,8 +3677,12 @@
         return (_b = (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.getPublishState()) !== null && _b !== void 0 ? _b : exports.PublishState.NOT_INITIALIZED;
       }
       publish(streamKey) {
-        var _a;
-        (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.publish(streamKey);
+        var _a, _b;
+        return (_b = (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.publish(streamKey)) !== null && _b !== void 0 ? _b : false;
+      }
+      isStreamReady() {
+        var _a, _b;
+        return (_b = (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.isStreamReady()) !== null && _b !== void 0 ? _b : false;
       }
       unpublish() {
         var _a;
@@ -3382,7 +3740,7 @@
       }
       updateToSize() {
         if (this._initialized) {
-          this._stageController.onResize();
+          this._stageController.handleResize();
         }
       }
       makeScreenshot() {
@@ -3454,14 +3812,14 @@
         super.dispatchEvent(eventName, event);
       }
       destroy() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this._logger.warning(this, "Destroying library instance, bye, bye!");
         if (this.DEV_MODE && 'StormStreamerArray' in window) window.StormStreamerArray[this._streamerID] = null;
         this._initialized = false;
         this._isRemoved = true;
-        (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection().destroy();
-        (_b = this._stageController) === null || _b === void 0 ? void 0 : _b.destroy();
-        (_c = this._playbackController) === null || _c === void 0 ? void 0 : _c.destroy();
+        (_b = (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection()) === null || _b === void 0 ? void 0 : _b.destroy();
+        (_c = this._stageController) === null || _c === void 0 ? void 0 : _c.destroy();
+        (_d = this._playbackController) === null || _d === void 0 ? void 0 : _d.destroy();
         this.removeAllEventListeners();
       }
     }