@stream-io/video-client 0.0.8 → 0.0.10

package/dist/index.es.js

@@ -5695,6 +5695,19 @@ class Publisher {
                 return this.notifyTrackMuteStateChanged(undefined, transceiver.sender.track, trackType, true);
             }
         });
+        /**
+         * Returns true if the given track type is currently being published to the SFU.
+         *
+         * @param trackType the track type to check.
+         */
+        this.isPublishing = (trackType) => {
+            const transceiverForTrackType = this.transceiverRegistry[trackType];
+            if (transceiverForTrackType && transceiverForTrackType.sender) {
+                const sender = transceiverForTrackType.sender;
+                return !!sender.track && sender.track.readyState === 'live';
+            }
+            return false;
+        };
         this.notifyTrackMuteStateChanged = (mediaStream, track, trackType, isMuted) => __awaiter(this, void 0, void 0, function* () {
             yield this.sfuClient.updateMuteState(trackType, isMuted);
             const audioOrVideoOrScreenShareStream = trackTypeToParticipantStreamKey(trackType);
@@ -9294,20 +9307,22 @@ class Call {
         createSubscription(this.state.ownCapabilities$, (ownCapabilities) => {
             // update the permission context.
             this.permissionsContext.setPermissions(ownCapabilities);
+            if (!this.publisher)
+                return;
             // check if the user still has publishing permissions and stop publishing if not.
             const permissionToTrackType = {
                 [OwnCapability.SEND_AUDIO]: TrackType.AUDIO,
                 [OwnCapability.SEND_VIDEO]: TrackType.VIDEO,
                 [OwnCapability.SCREENSHARE]: TrackType.SCREEN_SHARE,
             };
-            Object.entries(permissionToTrackType).forEach(([permission, type]) => {
+            for (const [permission, trackType] of Object.entries(permissionToTrackType)) {
                 const hasPermission = this.permissionsContext.hasPermission(permission);
-                if (!hasPermission) {
-                    this.stopPublish(type).catch((err) => {
-                        console.error('Error stopping publish', type, err);
+                if (!hasPermission && this.publisher.isPublishing(trackType)) {
+                    this.stopPublish(trackType).catch((err) => {
+                        console.error('Error stopping publish', trackType, err);
                     });
                 }
-            });
+            }
         }), 
         // handles the case when the user is blocked by the call owner.
         createSubscription(this.state.metadata$, (metadata) => __awaiter(this, void 0, void 0, function* () {
@@ -10206,7 +10221,7 @@ class TokenManager {
                 return;
             // Don't allow empty token for non-server side client.
             if (!this.secret && !tokenOrProvider) {
-                throw new Error('User token can not be empty');
+                throw new Error('UserWithId token can not be empty');
             }
             if (tokenOrProvider &&
                 typeof tokenOrProvider !== 'string' &&
@@ -10519,7 +10534,7 @@ class StreamClient {
         /**
          * connectUser - Set the current user and open a WebSocket connection
          *
-         * @param {OwnUserResponse} user Data about this user. IE {name: "john"}
+         * @param user Data about this user. IE {name: "john"}
          * @param {TokenOrProvider} userTokenOrProvider Token or provider
          *
          * @return {ConnectAPIResponse} Returns a promise that resolves when the connection is setup
@@ -10596,7 +10611,7 @@ class StreamClient {
         this.openConnection = () => __awaiter(this, void 0, void 0, function* () {
             var _d, _e, _f;
             if (!this.userID) {
-                throw Error('User is not set on client, use client.connectUser or client.connectAnonymousUser instead');
+                throw Error('UserWithId is not set on client, use client.connectUser or client.connectAnonymousUser instead');
             }
             if (((_d = this.wsConnection) === null || _d === void 0 ? void 0 : _d.isConnecting) && this.wsPromise) {
                 this.logger('info', 'client:openConnection() - connection already in progress', {
@@ -10656,7 +10671,9 @@ class StreamClient {
         });
         this.doAxiosRequest = (type, url, data, options = {}) => __awaiter(this, void 0, void 0, function* () {
             var _g;
-            yield this.tokenManager.tokenReady();
+            if (!options.publicEndpoint || this.user) {
+                yield this.tokenManager.tokenReady();
+            }
             const requestConfig = this._enrichAxiosOptions(options);
             try {
                 let response;
@@ -11009,7 +11026,7 @@ class StreamClient {
     }
     getUserAgent() {
         return (this.userAgent ||
-            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.7"}`);
+            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.9"}`);
     }
     setUserAgent(userAgent) {
         this.userAgent = userAgent;
@@ -11020,7 +11037,7 @@ class StreamClient {
         config: {},
     }) {
         var _a;
-        const token = this._getToken();
+        const token = options.publicEndpoint && !this.user ? undefined : this._getToken();
         const authorization = token ? { Authorization: token } : undefined;
         let signal = null;
         if (this.nextRequestAbortController !== null) {
@@ -11030,7 +11047,9 @@ class StreamClient {
         if (!((_a = options.headers) === null || _a === void 0 ? void 0 : _a['x-client-request-id'])) {
             options.headers = Object.assign(Object.assign({}, options.headers), { 'x-client-request-id': randomId() });
         }
-        return Object.assign(Object.assign(Object.assign({ params: Object.assign({ user_id: this.userID, connection_id: this._getConnectionID(), api_key: this.key }, options.params), headers: Object.assign(Object.assign(Object.assign({}, authorization), { 'stream-auth-type': this.getAuthType(), 'X-Stream-Client': this.getUserAgent() }), options.headers) }, (signal ? { signal } : {})), options.config), this.options.axiosRequestConfig);
+        return Object.assign(Object.assign(Object.assign({ params: Object.assign({ user_id: this.userID, connection_id: this._getConnectionID(), api_key: this.key }, options.params), headers: Object.assign(Object.assign(Object.assign({}, authorization), { 'stream-auth-type': options.publicEndpoint && !this.user
+                    ? 'anonymous'
+                    : this.getAuthType(), 'X-Stream-Client': this.getUserAgent() }), options.headers) }, (signal ? { signal } : {})), options.config), this.options.axiosRequestConfig);
     }
     _getToken() {
         if (!this.tokenManager)
@@ -11047,7 +11066,7 @@ class StreamClient {
      * createToken - Creates a token to authenticate this user. This function is used server side.
      * The resulting token should be passed to the client side when the users registers or logs in.
      *
-     * @param {string} userID The User ID
+     * @param {string} userID The UserWithId ID
      * @param {number} [exp] The expiration time for the token expressed in the number of seconds since the epoch
      * @param call_cids for anonymous tokens you have to provide the call cids the use can join
      *
@@ -11082,108 +11101,6 @@ class StreamVideoClient {
      */
     constructor(apiKey, opts) {
         this.eventHandlersToUnregister = [];
-        /**
-         * Connects the given user to the client.
-         * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
-         * If the connection is successful, the connected user [state variable](#readonlystatestore) will be updated accordingly.
-         *
-         * @param user the user to connect.
-         * @param tokenOrProvider a token or a function that returns a token.
-         */
-        this.connectUser = (user, tokenOrProvider) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const connectUser = () => {
-                return this.streamClient.connectUser(
-                // @ts-expect-error
-                user, tokenOrProvider);
-            };
-            this.connectionPromise = this.disconnectionPromise
-                ? this.disconnectionPromise.then(() => connectUser())
-                : connectUser();
-            (_a = this.connectionPromise) === null || _a === void 0 ? void 0 : _a.finally(() => (this.connectionPromise = undefined));
-            const connectUserResponse = yield this.connectionPromise;
-            this.writeableStateStore.setConnectedUser(user);
-            this.eventHandlersToUnregister.push(this.on('connection.changed', (e) => {
-                const event = e;
-                if (event.online) {
-                    const callsToReWatch = this.writeableStateStore.calls
-                        .filter((call) => call.watching)
-                        .map((call) => call.cid);
-                    if (callsToReWatch.length > 0) {
-                        this.queryCalls({
-                            watch: true,
-                            filter_conditions: {
-                                cid: { $in: callsToReWatch },
-                            },
-                            sort: [{ field: 'cid', direction: 1 }],
-                        }).catch((err) => {
-                            console.warn('Failed to re-watch calls', err);
-                        });
-                    }
-                }
-            }));
-            this.eventHandlersToUnregister.push(this.on('call.created', (event) => {
-                if (event.type !== 'call.created')
-                    return;
-                const { call, members } = event;
-                if (user.id === call.created_by.id) {
-                    console.warn('Received `call.created` sent by the current user');
-                    return;
-                }
-                this.writeableStateStore.registerCall(new Call({
-                    streamClient: this.streamClient,
-                    type: call.type,
-                    id: call.id,
-                    metadata: call,
-                    members,
-                    clientStore: this.writeableStateStore,
-                }));
-            }));
-            this.eventHandlersToUnregister.push(this.on('call.ring', (event) => __awaiter(this, void 0, void 0, function* () {
-                if (event.type !== 'call.ring')
-                    return;
-                const { call, members } = event;
-                if (user.id === call.created_by.id) {
-                    console.warn('Received `call.ring` sent by the current user');
-                    return;
-                }
-                // The call might already be tracked by the client,
-                // if `call.created` was received before `call.ring`.
-                // In that case, we just reuse the already tracked call.
-                let theCall = this.writeableStateStore.findCall(call.type, call.id);
-                if (!theCall) {
-                    // otherwise, we create a new call
-                    theCall = new Call({
-                        streamClient: this.streamClient,
-                        type: call.type,
-                        id: call.id,
-                        members,
-                        clientStore: this.writeableStateStore,
-                        ringing: true,
-                    });
-                }
-                // we fetch the latest metadata for the call from the server
-                yield theCall.get({ ring: true });
-                this.writeableStateStore.registerCall(theCall);
-            })));
-            return connectUserResponse;
-        });
-        /**
-         * Connects the given anonymous user to the client.
-         *
-         * @param user the user to connect.
-         * @param tokenOrProvider a token or a function that returns a token.
-         */
-        this.connectAnonymousUser = (user, tokenOrProvider) => __awaiter(this, void 0, void 0, function* () {
-            const connectAnonymousUser = () => 
-            // @ts-expect-error
-            this.streamClient.connectAnonymousUser(user, tokenOrProvider);
-            this.connectionPromise = this.disconnectionPromise
-                ? this.disconnectionPromise.then(() => connectAnonymousUser())
-                : connectAnonymousUser();
-            this.connectionPromise.finally(() => (this.connectionPromise = undefined));
-            return this.connectionPromise;
-        });
         /**
          * Disconnects the currently connected user from the client.
          *
@@ -11244,7 +11161,7 @@ class StreamVideoClient {
          * @param data the data for the guest user.
          */
         this.createGuestUser = (data) => __awaiter(this, void 0, void 0, function* () {
-            return this.streamClient.post('/guest', data);
+            return this.streamClient.doAxiosRequest('post', '/guest', data, { publicEndpoint: true });
         });
         /**
          * Will query the API for calls matching the given filters.
@@ -11325,10 +11242,123 @@ class StreamVideoClient {
         this.removeDevice = (id, userID) => __awaiter(this, void 0, void 0, function* () {
             return yield this.streamClient.delete('/devices', Object.assign({ id }, (userID ? { user_id: userID } : {})));
         });
+        /**
+         * Connects the given anonymous user to the client.
+         *
+         * @param user the user to connect.
+         * @param tokenOrProvider a token or a function that returns a token.
+         */
+        this.connectAnonymousUser = (user, tokenOrProvider) => __awaiter(this, void 0, void 0, function* () {
+            const connectAnonymousUser = () => this.streamClient.connectAnonymousUser(user, tokenOrProvider);
+            this.connectionPromise = this.disconnectionPromise
+                ? this.disconnectionPromise.then(() => connectAnonymousUser())
+                : connectAnonymousUser();
+            this.connectionPromise.finally(() => (this.connectionPromise = undefined));
+            return this.connectionPromise;
+        });
         this.streamClient = new StreamClient(apiKey, Object.assign({ persistUserOnConnectionFailure: true }, opts));
         this.writeableStateStore = new StreamVideoWriteableStateStore();
         this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(this.writeableStateStore);
     }
+    /**
+     * Connects the given user to the client.
+     * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
+     * If the connection is successful, the connected user [state variable](#readonlystatestore) will be updated accordingly.
+     *
+     * @param user the user to connect.
+     * @param tokenOrProvider a token or a function that returns a token.
+     */
+    connectUser(user, token) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (user.type === 'anonymous') {
+                user.id = '!anon';
+                return this.connectAnonymousUser(user, token);
+            }
+            if (user.type === 'guest') {
+                const response = yield this.createGuestUser({
+                    user: Object.assign(Object.assign({}, user), { role: 'guest' }),
+                });
+                return this.connectUser(response.user, response.access_token);
+            }
+            const connectUser = () => {
+                return this.streamClient.connectUser(user, token);
+            };
+            this.connectionPromise = this.disconnectionPromise
+                ? this.disconnectionPromise.then(() => connectUser())
+                : connectUser();
+            (_a = this.connectionPromise) === null || _a === void 0 ? void 0 : _a.finally(() => (this.connectionPromise = undefined));
+            const connectUserResponse = yield this.connectionPromise;
+            // connectUserResponse will be void if connectUser called twice for the same user
+            if (connectUserResponse === null || connectUserResponse === void 0 ? void 0 : connectUserResponse.me) {
+                this.writeableStateStore.setConnectedUser(connectUserResponse.me);
+            }
+            this.eventHandlersToUnregister.push(this.on('connection.changed', (e) => {
+                const event = e;
+                if (event.online) {
+                    const callsToReWatch = this.writeableStateStore.calls
+                        .filter((call) => call.watching)
+                        .map((call) => call.cid);
+                    if (callsToReWatch.length > 0) {
+                        this.queryCalls({
+                            watch: true,
+                            filter_conditions: {
+                                cid: { $in: callsToReWatch },
+                            },
+                            sort: [{ field: 'cid', direction: 1 }],
+                        }).catch((err) => {
+                            console.warn('Failed to re-watch calls', err);
+                        });
+                    }
+                }
+            }));
+            this.eventHandlersToUnregister.push(this.on('call.created', (event) => {
+                if (event.type !== 'call.created')
+                    return;
+                const { call, members } = event;
+                if (user.id === call.created_by.id) {
+                    console.warn('Received `call.created` sent by the current user');
+                    return;
+                }
+                this.writeableStateStore.registerCall(new Call({
+                    streamClient: this.streamClient,
+                    type: call.type,
+                    id: call.id,
+                    metadata: call,
+                    members,
+                    clientStore: this.writeableStateStore,
+                }));
+            }));
+            this.eventHandlersToUnregister.push(this.on('call.ring', (event) => __awaiter(this, void 0, void 0, function* () {
+                if (event.type !== 'call.ring')
+                    return;
+                const { call, members } = event;
+                if (user.id === call.created_by.id) {
+                    console.warn('Received `call.ring` sent by the current user');
+                    return;
+                }
+                // The call might already be tracked by the client,
+                // if `call.created` was received before `call.ring`.
+                // In that case, we just reuse the already tracked call.
+                let theCall = this.writeableStateStore.findCall(call.type, call.id);
+                if (!theCall) {
+                    // otherwise, we create a new call
+                    theCall = new Call({
+                        streamClient: this.streamClient,
+                        type: call.type,
+                        id: call.id,
+                        members,
+                        clientStore: this.writeableStateStore,
+                        ringing: true,
+                    });
+                }
+                // we fetch the latest metadata for the call from the server
+                yield theCall.get({ ring: true });
+                this.writeableStateStore.registerCall(theCall);
+            })));
+            return connectUserResponse;
+        });
+    }
     /**
      * addDevice - Adds a push device for a user.
      *