@opentok/client 2.35.0-alpha.26 → 2.35.0-alpha.27

package/dist/js/opentok.d.ts

@@ -598,11 +598,14 @@ declare namespace OT {
     connection?: Connection;
     sessionId: string;
 
-    connect(token: string, callback: (error?: OTError) => void): void;
-    disconnect(): void;
+    connect: {
+      (token: string, callback: (error?: OTError) => void): Session;
+      promise: (token: string) => Promise<Session>;
+    }
+    disconnect(): Promise<void>;
     disableForceMute(): Promise<void>;
-    forceDisconnect(connection: Connection, callback: (error?: OTError) => void): void;
-    forceUnpublish(stream: Stream, callback: (error?: OTError) => void): void;
+    forceDisconnect(connection: Connection, callback: (error?: OTError) => void): Promise<void>;
+    forceUnpublish(stream: Stream, callback: (error?: OTError) => void): Promise<void>;
     forceMuteStream(stream: Stream): Promise<void>;
     forceMuteAll(excludedStreams?: Stream[]): Promise<void>;
     getPublisherForStream(stream: Stream): Publisher | undefined;
@@ -615,7 +618,7 @@ declare namespace OT {
     signal(
       signal: { type?: string, data?: string, to?: Connection, retryAfterReconnect?: boolean },
       callback?: (error?: OTError) => void
-    ): void;
+    ): Promise<void>;
 
     subscribe(
       stream: Stream,

package/dist/js/opentok.js

@@ -1,11 +1,11 @@
 /**
- * @license OpenTok.js 2.35.0 e629a49d4
+ * @license OpenTok.js 2.35.0 87f6a8fb6
  *
  * 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: Fri, 22 May 2026 09:55:51 GMT
+ * Date: Fri, 22 May 2026 18:11:26 GMT
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -41891,7 +41891,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.35.0","buildHash":"e629a49d4","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.35.0","buildHash":"87f6a8fb6","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);
   /**
@@ -70568,6 +70568,26 @@ function SessionFactory(deps) {
       return _this;
     };
 
+    /**
+     * The <code>connect</code> function is also available in a promisified flavour.
+     * This function will resolve to a session object at the moment the event
+     * <code>sessionConnected</code> happens if there were no errors.
+     */
+    this.connect.promise = function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return new Promise((resolve, reject) => {
+        const session = _this.connect(...args, error => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(session);
+          }
+        });
+      });
+    };
+
     /**
     * Disconnects from the Vonage Video API session.
     *
@@ -70618,29 +70638,39 @@ function SessionFactory(deps) {
     * Dispatched on other clients if streams are lost as a result of the session disconnecting.
     * </p>
     *
+    * @returns {Promise<void>} A promise that will resolve when the sessionDisconnected event gets fired
+    *
     * @method #disconnect
     * @memberOf Session
     */
     this.disconnect = function () {
-      if (this._singlePeerConnectionController) {
-        this._singlePeerConnectionController.destroy();
-        this._singlePeerConnectionController = null;
-      }
-      if (cpuPressureMonitor) {
-        cpuPressureMonitor.stopMonitoring();
-      }
-      if (_socket && _socket.isNot('disconnected')) {
-        if (_socket.isNot('disconnecting')) {
-          if (!_socket.isNot('connecting')) {
-            this.logConnectivityEvent('Cancel');
+      return new Promise((resolve, reject) => {
+        try {
+          if (this._singlePeerConnectionController) {
+            this._singlePeerConnectionController.destroy();
+            this._singlePeerConnectionController = null;
+          }
+          if (cpuPressureMonitor) {
+            cpuPressureMonitor.stopMonitoring();
+          }
+          if (_socket && _socket.isNot('disconnected')) {
+            if (_socket.isNot('disconnecting')) {
+              if (!_socket.isNot('connecting')) {
+                this.logConnectivityEvent('Cancel');
+              }
+              setState('disconnecting');
+              _socket.disconnect();
+              this.off('gsmCallEnded', gsmCallEndedHandler);
+            }
+            this.once('sessionDisconnected', resolve);
+          } else {
+            reset();
+            resolve();
           }
-          setState('disconnecting');
-          _socket.disconnect();
-          this.off('gsmCallEnded', gsmCallEndedHandler);
+        } catch (err) {
+          reject(err);
         }
-      } else {
-        reset();
-      }
+      });
     };
     this.destroy = function () {
       this.streams.destroy();
@@ -72019,62 +72049,68 @@ function SessionFactory(deps) {
     * and the signal was sent. It does <i>not</i> indicate that the signal was successfully
     * received by any of the intended recipients.
     *
+    * @returns {Promise<void>} A promise that resolves when the signal has been sent
+    *
     * @method #signal
     * @memberOf Session
     * @see <a href="#event:signal">signal</a> and <a href="#event:signal:type">signal:type</a> events
     */
     this.signal = function (options, completion) {
-      let _options = options;
-      let _completion = completion || function () {};
-      if ((0, _isFunction.default)(_options)) {
-        _completion = _options;
-        _options = null;
-      }
-      if (!this.isConnected()) {
-        const notConnectedErrorMsg = 'Unable to send signal - you are not connected to the session.';
-        dispatchOTError(otError(errors.NOT_CONNECTED, new Error(notConnectedErrorMsg), 500), _completion);
-        return;
-      }
-      function getErrorNameFromCode(code) {
-        switch (code) {
-          case 400:
-          case 413:
-            return errors.INVALID_PARAMETER;
-          case 429:
-            return errors.RATE_LIMIT_EXCEEDED;
-          case 404:
-            return errors.NOT_FOUND;
-          case 500:
-            return errors.NOT_CONNECTED;
-          case 403:
-            return errors.PERMISSION_DENIED;
-          case 2001:
-            return errors.UNEXPECTED_SERVER_RESPONSE;
-          default:
-            return undefined;
+      return new Promise((resolve, reject) => {
+        let _options = options;
+        let _completion = completion || function () {};
+        if ((0, _isFunction.default)(_options)) {
+          _completion = _options;
+          _options = null;
+        }
+        const errorCallback = function errorCallback() {
+          _completion(...arguments);
+          reject(...arguments);
+        };
+        if (!this.isConnected()) {
+          const notConnectedErrorMsg = 'Unable to send signal - you are not connected to the session.';
+          dispatchOTError(otError(errors.NOT_CONNECTED, new Error(notConnectedErrorMsg), 500), errorCallback);
+          return;
         }
-      }
-      if (!_socket) {
-        dispatchSocketIsNullError('signal', _completion);
-        return;
-      }
-      _socket.signal(_options, function (error) {
-        if (error) {
-          const errorName = getErrorNameFromCode(error.code);
-          if (errorName) {
-            error = otError(errorName, new Error(error.message), error.code);
+        function getErrorNameFromCode(code) {
+          switch (code) {
+            case 400:
+            case 413:
+              return errors.INVALID_PARAMETER;
+            case 429:
+              return errors.RATE_LIMIT_EXCEEDED;
+            case 404:
+              return errors.NOT_FOUND;
+            case 500:
+              return errors.NOT_CONNECTED;
+            case 403:
+              return errors.PERMISSION_DENIED;
+            case 2001:
+              return errors.UNEXPECTED_SERVER_RESPONSE;
+            default:
+              return undefined;
           }
-          _completion(error);
+        }
+        if (!_socket) {
+          dispatchSocketIsNullError('signal', errorCallback);
           return;
         }
-        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-          args[_key3 - 1] = arguments[_key3];
+        _socket.signal(_options, error => {
+          if (error) {
+            const errorName = getErrorNameFromCode(error.code);
+            if (errorName) {
+              error = otError(errorName, new Error(error.message), error.code);
+            }
+            errorCallback(error);
+            return;
+          }
+          _completion();
+          resolve();
+        }, this.logEvent);
+        if (options && options.data && typeof options.data !== 'string') {
+          _logging.warn('Signaling of anything other than Strings is deprecated. ' + 'Please update the data property to be a string.');
         }
-        _completion(error, ...args);
-      }, this.logEvent);
-      if (options && options.data && typeof options.data !== 'string') {
-        _logging.warn('Signaling of anything other than Strings is deprecated. ' + 'Please update the data property to be a string.');
-      }
+      });
     };
 
     /**
@@ -72155,40 +72191,49 @@ function SessionFactory(deps) {
     * });
     * </pre>
     *
+    * @returns {Promise<void>} A promise that resolves when the disconnection happens
+    *
     * @method #forceDisconnect
     * @memberOf Session
     */
 
     this.forceDisconnect = function (connectionOrConnectionId, completionHandler) {
-      if (!this.isConnected()) {
-        const notConnectedErrorMsg = 'Cannot call forceDisconnect(). You are not ' + 'connected to the session.';
-        dispatchOTError(otError(errors.NOT_CONNECTED, new Error(notConnectedErrorMsg), ExceptionCodes.NOT_CONNECTED), completionHandler);
-        return;
-      }
-      const connectionId = typeof connectionOrConnectionId === 'string' ? connectionOrConnectionId : connectionOrConnectionId.id;
-      const invalidParameterErrorMsg = 'Invalid Parameter. Check that you have passed valid parameter values into the method call.';
-      if (!connectionId) {
-        dispatchOTError(otError(errors.INVALID_PARAMETER, new Error(invalidParameterErrorMsg), ExceptionCodes.INVALID_PARAMETER), completionHandler);
-        return;
-      }
-      const notPermittedErrorMsg = 'This token does not allow forceDisconnect. ' + 'The role must be at least `moderator` to enable this functionality';
-      if (!permittedTo('forceDisconnect')) {
-        dispatchOTError(otError(errors.PERMISSION_DENIED, new Error(notPermittedErrorMsg), ExceptionCodes.UNABLE_TO_FORCE_DISCONNECT), completionHandler);
-        return;
-      }
-      if (!_socket) {
-        dispatchSocketIsNullError('forceDisconnect', completionHandler);
-        return;
+      if (completionHandler === void 0) {
+        completionHandler = () => {};
       }
-      _socket.forceDisconnect(connectionId, function (err) {
-        if (err) {
-          dispatchOTError(otError(errors.INVALID_PARAMETER, new Error(invalidParameterErrorMsg), ExceptionCodes.INVALID_PARAMETER), completionHandler);
-        } else if (completionHandler && (0, _isFunction.default)(completionHandler)) {
-          for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
-            args[_key4 - 1] = arguments[_key4];
-          }
-          completionHandler(err, ...args);
+      return new Promise((resolve, reject) => {
+        const errorCallback = function errorCallback() {
+          if (typeof completionHandler === 'function') completionHandler(...arguments);
+          reject(...arguments);
+        };
+        if (!this.isConnected()) {
+          const notConnectedErrorMsg = 'Cannot call forceDisconnect(). You are not ' + 'connected to the session.';
+          dispatchOTError(otError(errors.NOT_CONNECTED, new Error(notConnectedErrorMsg), ExceptionCodes.NOT_CONNECTED), errorCallback);
+          return;
+        }
+        const connectionId = typeof connectionOrConnectionId === 'string' ? connectionOrConnectionId : connectionOrConnectionId.id;
+        const invalidParameterErrorMsg = 'Invalid Parameter. Check that you have passed valid parameter values into the method call.';
+        if (!connectionId) {
+          dispatchOTError(otError(errors.INVALID_PARAMETER, new Error(invalidParameterErrorMsg), ExceptionCodes.INVALID_PARAMETER), errorCallback);
+          return;
+        }
+        const notPermittedErrorMsg = 'This token does not allow forceDisconnect. ' + 'The role must be at least `moderator` to enable this functionality';
+        if (!permittedTo('forceDisconnect')) {
+          dispatchOTError(otError(errors.PERMISSION_DENIED, new Error(notPermittedErrorMsg), ExceptionCodes.UNABLE_TO_FORCE_DISCONNECT), errorCallback);
+          return;
         }
+        if (!_socket) {
+          dispatchSocketIsNullError('forceDisconnect', errorCallback);
+          return;
+        }
+        _socket.forceDisconnect(connectionId, err => {
+          if (err) {
+            dispatchOTError(otError(errors.INVALID_PARAMETER, new Error(invalidParameterErrorMsg), ExceptionCodes.INVALID_PARAMETER), errorCallback);
+          } else {
+            completionHandler();
+            resolve();
+          }
+        });
       });
     };
 
@@ -72246,6 +72291,8 @@ function SessionFactory(deps) {
     *   });
     * </pre>
     *
+    * @returns {Promise<void>} A promise that resolves when the unpublish happens
+    *
     * @method #forceUnpublish
     * @memberOf Session
     */
@@ -72254,61 +72301,68 @@ function SessionFactory(deps) {
       if (completionHandler === void 0) {
         completionHandler = () => {};
       }
-      const dispatchError = err => dispatchOTError(otError(err.name, new Error(err.msg), err.code), completionHandler);
-      const invalidParameterError = {
-        msg: 'Invalid Parameter. Check that you have passed valid parameter values into the method call.',
-        code: ExceptionCodes.INVALID_PARAMETER,
-        name: errors.INVALID_PARAMETER
-      };
-      const notConnectedError = {
-        msg: 'Cannot call forceUnpublish(). You are not connected to the session.',
-        code: ExceptionCodes.NOT_CONNECTED,
-        name: errors.NOT_CONNECTED
-      };
-      const notPermittedError = {
-        msg: 'This token does not allow forceUnpublish. The role must be at least `moderator` to enable this ' + 'functionality',
-        code: ExceptionCodes.UNABLE_TO_FORCE_UNPUBLISH,
-        name: errors.PERMISSION_DENIED
-      };
-      const notFoundError = {
-        msg: 'The stream does not exist.',
-        name: errors.NOT_FOUND
-      };
-      const unexpectedError = {
-        msg: 'An unexpected error occurred.',
-        name: errors.UNEXPECTED_SERVER_RESPONSE,
-        code: ExceptionCodes.UNEXPECTED_SERVER_RESPONSE
-      };
-      if (!streamOrStreamId) {
-        dispatchError(invalidParameterError);
-        return;
-      }
-      if (!_this.isConnected()) {
-        dispatchError(notConnectedError);
-        return;
-      }
-      const stream = getStream(streamOrStreamId);
-      if (!permittedTo('forceUnpublish')) {
-        // if this throws an error the handleJsException won't occur
-        dispatchError(notPermittedError);
-        return;
-      }
-      if (!_socket) {
-        dispatchSocketIsNullError('forceUnpublish', completionHandler);
-        return;
-      }
-      _socket.forceUnpublish(stream.id, err => {
-        if (!err) {
-          completionHandler(null);
+      return new Promise((resolve, reject) => {
+        const errorCallback = function errorCallback() {
+          if (typeof completionHandler === 'function') completionHandler(...arguments);
+          reject(...arguments);
+        };
+        const dispatchError = err => dispatchOTError(otError(err.name, new Error(err.msg), err.code), errorCallback);
+        const invalidParameterError = {
+          msg: 'Invalid Parameter. Check that you have passed valid parameter values into the method call.',
+          code: ExceptionCodes.INVALID_PARAMETER,
+          name: errors.INVALID_PARAMETER
+        };
+        const notConnectedError = {
+          msg: 'Cannot call forceUnpublish(). You are not connected to the session.',
+          code: ExceptionCodes.NOT_CONNECTED,
+          name: errors.NOT_CONNECTED
+        };
+        const notPermittedError = {
+          msg: 'This token does not allow forceUnpublish. The role must be at least `moderator` to enable this ' + 'functionality',
+          code: ExceptionCodes.UNABLE_TO_FORCE_UNPUBLISH,
+          name: errors.PERMISSION_DENIED
+        };
+        const notFoundError = {
+          msg: 'The stream does not exist.',
+          name: errors.NOT_FOUND
+        };
+        const unexpectedError = {
+          msg: 'An unexpected error occurred.',
+          name: errors.UNEXPECTED_SERVER_RESPONSE,
+          code: ExceptionCodes.UNEXPECTED_SERVER_RESPONSE
+        };
+        if (!streamOrStreamId) {
+          dispatchError(invalidParameterError);
+          return;
+        }
+        if (!_this.isConnected()) {
+          dispatchError(notConnectedError);
           return;
         }
-        if (err.code === '404') {
-          dispatchError(notFoundError);
-        } else if (err.code === '403') {
+        const stream = getStream(streamOrStreamId);
+        if (!permittedTo('forceUnpublish')) {
+          // if this throws an error the handleJsException won't occur
           dispatchError(notPermittedError);
-        } else {
-          dispatchError(unexpectedError);
+          return;
+        }
+        if (!_socket) {
+          dispatchSocketIsNullError('forceUnpublish', errorCallback);
+          return;
         }
+        _socket.forceUnpublish(stream.id, err => {
+          if (!err) {
+            completionHandler();
+            resolve();
+            return;
+          }
+          if (err.code === '404') {
+            dispatchError(notFoundError);
+          } else if (err.code === '403') {
+            dispatchError(notPermittedError);
+          } else {
+            dispatchError(unexpectedError);
+          }
+        });
       });
     };