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

package/dist/js/opentok.d.ts

@@ -488,6 +488,8 @@ declare namespace OT {
       promise: (value: boolean) => Promise<void>;
     }
     publishCaptions(value: boolean): Promise<void>;
+    setCaptionsInputLanguage(langCode: CaptionsLanguageCode | null): Promise<void>;
+    getCaptionsInputLanguage(): CaptionsLanguageCode | null;
     cycleVideo(): Promise<{ deviceId: string }>;
     setAudioSource(audioSource:string | MediaStreamTrack): Promise<undefined>;
     getAudioSource(): MediaStreamTrack;

package/dist/js/opentok.js

@@ -1,11 +1,11 @@
 /**
- * @license OpenTok.js 2.36.0 895d7e807
+ * @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 10:30:07 GMT
+ * Date: Thu, 30 Jul 2026 10:15:47 GMT
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -27523,6 +27523,12 @@ function RaptorSocketFactory(deps) {
       }
       this.publish(RaptorMessage.streamChannels.update(_apiKey, _sessionId, streamId, channelId, attributes), {}, true, completion);
     };
+    this.publisherChannelUpdate = function (streamId, channelId, attributes, completion) {
+      if (completion === void 0) {
+        completion = () => {};
+      }
+      this.publish(RaptorMessage.streamChannels.update(_apiKey, _sessionId, streamId, channelId, attributes), {}, true, completion);
+    };
     this.streamChannelSendData = function (streamId, channelId, data, completion) {
       this.publish(RaptorMessage.streamChannels.data(_apiKey, _sessionId, streamId, channelId, data), {}, true, completion);
     };
@@ -39866,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":"895d7e807","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);
   /**
@@ -41455,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));
@@ -41516,6 +41522,7 @@ var _getSpatialResolution = _interopRequireDefault(__webpack_require__(39841));
 var _VideoBitratePreset = _interopRequireDefault(__webpack_require__(51831));
 var _videoConstraints = _interopRequireDefault(__webpack_require__(49474));
 var _networkConditionConstants = __webpack_require__(46179);
+var _languageCodes = __webpack_require__(38891);
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 /* eslint-disable global-require, func-names, max-len */
@@ -41717,6 +41724,9 @@ function PublisherFactory(_ref) {
     let networkCondition = _networkConditionConstants.NETWORK_CONDITION.GOOD;
     let getStatsCalled = false;
     let filteredVideoTrackId;
+    let _captionsInputLanguage = null;
+    let _pendingSetCaptionsInputLanguageArgs;
+    let _setCaptionsInputLanguageInFlight = false;
 
     /** @type IntervalRunnerDefault | undefined */
     let connectivityAttemptPinger;
@@ -44175,6 +44185,102 @@ function PublisherFactory(_ref) {
         streamReadyJobs.add(() => finishPublishCaptions(value, resolve, reject));
       }
     });
