@stream-io/video-client 1.30.1 → 1.32.0

package/dist/index.cjs.js

@@ -8,6 +8,7 @@ var twirpTransport = require('@protobuf-ts/twirp-transport');
 var rxjs = require('rxjs');
 var uaParserJs = require('ua-parser-js');
 var sdpTransform = require('sdp-transform');
+var workerTimer = require('@stream-io/worker-timer');
 var https = require('https');
 
 /* tslint:disable */
@@ -2950,6 +2951,12 @@ class JoinRequest$Type extends runtime.MessageType {
         super('stream.video.sfu.event.JoinRequest', [
             { no: 1, name: 'token', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 13,
+                name: 'unified_session_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
             {
                 no: 3,
                 name: 'subscriber_sdp',
@@ -5759,7 +5766,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.30.1";
+const version = "1.32.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7896,137 +7903,12 @@ function lazy(factory) {
     };
 }
 
-// Do not modify this file manually. Instead, edit worker.ts
-// and the run ./generate-timer-worker.sh
-const timerWorker = {
-    src: `const timerIdMapping = new Map();
-self.addEventListener('message', (event) => {
-    const request = event.data;
-    switch (request.type) {
-        case 'setTimeout':
-        case 'setInterval':
-            timerIdMapping.set(request.id, (request.type === 'setTimeout' ? setTimeout : setInterval)(() => {
-                tick(request.id);
-                if (request.type === 'setTimeout') {
-                    timerIdMapping.delete(request.id);
-                }
-            }, request.timeout));
-            break;
-        case 'clearTimeout':
-        case 'clearInterval':
-            (request.type === 'clearTimeout' ? clearTimeout : clearInterval)(timerIdMapping.get(request.id));
-            timerIdMapping.delete(request.id);
-            break;
-    }
-});
-function tick(id) {
-    const message = { type: 'tick', id };
-    self.postMessage(message);
-}`,
-};
-
-class TimerWorker {
-    constructor() {
-        this.currentTimerId = 1;
-        this.callbacks = new Map();
-        this.fallback = false;
-    }
-    setup({ useTimerWorker = true } = {}) {
-        if (!useTimerWorker) {
-            this.fallback = true;
-            return;
-        }
-        try {
-            const source = timerWorker.src;
-            const blob = new Blob([source], {
-                type: 'application/javascript; charset=utf-8',
-            });
-            const script = URL.createObjectURL(blob);
-            this.worker = new Worker(script, { name: 'str-timer-worker' });
-            this.worker.addEventListener('message', (event) => {
-                const { type, id } = event.data;
-                if (type === 'tick') {
-                    this.callbacks.get(id)?.();
-                }
-            });
-        }
-        catch (err) {
-            getLogger(['timer-worker'])('error', err);
-            this.fallback = true;
-        }
-    }
-    destroy() {
-        this.callbacks.clear();
-        this.worker?.terminate();
-        this.worker = undefined;
-        this.fallback = false;
-    }
-    get ready() {
-        return this.fallback || Boolean(this.worker);
-    }
-    setInterval(callback, timeout) {
-        return this.setTimer('setInterval', callback, timeout);
-    }
-    clearInterval(id) {
-        this.clearTimer('clearInterval', id);
-    }
-    setTimeout(callback, timeout) {
-        return this.setTimer('setTimeout', callback, timeout);
-    }
-    clearTimeout(id) {
-        this.clearTimer('clearTimeout', id);
-    }
-    setTimer(type, callback, timeout) {
-        if (!this.ready) {
-            this.setup();
-        }
-        if (this.fallback) {
-            return (type === 'setTimeout' ? setTimeout : setInterval)(callback, timeout);
-        }
-        const id = this.getTimerId();
-        this.callbacks.set(id, () => {
-            callback();
-            // Timeouts are one-off operations, so no need to keep callback reference
-            // after timer has fired
-            if (type === 'setTimeout') {
-                this.callbacks.delete(id);
-            }
-        });
-        this.sendMessage({ type, id, timeout });
-        return id;
-    }
-    clearTimer(type, id) {
-        if (!id) {
-            return;
-        }
-        if (!this.ready) {
-            this.setup();
-        }
-        if (this.fallback) {
-            (type === 'clearTimeout' ? clearTimeout : clearInterval)(id);
-            return;
-        }
-        this.callbacks.delete(id);
-        this.sendMessage({ type, id });
-    }
-    getTimerId() {
-        return this.currentTimerId++;
-    }
-    sendMessage(message) {
-        if (!this.worker) {
-            throw new Error("Cannot use timer worker before it's set up");
-        }
-        this.worker.postMessage(message);
-    }
-}
 let timerWorkerEnabled = false;
 const enableTimerWorker = () => {
     timerWorkerEnabled = true;
 };
 const getTimers = lazy(() => {
-    const instance = new TimerWorker();
-    instance.setup({ useTimerWorker: timerWorkerEnabled });
-    return instance;
+    return new workerTimer.WorkerTimer({ useWorker: timerWorkerEnabled });
 });
 
 /**
@@ -11995,7 +11877,6 @@ class Call {
             if ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
                 throw new Error(`Illegal State: call.join() shall be called only once`);
             }
-            this.state.setCallingState(exports.CallingState.JOINING);
             // we will count the number of join failures per SFU.
             // once the number of failures reaches 2, we will piggyback on the `migrating_from`
             // field to force the coordinator to provide us another SFU
@@ -12024,8 +11905,6 @@ class Call {
                         joinData.migrating_from = sfuId;
                     }
                     if (attempt === maxJoinRetries - 1) {
-                        // restore the previous call state if the join-flow fails
-                        this.state.setCallingState(callingState);
                         throw err;
                     }
                 }
@@ -12085,6 +11964,7 @@ class Call {
                 })
                 : previousSfuClient;
             this.sfuClient = sfuClient;
+            this.unifiedSessionId ?? (this.unifiedSessionId = sfuClient.sessionId);
             this.dynascaleManager.setSfuClient(sfuClient);
             const clientDetails = await getClientDetails();
             // we don't need to send JoinRequest if we are re-using an existing healthy SFU client
@@ -12108,6 +11988,7 @@ class Call {
                     : [];
                 try {
                     const { callState, fastReconnectDeadlineSeconds, publishOptions } = await sfuClient.join({
+                        unifiedSessionId: this.unifiedSessionId,
                         subscriberSdp,
                         publisherSdp,
                         clientDetails,
@@ -12153,6 +12034,7 @@ class Call {
                     statsOptions,
                     publishOptions: this.currentPublishOptions || [],
                     closePreviousInstances: !performingMigration,
+                    unifiedSessionId: this.unifiedSessionId,
                 });
             }
             // make sure we only track connection timing if we are not calling this method as part of a reconnection flow
@@ -12279,7 +12161,7 @@ class Call {
          * @internal
          */
         this.initPublisherAndSubscriber = (opts) => {
-            const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, } = opts;
+            const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, unifiedSessionId, } = opts;
             const { enable_rtc_stats: enableTracing } = statsOptions;
             if (closePreviousInstances && this.subscriber) {
                 this.subscriber.dispose();
@@ -12334,7 +12216,6 @@ class Call {
             this.tracer.setEnabled(enableTracing);
             this.sfuStatsReporter?.stop();
             if (statsOptions?.reporting_interval_ms > 0) {
-                this.unifiedSessionId ?? (this.unifiedSessionId = sfuClient.sessionId);
                 this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {
                     clientDetails,
                     options: statsOptions,
@@ -12344,7 +12225,7 @@ class Call {
                     camera: this.camera,
                     state: this.state,
                     tracer: this.tracer,
-                    unifiedSessionId: this.unifiedSessionId,
+                    unifiedSessionId,
                 });
                 this.sfuStatsReporter.start();
             }
@@ -14664,7 +14545,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.30.1", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.32.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -14853,6 +14734,7 @@ class StreamVideoClient {
         this.effectsRegistered = false;
         this.eventHandlersToUnregister = [];
         this.connectionConcurrencyTag = Symbol('connectionConcurrencyTag');
+        this.rejectCallWhenBusy = false;
         this.registerClientInstance = (apiKey, user) => {
             const instanceKey = getInstanceKey(apiKey, user);
             if (StreamVideoClient._instances.has(instanceKey)) {
@@ -14898,7 +14780,16 @@ class StreamVideoClient {
                     let call = this.writeableStateStore.findCall(e.call.type, e.call.id);
                     if (call) {
                         if (ringing) {
-                            await call.updateFromRingingEvent(e);
+                            if (this.shouldRejectCall(call.cid)) {
+                                this.logger('info', `Leaving call with busy reject reason ${call.cid} because user is busy`);
+                                // remove the instance from the state store
+                                await call.leave();
+                                // explicitly reject the call with busy reason as calling state was not ringing before and leave would not call it therefore
+                                await call.reject('busy');
+                            }
+                            else {
+                                await call.updateFromRingingEvent(e);
+                            }
                         }
                         else {
                             call.state.updateFromCallResponse(e.call);
@@ -14913,11 +14804,19 @@ class StreamVideoClient {
                         clientStore: this.writeableStateStore,
                         ringing,
                     });
-                    call.state.updateFromCallResponse(e.call);
                     if (ringing) {
-                        await call.get();
+                        if (this.shouldRejectCall(call.cid)) {
+                            this.logger('info', `Rejecting call ${call.cid} because user is busy`);
+                            // call is not in the state store yet, so just reject api is enough
+                            await call.reject('busy');
+                        }
+                        else {
+                            await call.updateFromRingingEvent(e);
+                            await call.get();
+                        }
                     }
                     else {
+                        call.state.updateFromCallResponse(e.call);
                         this.writeableStateStore.registerCall(call);
                         this.logger('info', `New call created and registered: ${call.cid}`);
                     }
@@ -15184,6 +15083,16 @@ class StreamVideoClient {
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
             return withoutConcurrency(this.connectionConcurrencyTag, () => this.streamClient.connectAnonymousUser(user, tokenOrProvider));
         };
+        this.shouldRejectCall = (currentCallId) => {
+            if (!this.rejectCallWhenBusy)
+                return false;
+            const hasOngoingRingingCall = this.state.calls.some((c) => c.cid !== currentCallId &&
+                c.ringing &&
+                c.state.callingState !== exports.CallingState.IDLE &&
+                c.state.callingState !== exports.CallingState.LEFT &&
+                c.state.callingState !== exports.CallingState.RECONNECTING_FAILED);
+            return hasOngoingRingingCall;
+        };
         const apiKey = typeof apiKeyOrArgs === 'string' ? apiKeyOrArgs : apiKeyOrArgs.apiKey;
         const clientOptions = typeof apiKeyOrArgs === 'string' ? opts : apiKeyOrArgs.options;
         if (clientOptions?.enableTimerWorker)
@@ -15191,6 +15100,7 @@ class StreamVideoClient {
         const rootLogger = clientOptions?.logger || logToConsole;
         setLogger(rootLogger, clientOptions?.logLevel || 'warn');
         this.logger = getLogger(['client']);
+        this.rejectCallWhenBusy = clientOptions?.rejectCallWhenBusy ?? false;
         this.streamClient = createCoordinatorClient(apiKey, clientOptions);
         this.writeableStateStore = new StreamVideoWriteableStateStore();
         this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(this.writeableStateStore);