@opentok/client 2.36.0-alpha.16 → 2.36.0-alpha.17

package/dist/js/opentok.js

@@ -1,11 +1,11 @@
 /**
- * @license OpenTok.js 2.36.0 80ef11d29
+ * @license OpenTok.js 2.36.0 738cef185
  *
  * Copyright (c) 2010-2026 TokBox, Inc.
  * Subject to the applicable Software Development Kit (SDK) License Agreement:
  * https://www.vonage.com/legal/communications-apis/terms-of-use/
  *
- * Date: Wed, 29 Jul 2026 11:28:57 GMT
+ * Date: Thu, 30 Jul 2026 10:15:47 GMT
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -39872,7 +39872,7 @@ function staticConfigFactory(_temp) {
     _ref$axios = _ref.axios,
     axios = _ref$axios === void 0 ? _axios.default : _ref$axios,
     _ref$properties = _ref.properties,
-    properties = _ref$properties === void 0 ? {"version":"v2.36.0","buildHash":"80ef11d29","minimumVersion":{"firefox":52,"chrome":49},"debug":false,"websiteURL":"http://www.tokbox.com","configURL":"https://config.opentok.com","ipWhitelistConfigURL":"","cdnURL":"","loggingURL":"https://hlg.tokbox.com/prod","apiURL":"https://anvil.opentok.com","vonageApiURL":""} : _ref$properties;
+    properties = _ref$properties === void 0 ? {"version":"v2.36.0","buildHash":"738cef185","minimumVersion":{"firefox":52,"chrome":49},"debug":false,"websiteURL":"http://www.tokbox.com","configURL":"https://config.opentok.com","ipWhitelistConfigURL":"","cdnURL":"","loggingURL":"https://hlg.tokbox.com/prod","apiURL":"https://anvil.opentok.com","vonageApiURL":""} : _ref$properties;
   /** @type builtInConfig */
   const builtInConfig = (0, _cloneDeep.default)(properties);
   /**
@@ -41461,7 +41461,7 @@ var _promiseDelay = _interopRequireDefault(__webpack_require__(66395));
 var _env = _interopRequireDefault(__webpack_require__(28628));
 var _networkStatus = _interopRequireDefault(__webpack_require__(83655));
 var _deviceHelpers = _interopRequireDefault(__webpack_require__(78092));
-var _blockCallsUntilComplete = _interopRequireDefault(__webpack_require__(86266));
+var _blockCallsUntilComplete = _interopRequireWildcard(__webpack_require__(86266));
 var _interval_runner = _interopRequireDefault(__webpack_require__(55605));
 var _exception_codes = _interopRequireDefault(__webpack_require__(90529));
 var _ot_error_class = _interopRequireDefault(__webpack_require__(4960));
@@ -44423,45 +44423,58 @@ function PublisherFactory(_ref) {
     let currentDeviceId;
     let currentVideoFilter;
     let currentAudioFilter;
-    this._toggleVideo = (0, _blockCallsUntilComplete.default)( /*#__PURE__*/function () {
+    this._toggleVideo = (0, _blockCallsUntilComplete.queueLatestCall)( /*#__PURE__*/function () {
       var _ref40 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee28(shouldHaveVideo, videoDimensions) {
         var _vidDevices$find;
         var vidDevices, oldTrack, oldTrackDeviceId, newTrack, videoFilter, originalVideoTrack, _originalVideoTrack;
         return _regenerator.default.wrap(function _callee28$(_context28) {
           while (1) switch (_context28.prev = _context28.next) {
             case 0:
+              if (properties.publisherAudioFallbackEnabled || getStatsCalled || networkConditionChangedListenersCount > 0) {
+                resetCongestionLevelEstimationOnPeerConnection(shouldHaveVideo);
+                if (shouldHaveVideo === false && audioFallbackCoordinator && audioFallbackCoordinator.getState() !== _audioFallbackVideoStates.default.ACTIVE_VIDEO) {
+                  // We will reset audio fallback state now, but rumor doesn't expect the message until we re-enable the video
+                  // so we flag the message as pending
+                  pendingRumorAudioFallbackMessage = true;
+                  resetAudioFallbackState();
+                }
+              }
+
+              // we don't need to worry about the camera if we're screensharing or using
+              // a custom video track
+              // if we add support for switching between screen and camera this may cause issues
               if (!(isScreenSharing || isCustomVideoTrack || isTrackManuallyStopped)) {
-                _context28.next = 2;
+                _context28.next = 3;
                 break;
               }
               return _context28.abrupt("return");
-            case 2:
-              _context28.next = 4;
+            case 3:
+              _context28.next = 5;
               return getVideoDevices();
-            case 4:
+            case 5:
               vidDevices = _context28.sent;
               oldTrack = getCurrentTrack();
               if (oldTrack) {
-                _context28.next = 8;
+                _context28.next = 9;
                 break;
               }
               throw otError(Errors.NOT_SUPPORTED, new Error('Publisher._toggleVideo cannot toggleVideo when you have no video source.'));
-            case 8:
+            case 9:
               // oldTrackDeviceId is undefined when it comes from a canvasTracks, i.e.: it is currently muted
               oldTrackDeviceId = (_vidDevices$find = vidDevices.find(device => device.label === oldTrack.label)) == null ? void 0 : _vidDevices$find.deviceId;
               if (isNewTrackNeeded(shouldHaveVideo, oldTrackDeviceId)) {
-                _context28.next = 11;
+                _context28.next = 12;
                 break;
               }
               return _context28.abrupt("return");
-            case 11:
+            case 12:
               if (!(oldTrack.readyState === 'ended')) {
-                _context28.next = 14;
+                _context28.next = 15;
                 break;
               }
               isTrackManuallyStopped = true;
               return _context28.abrupt("return");
-            case 14:
+            case 15:
               if (shouldHaveVideo && OTHelpers.env.isAndroid && (OTHelpers.env.isChrome || OTHelpers.env.isSamsung)) {
                 // On Chrome on Android you need to stop the previous video track OPENTOK-37206
                 if (oldTrack && oldTrack.stop) {
@@ -44469,18 +44482,18 @@ function PublisherFactory(_ref) {
                 }
               }
               if (shouldHaveVideo) {
-                _context28.next = 31;
+                _context28.next = 32;
                 break;
               }
-              _context28.prev = 16;
+              _context28.prev = 17;
               newTrack = (0, _createCanvasVideoTrack.default)(videoDimensions);
-              _context28.next = 23;
+              _context28.next = 24;
               break;
-            case 20:
-              _context28.prev = 20;
-              _context28.t0 = _context28["catch"](16);
+            case 21:
+              _context28.prev = 21;
+              _context28.t0 = _context28["catch"](17);
               return _context28.abrupt("return");
-            case 23:
+            case 24:
               if (oldTrackDeviceId) {
                 // store the current deviceId to reacquire the video later
                 currentDeviceId = oldTrackDeviceId;
@@ -44488,102 +44501,102 @@ function PublisherFactory(_ref) {
               setCurrentTrackDeviceId(newTrack.label);
               videoFilter = mediaProcessor.getVideoFilter();
               if (!videoFilter) {
-                _context28.next = 30;
+                _context28.next = 31;
                 break;
               }
               // Save the current video filter because we want to make sure it
               // gets enabled when the user publishes video again
               currentVideoFilter = videoFilter;
-              _context28.next = 30;
+              _context28.next = 31;
               return destroyMediaProcessor();
-            case 30:
+            case 31:
               if (_videoMediaProcessorConnector) {
                 _videoMediaProcessorConnector.destroy();
                 _videoMediaProcessorConnector.stopOriginalTrack();
               }
-            case 31:
+            case 32:
               if (!(currentDeviceId && vidDevices.findIndex(device => device.deviceId === currentDeviceId) === -1)) {
-                _context28.next = 33;
+                _context28.next = 34;
                 break;
               }
               throw otError(Errors.NO_DEVICES_FOUND, new Error('Previous device no longer available - deviceId not found'));
-            case 33:
+            case 34:
               privateEvents.emit('streamDestroy');
               if (!shouldHaveVideo) {
-                _context28.next = 64;
+                _context28.next = 65;
                 break;
               }
               if (!hasTrackFromDevice(currentDeviceId)) {
-                _context28.next = 37;
+                _context28.next = 38;
                 break;
               }
               return _context28.abrupt("return");
-            case 37:
-              _context28.prev = 37;
-              _context28.next = 40;
+            case 38:
+              _context28.prev = 38;
+              _context28.next = 41;
               return getTrackFromDeviceId(currentDeviceId);
-            case 40:
+            case 41:
               newTrack = _context28.sent;
-              _context28.next = 47;
+              _context28.next = 48;
               break;
-            case 43:
-              _context28.prev = 43;
-              _context28.t1 = _context28["catch"](37);
+            case 44:
+              _context28.prev = 44;
+              _context28.t1 = _context28["catch"](38);
               logging.error(`Error getting new track for current device(${currentDeviceId}): ${_context28.t1}`);
               throw _context28.t1;
-            case 47:
+            case 48:
               if (newTrack) {
-                _context28.next = 50;
+                _context28.next = 51;
                 break;
               }
               logging.error('Failed to enable video. It was not possible to get a new track from the camera');
               return _context28.abrupt("return");
-            case 50:
+            case 51:
               if (!currentVideoFilter) {
-                _context28.next = 59;
+                _context28.next = 60;
                 break;
               }
               originalVideoTrack = mediaProcessor.getOriginalVideoTrack();
-              _context28.next = 54;
+              _context28.next = 55;
               return mediaProcessor.setVideoFilter(currentVideoFilter, true);
-            case 54:
-              _context28.next = 56;
+            case 55:
+              _context28.next = 57;
               return mediaProcessor.setMediaStream(webRTCStream);
-            case 56:
-              _context28.next = 58;
+            case 57:
+              _context28.next = 59;
               return mediaProcessor.setVideoTrack(newTrack);
-            case 58:
-              newTrack = _context28.sent;
             case 59:
+              newTrack = _context28.sent;
+            case 60:
               if (!_videoMediaProcessorConnector) {
-                _context28.next = 64;
+                _context28.next = 65;
                 break;
               }
               originalVideoTrack = _videoMediaProcessorConnector.originalTrack;
-              _context28.next = 63;
+              _context28.next = 64;
               return _videoMediaProcessorConnector.setTrack(newTrack);
-            case 63:
-              newTrack = _context28.sent;
             case 64:
-              _context28.prev = 64;
-              _context28.next = 67;
+              newTrack = _context28.sent;
+            case 65:
+              _context28.prev = 65;
+              _context28.next = 68;
               return replaceTrackAndUpdate(oldTrack, newTrack);
-            case 67:
+            case 68:
               // We stop the original track as a final step because whatever effects
               // were applied to it should remain in effect until the new track is
               // set
               (_originalVideoTrack = originalVideoTrack) == null ? void 0 : _originalVideoTrack.stop();
-              _context28.next = 73;
+              _context28.next = 74;
               break;
-            case 70:
-              _context28.prev = 70;
-              _context28.t2 = _context28["catch"](64);
+            case 71:
+              _context28.prev = 71;
+              _context28.t2 = _context28["catch"](65);
               throw _context28.t2;
-            case 73:
+            case 74:
             case "end":
               return _context28.stop();
           }
-        }, _callee28, null, [[16, 20], [37, 43], [64, 70]]);
+        }, _callee28, null, [[17, 21], [38, 44], [65, 71]]);
       }));
       return function (_x20, _x21) {
         return _ref40.apply(this, arguments);
@@ -44817,18 +44830,9 @@ function PublisherFactory(_ref) {
               // Save videoDimensions to not alter video size between mute states.
               videoDimensions = getVideoDimensions();
               properties.publishVideo = value;
-              if (properties.publisherAudioFallbackEnabled || getStatsCalled || networkConditionChangedListenersCount > 0) {
-                resetCongestionLevelEstimationOnPeerConnection(value);
-                if (value === false && audioFallbackCoordinator && audioFallbackCoordinator.getState() !== _audioFallbackVideoStates.default.ACTIVE_VIDEO) {
-                  // We will reset audio fallback state now, but rumor doesn't expect the message until we re-enable the video
-                  // so we flag the message as pending
-                  pendingRumorAudioFallbackMessage = true;
-                  resetAudioFallbackState();
-                }
-              }
-              _context32.next = 5;
+              _context32.next = 4;
               return Promise.all([_this._toggleVideo(properties.publishVideo, videoDimensions), updateVideo()]);
-            case 5:
+            case 4:
             case "end":
               return _context32.stop();
           }
@@ -96153,14 +96157,16 @@ module.exports = assign;
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
+/* provided dependency */ var Promise = __webpack_require__(86964);
 
 
 var _interopRequireDefault = __webpack_require__(95709);
 exports.__esModule = true;
 exports["default"] = blockCallsUntilComplete;
+exports.queueLatestCall = queueLatestCall;
 var _regenerator = _interopRequireDefault(__webpack_require__(92207));
 var _asyncToGenerator2 = _interopRequireDefault(__webpack_require__(79092));
-// Block subsequent calls to an async function until the previous call has completed
+// Block subsequent calls to an async function until the previous call has completed.
 // Throws an error if you call the function too soon.
 function blockCallsUntilComplete(fn) {
   let blocked = false;
@@ -96204,6 +96210,87 @@ function blockCallsUntilComplete(fn) {
     return blocker;
   }();
 }
+function callSafely(fn, context, args) {
+  try {
+    return Promise.resolve(fn.apply(context, args));
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+// Like blockCallsUntilComplete, but instead of throwing when called while busy,
+// it queues at most one pending call. Whether a call gets queued or skipped
+// is decided purely by its first (boolean) argument — if it matches the flag
+// of the call currently in flight, this call is redundant and just resolves
+// with that call's result. Any other arguments are only used once a call
+// actually runs; they play no part in the queue/skip decision.
+function queueLatestCall(fn) {
+  let current = null; // promise of the call currently executing, or null when idle
+  let runningFlag = null; // boolean flag of the call currently executing
+  let queued = null; // the one call waiting its turn: { context, args, resolve, reject, promise }
+
+  function run(context, args) {
+    runningFlag = args[0];
+    // eslint-disable-next-line no-use-before-define
+    current = callSafely(fn, context, args).finally(settle);
+    return current;
+  }
+  function settle() {
+    if (!queued) {
+      current = null;
+      runningFlag = null;
+      return;
+    }
+    const _queued = queued,
+      context = _queued.context,
+      args = _queued.args,
+      resolve = _queued.resolve,
+      reject = _queued.reject;
+    queued = null;
+    run(context, args).then(resolve, reject);
+  }
+  return function (flag) {
+    const context = this;
+    for (var _len2 = arguments.length, rest = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      rest[_key2 - 1] = arguments[_key2];
+    }
+    const args = [flag, ...rest];
+    if (!current) {
+      return run(context, args);
+    }
+    if (flag === runningFlag) {
+      // Same flag as the call already in flight — anything queued behind
+      // it is now moot, since we'd just end up back at this same state.
+      if (queued) {
+        current.then(queued.resolve, queued.reject);
+        queued = null;
+      }
+      return current;
+    }
+
+    // Only the most recent pending call matters, so replace whatever was
+    // waiting before it — this is also what keeps its `rest` args current.
+    if (queued) {
+      queued.context = context;
+      queued.args = args;
+      return queued.promise;
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    queued = {
+      context,
+      args,
+      resolve,
+      reject,
+      promise
+    };
+    return promise;
+  };
+}
 
 /***/ }),