+    const sendCaptionsInputLanguageUpdate = () => {
+      var _this$session22, _this$stream;
+      _setCaptionsInputLanguageInFlight = true;
+      const _pendingSetCaptionsIn = _pendingSetCaptionsInputLanguageArgs,
+        langCode = _pendingSetCaptionsIn.langCode,
+        resolve = _pendingSetCaptionsIn.resolve,
+        reject = _pendingSetCaptionsIn.reject;
+      _pendingSetCaptionsInputLanguageArgs = null;
+      const attributes = {
+        category: langCode === null ? '' : langCode
+      };
+      const socket = (_this$session22 = this.session) == null ? void 0 : _this$session22._.getSocket();
+      const streamId = ((_this$stream = this.stream) == null ? void 0 : _this$stream.id) || this.streamId;
+      socket.publisherChannelUpdate(streamId, 'caption1', attributes, err => {
+        _setCaptionsInputLanguageInFlight = false;
+        if (err) {
+          reject(err);
+        } else {
+          _captionsInputLanguage = langCode;
+          logAnalyticsEvent('setCaptionsInputLanguage', 'Event', {
+            captionsInputLanguage: langCode
+          });
+          resolve();
+        }
+        // If there's a pending call queued while we were in-flight, process it now
+        if (_pendingSetCaptionsInputLanguageArgs) {
+          if (_pendingSetCaptionsInputLanguageArgs.langCode === _captionsInputLanguage) {
+            // Same language as what just succeeded, resolve without another network call
+            _pendingSetCaptionsInputLanguageArgs.resolve();
+            _pendingSetCaptionsInputLanguageArgs = null;
+          } else {
+            sendCaptionsInputLanguageUpdate();
+          }
+        }
+      });
+    };
+
+    /**
+    * Sets the language used for captions input on the publisher. The language code
+    * is sent to the captions service to indicate the spoken language of the audio.
+    * Pass <code>null</code> to clear the captions input language.
+    *
+    * <p>
+    * If the publisher is not yet publishing to a session, the language will be applied
+    * once publishing begins.
+    *
+    * @param {String|null} langCode A BCP-47 language code (for example, <code>"en-US"</code>,
+    * <code>"es"</code>), or <code>null</code> to clear the captions input language.
+    *
+    * @see <a href="#getCaptionsInputLanguage">Publisher.getCaptionsInputLanguage()</a>
+    * @see <a href="#publishCaptions">Publisher.publishCaptions()</a>
+    * @returns {Promise<void>} A promise that resolves when the language has been set,
+    * or rejects with an error if the language code is invalid or the operation fails.
+    * @method #setCaptionsInputLanguage
+    * @memberOf Publisher
+    */
+    this.setCaptionsInputLanguage = langCode => new Promise((resolve, reject) => {
+      if (langCode !== null && !(0, _languageCodes.validateLanguageCode)(langCode)) {
+        const message = `Invalid captions input language ${langCode}`;
+        logging.warn(`setCaptionsInputLanguage: ${message}`);
+        reject(otError(Errors.INVALID_PARAMETER, new Error(`setCaptionsInputLanguage: ${message}`)));
+        return;
+      }
+      if (_pendingSetCaptionsInputLanguageArgs) {
+        streamReadyJobs.remove(sendCaptionsInputLanguageUpdate);
+        _pendingSetCaptionsInputLanguageArgs.reject(new Error('setCaptionsInputLanguage: call superseded by a newer setCaptionsInputLanguage call'));
+        _pendingSetCaptionsInputLanguageArgs = undefined;
+      }
+      if (langCode === _captionsInputLanguage && !_setCaptionsInputLanguageInFlight) {
+        resolve();
+        return;
+      }
+      _pendingSetCaptionsInputLanguageArgs = {
+        langCode,
+        resolve,
+        reject
+      };
+      if (this.stream) {
+        if (!_setCaptionsInputLanguageInFlight) {
+          sendCaptionsInputLanguageUpdate();
+        }
+      } else {
+        streamReadyJobs.add(sendCaptionsInputLanguageUpdate);
+      }
+    });
+
+    /**
+    * Returns the current captions input language set for the publisher.
+    *
+    * @return {String|null} The BCP-47 language code (for example, <code>"en-US"</code>)
+    * currently set for captions input, or <code>null</code> if no language has been set.
+    * @see <a href="#setCaptionsInputLanguage">Publisher.setCaptionsInputLanguage()</a>
+    * @method #getCaptionsInputLanguage
+    * @memberOf Publisher
+    */
+    this.getCaptionsInputLanguage = () => _captionsInputLanguage;
     let updateVideoSenderParametersSentinel;
 
     // keeps track of if the client has called mediaStreamTrack.stop(), so that we don't restart
@@ -44317,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) {
@@ -44363,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;
@@ -44382,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);
@@ -44711,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();
           }
@@ -45045,8 +45155,8 @@ function PublisherFactory(_ref) {
           break;
         default:
           if (!futurePeerConnection) {
-            var _this$session22, _this$session22$sessi;
-            if (!state.isMigrating() && (_this$session22 = this.session) != null && (_this$session22$sessi = _this$session22.sessionInfo) != null && _this$session22$sessi.isAdaptiveEnabled && getP2pPeerConnection()) {
+            var _this$session23, _this$session23$sessi;
+            if (!state.isMigrating() && (_this$session23 = this.session) != null && (_this$session23$sessi = _this$session23.sessionInfo) != null && _this$session23$sessi.isAdaptiveEnabled && getP2pPeerConnection()) {
               // In the case Rumor sends two generateOffers for the P2P leg,
               // we need to ignore the second one.
               return;
@@ -45587,7 +45697,7 @@ function PublisherFactory(_ref) {
       document.addEventListener('visibilitychange', visibilityHandler);
     };
     const handleBuggedUnMutedLocalAudioTrack = audioTrack => {
-      var _this$session23;
+      var _this$session24;
       if (hasAudio()) {
         if (!hasVideo()) {
           // We only need to reset the audio source when the publisher is audio only.
@@ -45602,7 +45712,7 @@ function PublisherFactory(_ref) {
           this.videoElement().pause();
         }
       }
-      this == null ? void 0 : (_this$session23 = this.session) == null ? void 0 : _this$session23.trigger('gsmCallEnded');
+      this == null ? void 0 : (_this$session24 = this.session) == null ? void 0 : _this$session24.trigger('gsmCallEnded');
     };
 
     /**
@@ -46415,7 +46525,7 @@ function PublisherFactory(_ref) {
       },
       startMigration: function () {
         var _startMigration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee49() {
-          var _publisherSenderStats6, _this$session24, _this$session24$sessi;
+          var _publisherSenderStats6, _this$session25, _this$session25$sessi;
           var relayedPeerConnection, onCreateStreamError;
           return _regenerator.default.wrap(function _callee49$(_context49) {
             while (1) switch (_context49.prev = _context49.next) {
@@ -46437,7 +46547,7 @@ function PublisherFactory(_ref) {
                     throw new Error(error);
                   }
                 };
-                if (!((_this$session24 = _this.session) != null && (_this$session24$sessi = _this$session24.sessionInfo) != null && _this$session24$sessi.p2pEnabled)) {
+                if (!((_this$session25 = _this.session) != null && (_this$session25$sessi = _this$session25.sessionInfo) != null && _this$session25$sessi.p2pEnabled)) {
                   _context49.next = 13;
                   break;
                 }
@@ -46462,7 +46572,7 @@ function PublisherFactory(_ref) {
         return startMigration;
       }(),
       finishMigration: () => {
-        var _this$session25, _this$session25$sessi;
+        var _this$session26, _this$session26$sessi;
         clearTimeout(_migrationTimeoutId);
         const destroyPeerConnection = /*#__PURE__*/function () {
           var _ref61 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee50(pc) {
@@ -46497,7 +46607,7 @@ function PublisherFactory(_ref) {
         _previousPeerConnection = null;
 
         // In case we don't transition to P2P after migration, clear P2P leg.
-        if ((_this$session25 = this.session) != null && (_this$session25$sessi = _this$session25.sessionInfo) != null && _this$session25$sessi.isAdaptiveEnabled && activeSourceStreamId === 'MANTIS') {
+        if ((_this$session26 = this.session) != null && (_this$session26$sessi = _this$session26.sessionInfo) != null && _this$session26$sessi.isAdaptiveEnabled && activeSourceStreamId === 'MANTIS') {
           var _getP2pPeerConnection;
           (_getP2pPeerConnection = getP2pPeerConnection()) == null ? void 0 : _getP2pPeerConnection.then(destroyPeerConnection);
         }
@@ -96047,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;
@@ -96098,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;
+  };
+}
 
 /***/ }),