@stream-io/video-client 0.2.2 → 0.3.0

package/dist/index.es.js

@@ -6523,8 +6523,8 @@ class Publisher {
                 track.removeEventListener('ended', handleTrackEnded);
             });
             if (!transceiver) {
-                const metadata = this.state.metadata;
-                const targetResolution = metadata === null || metadata === void 0 ? void 0 : metadata.settings.video.target_resolution;
+                const { settings } = this.state;
+                const targetResolution = settings === null || settings === void 0 ? void 0 : settings.video.target_resolution;
                 const videoEncodings = trackType === TrackType.VIDEO
                     ? findOptimalVideoLayers(track, targetResolution)
                     : undefined;
@@ -6802,8 +6802,8 @@ class Publisher {
                 }
                 return String(media.mid);
             };
-            const metadata = this.state.metadata;
-            const targetResolution = metadata === null || metadata === void 0 ? void 0 : metadata.settings.video.target_resolution;
+            const { settings } = this.state;
+            const targetResolution = settings === null || settings === void 0 ? void 0 : settings.video.target_resolution;
             return this.pc
                 .getTransceivers()
                 .filter((t) => t.direction === 'sendonly' && t.sender.track)
@@ -6896,7 +6896,6 @@ class Publisher {
         this.pc = this.createPeerConnection(connectionConfig);
         this.sfuClient = sfuClient;
         this.state = state;
-        this.dispatcher = dispatcher;
         this.isDtxEnabled = isDtxEnabled;
         this.isRedEnabled = isRedEnabled;
         this.preferredVideoCodec = preferredVideoCodec;
@@ -7524,17 +7523,6 @@ const retryable = (rpc, logger) => __awaiter(void 0, void 0, void 0, function* (
     return rpcCallResult;
 });
 
-/**
- * Watches for `call.live_started` events.
- */
-const watchCallLiveStarted = (state) => {
-    return function onCallLiveStarted(event) {
-        if (event.type !== 'call.live_started')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { backstage: false })));
-    };
-};
-
 /**
  * Gets the current value of an observable, or undefined if the observable has
  * not emitted a value yet.
@@ -7977,71 +7965,29 @@ class CallState {
      *
      */
     constructor() {
-        /**
-         * The raw call metadata object, as defined on the backend.
-         *
-         * @internal
-         */
-        this.metadataSubject = new BehaviorSubject(undefined);
-        /**
-         * The list of members of the current call.
-         *
-         * @internal
-         */
+        this.backstageSubject = new BehaviorSubject(false);
+        this.blockedUserIdsSubject = new BehaviorSubject([]);
+        this.createdAtSubject = new BehaviorSubject(new Date());
+        this.endedAtSubject = new BehaviorSubject(undefined);
+        this.startsAtSubject = new BehaviorSubject(undefined);
+        this.updatedAtSubject = new BehaviorSubject(new Date());
+        this.createdBySubject = new BehaviorSubject(undefined);
+        this.customSubject = new BehaviorSubject({});
+        this.egressSubject = new BehaviorSubject(undefined);
+        this.ingressSubject = new BehaviorSubject(undefined);
+        this.recordingSubject = new BehaviorSubject(false);
+        this.sessionSubject = new BehaviorSubject(undefined);
+        this.settingsSubject = new BehaviorSubject(undefined);
+        this.transcribingSubject = new BehaviorSubject(false);
+        this.endedBySubject = new BehaviorSubject(undefined);
         this.membersSubject = new BehaviorSubject([]);
-        /**
-         * The list of capabilities of the current user.
-         *
-         * @private
-         */
         this.ownCapabilitiesSubject = new BehaviorSubject([]);
-        /**
-         * The calling state.
-         *
-         * @internal
-         */
         this.callingStateSubject = new BehaviorSubject(CallingState.UNKNOWN);
-        /**
-         * The time the call session actually started.
-         *
-         * @internal
-         */
         this.startedAtSubject = new BehaviorSubject(undefined);
-        /**
-         * The server-side counted number of participants connected to the current call.
-         * This number includes the anonymous participants as well.
-         *
-         * @internal
-         */
         this.participantCountSubject = new BehaviorSubject(0);
-        /**
-         * The server-side counted number of anonymous participants connected to the current call.
-         * This number excludes the regular participants.
-         *
-         * @internal
-         */
         this.anonymousParticipantCountSubject = new BehaviorSubject(0);
-        /**
-         * All participants of the current call (including the logged-in user).
-         *
-         * @internal
-         */
         this.participantsSubject = new BehaviorSubject([]);
-        /**
-         * The latest stats report of the current call.
-         * When stats gathering is enabled, this observable will emit a new value
-         * at a regular (configurable) interval.
-         *
-         * Consumers of this observable can implement their own batching logic
-         * in case they want to show historical stat data.
-         *
-         * @internal
-         */
         this.callStatsReportSubject = new BehaviorSubject(undefined);
-        /**
-         * Emits a list of details about recordings performed for the current call.
-         */
-        this.callRecordingListSubject = new BehaviorSubject([]);
         /**
          * A list of comparators that are used to sort the participants.
          *
@@ -8124,15 +8070,6 @@ class CallState {
         this.setCallingState = (state) => {
             return this.setCurrentValue(this.callingStateSubject, state);
         };
-        /**
-         * Sets the list of call recordings.
-         *
-         * @internal
-         * @param recordings the list of call recordings.
-         */
-        this.setCallRecordingsList = (recordings) => {
-            return this.setCurrentValue(this.callRecordingListSubject, recordings);
-        };
         /**
          * Sets the call stats report.
          *
@@ -8142,16 +8079,6 @@ class CallState {
         this.setCallStatsReport = (report) => {
             return this.setCurrentValue(this.callStatsReportSubject, report);
         };
-        /**
-         * Sets the metadata of the current call.
-         *
-         * @internal
-         *
-         * @param metadata the metadata to set.
-         */
-        this.setMetadata = (metadata) => {
-            return this.setCurrentValue(this.metadataSubject, metadata);
-        };
         /**
          * Sets the members of the current call.
          *
@@ -8250,6 +8177,19 @@ class CallState {
                 return p;
             }));
         };
+        /**
+         * Updates the call state with the data received from the server.
+         *
+         * @internal
+         *
+         * @param event the video event that our backend sent us.
+         */
+        this.updateFromEvent = (event) => {
+            const update = this.eventHandlers[event.type];
+            if (update) {
+                update(event);
+            }
+        };
         /**
          * Updates the participant pinned state with server side pinning data.
          *
@@ -8278,25 +8218,174 @@ class CallState {
                 return participant;
             }));
         };
-        this.logger = getLogger(['call-state']);
+        /**
+         * Updates the call state with the data received from the server.
+         *
+         * @internal
+         *
+         * @param call the call response from the server.
+         */
+        this.updateFromCallResponse = (call) => {
+            this.setCurrentValue(this.backstageSubject, call.backstage);
+            this.setCurrentValue(this.blockedUserIdsSubject, call.blocked_user_ids);
+            this.setCurrentValue(this.createdAtSubject, new Date(call.created_at));
+            this.setCurrentValue(this.updatedAtSubject, new Date(call.updated_at));
+            this.setCurrentValue(this.startsAtSubject, call.starts_at ? new Date(call.starts_at) : undefined);
+            this.setCurrentValue(this.endedAtSubject, call.ended_at ? new Date(call.ended_at) : undefined);
+            this.setCurrentValue(this.createdBySubject, call.created_by);
+            this.setCurrentValue(this.customSubject, call.custom);
+            this.setCurrentValue(this.egressSubject, call.egress);
+            this.setCurrentValue(this.ingressSubject, call.ingress);
+            this.setCurrentValue(this.recordingSubject, call.recording);
+            this.setCurrentValue(this.sessionSubject, call.session);
+            this.setCurrentValue(this.settingsSubject, call.settings);
+            this.setCurrentValue(this.transcribingSubject, call.transcribing);
+        };
+        this.updateFromMemberRemoved = (event) => {
+            this.setCurrentValue(this.membersSubject, (members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
+        };
+        this.updateFromMemberAdded = (event) => {
+            this.setCurrentValue(this.membersSubject, (members) => [
+                ...members,
+                ...event.members,
+            ]);
+        };
+        this.updateFromBroadcastStopped = () => {
+            this.setCurrentValue(this.egressSubject, (egress) => (Object.assign(Object.assign({}, egress), { broadcasting: false })));
+        };
+        this.updateFromBroadcastStarted = (event) => {
+            this.setCurrentValue(this.egressSubject, (egress) => (Object.assign(Object.assign({}, egress), { broadcasting: true, hls: Object.assign(Object.assign({}, egress.hls), { playlist_url: event.hls_playlist_url }) })));
+        };
+        this.updateFromSessionParticipantLeft = (event) => {
+            this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session) {
+                    this.logger('warn', `Received call.session_participant_left event but no session is available.`, event);
+                    return session;
+                }
+                const { participants, participants_count_by_role } = session;
+                const { user, user_session_id } = event.participant;
+                return Object.assign(Object.assign({}, session), { participants: participants.filter((p) => p.user_session_id !== user_session_id), participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: Math.max(0, (participants_count_by_role[user.role] || 0) - 1) }) });
+            });
+        };
+        this.updateFromSessionParticipantJoined = (event) => {
+            this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session) {
+                    this.logger('warn', `Received call.session_participant_joined event but no session is available.`, event);
+                    return session;
+                }
+                const { participants, participants_count_by_role } = session;
+                const { user } = event.participant;
+                return Object.assign(Object.assign({}, session), { participants: [...participants, event.participant], participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: (participants_count_by_role[user.role] || 0) + 1 }) });
+            });
+        };
+        this.updateMembers = (event) => {
+            this.setCurrentValue(this.membersSubject, (members) => members.map((member) => {
+                const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
+                return memberUpdate ? memberUpdate : member;
+            }));
+        };
+        this.updateParticipantReaction = (event) => {
+            const { user, custom, type, emoji_code } = event.reaction;
+            this.setParticipants((participants) => {
+                return participants.map((p) => {
+                    // skip if the reaction is not for this participant
+                    if (p.userId !== user.id)
+                        return p;
+                    // update the participant with the new reaction
+                    return Object.assign(Object.assign({}, p), { reaction: {
+                            type,
+                            emoji_code,
+                            custom,
+                        } });
+                });
+            });
+        };
+        this.unblockUser = (event) => {
+            this.setCurrentValue(this.blockedUserIdsSubject, (current) => {
+                if (!current)
+                    return current;
+                return current.filter((id) => id !== event.user.id);
+            });
+        };
+        this.blockUser = (event) => {
+            this.setCurrentValue(this.blockedUserIdsSubject, (current) => [
+                ...(current || []),
+                event.user.id,
+            ]);
+        };
+        this.updateOwnCapabilities = (event) => {
+            var _a;
+            if (event.user.id === ((_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.userId)) {
+                this.setCurrentValue(this.ownCapabilitiesSubject, event.own_capabilities);
+            }
+        };
+        this.logger = getLogger(['CallState']);
         this.participants$ = this.participantsSubject.pipe(map$1((ps) => ps.sort(this.sortParticipantsBy)));
         this.localParticipant$ = this.participants$.pipe(map$1((participants) => participants.find(isStreamVideoLocalParticipant)));
         this.remoteParticipants$ = this.participants$.pipe(map$1((participants) => participants.filter((p) => !p.isLocalParticipant)));
         this.pinnedParticipants$ = this.participants$.pipe(map$1((participants) => participants.filter((p) => !!p.pin)));
         this.dominantSpeaker$ = this.participants$.pipe(map$1((participants) => participants.find((p) => p.isDominantSpeaker)));
-        this.hasOngoingScreenShare$ = this.participants$.pipe(map$1((participants) => {
-            return participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE));
-        }), distinctUntilChanged());
+        this.hasOngoingScreenShare$ = this.participants$.pipe(map$1((participants) => participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE))), distinctUntilChanged());
         this.startedAt$ = this.startedAtSubject.asObservable();
         this.participantCount$ = this.participantCountSubject.asObservable();
         this.anonymousParticipantCount$ =
             this.anonymousParticipantCountSubject.asObservable();
         this.callStatsReport$ = this.callStatsReportSubject.asObservable();
-        this.callRecordingList$ = this.callRecordingListSubject.asObservable();
-        this.metadata$ = this.metadataSubject.asObservable();
         this.members$ = this.membersSubject.asObservable();
         this.ownCapabilities$ = this.ownCapabilitiesSubject.asObservable();
         this.callingState$ = this.callingStateSubject.asObservable();
+        this.backstage$ = this.backstageSubject.asObservable();
+        this.blockedUserIds$ = this.blockedUserIdsSubject.asObservable();
+        this.createdAt$ = this.createdAtSubject.asObservable();
+        this.endedAt$ = this.endedAtSubject.asObservable();
+        this.startsAt$ = this.startsAtSubject.asObservable();
+        this.updatedAt$ = this.updatedAtSubject.asObservable();
+        this.createdBy$ = this.createdBySubject.asObservable();
+        this.custom$ = this.customSubject.asObservable();
+        this.egress$ = this.egressSubject.asObservable();
+        this.ingress$ = this.ingressSubject.asObservable();
+        this.recording$ = this.recordingSubject.asObservable();
+        this.session$ = this.sessionSubject.asObservable();
+        this.settings$ = this.settingsSubject.asObservable();
+        this.transcribing$ = this.transcribingSubject.asObservable();
+        this.endedBy$ = this.endedBySubject.asObservable();
+        this.eventHandlers = {
+            // these events are not updating the call state:
+            'call.permission_request': undefined,
+            'call.user_muted': undefined,
+            'connection.error': undefined,
+            'connection.ok': undefined,
+            'health.check': undefined,
+            custom: undefined,
+            // events that update call state:
+            'call.accepted': (e) => this.updateFromCallResponse(e.call),
+            'call.created': (e) => this.updateFromCallResponse(e.call),
+            'call.notification': (e) => this.updateFromCallResponse(e.call),
+            'call.rejected': (e) => this.updateFromCallResponse(e.call),
+            'call.ring': (e) => this.updateFromCallResponse(e.call),
+            'call.live_started': (e) => this.updateFromCallResponse(e.call),
+            'call.updated': (e) => this.updateFromCallResponse(e.call),
+            'call.session_started': (e) => this.updateFromCallResponse(e.call),
+            'call.session_ended': (e) => this.updateFromCallResponse(e.call),
+            'call.ended': (e) => {
+                this.updateFromCallResponse(e.call);
+                this.setCurrentValue(this.endedBySubject, e.user);
+            },
+            'call.recording_started': () => this.setCurrentValue(this.recordingSubject, true),
+            'call.recording_stopped': () => this.setCurrentValue(this.recordingSubject, false),
+            'call.broadcasting_started': this.updateFromBroadcastStarted,
+            'call.broadcasting_stopped': this.updateFromBroadcastStopped,
+            'call.session_participant_joined': this.updateFromSessionParticipantJoined,
+            'call.session_participant_left': this.updateFromSessionParticipantLeft,
+            'call.blocked_user': this.blockUser,
+            'call.unblocked_user': this.unblockUser,
+            'call.permissions_updated': this.updateOwnCapabilities,
+            'call.member_added': this.updateFromMemberAdded,
+            'call.member_removed': this.updateFromMemberRemoved,
+            'call.member_updated': this.updateMembers,
+            'call.member_updated_permission': this.updateMembers,
+            'call.reaction_new': this.updateParticipantReaction,
+        };
     }
     /**
      * The server-side counted number of participants connected to the current call.
@@ -8361,24 +8450,12 @@ class CallState {
     get callingState() {
         return this.getCurrentValue(this.callingState$);
     }
-    /**
-     * The list of call recordings.
-     */
-    get callRecordingsList() {
-        return this.getCurrentValue(this.callRecordingList$);
-    }
     /**
      * The call stats report.
      */
     get callStatsReport() {
         return this.getCurrentValue(this.callStatsReport$);
     }
-    /**
-     * The metadata of the current call.
-     */
-    get metadata() {
-        return this.getCurrentValue(this.metadata$);
-    }
     /**
      * The members of the current call.
      */
@@ -8391,6 +8468,96 @@ class CallState {
     get ownCapabilities() {
         return this.getCurrentValue(this.ownCapabilities$);
     }
+    /**
+     * The backstage state.
+     */
+    get backstage() {
+        return this.getCurrentValue(this.backstage$);
+    }
+    /**
+     * Will provide the list of blocked user IDs.
+     */
+    get blockedUserIds() {
+        return this.getCurrentValue(this.blockedUserIds$);
+    }
+    /**
+     * Will provide the time when this call has been created.
+     */
+    get createdAt() {
+        return this.getCurrentValue(this.createdAt$);
+    }
+    /**
+     * Will provide the time when this call has been ended.
+     */
+    get endedAt() {
+        return this.getCurrentValue(this.endedAt$);
+    }
+    /**
+     * Will provide the time when this call has been scheduled to start.
+     */
+    get startsAt() {
+        return this.getCurrentValue(this.startsAt$);
+    }
+    /**
+     * Will provide the time when this call has been updated.
+     */
+    get updatedAt() {
+        return this.getCurrentValue(this.updatedAt$);
+    }
+    /**
+     * Will provide the user who created this call.
+     */
+    get createdBy() {
+        return this.getCurrentValue(this.createdBy$);
+    }
+    /**
+     * Will provide the custom data of this call.
+     */
+    get custom() {
+        return this.getCurrentValue(this.custom$);
+    }
+    /**
+     * Will provide the egress data of this call.
+     */
+    get egress() {
+        return this.getCurrentValue(this.egress$);
+    }
+    /**
+     * Will provide the ingress data of this call.
+     */
+    get ingress() {
+        return this.getCurrentValue(this.ingress$);
+    }
+    /**
+     * Will provide the recording state of this call.
+     */
+    get recording() {
+        return this.getCurrentValue(this.recording$);
+    }
+    /**
+     * Will provide the session data of this call.
+     */
+    get session() {
+        return this.getCurrentValue(this.session$);
+    }
+    /**
+     * Will provide the settings of this call.
+     */
+    get settings() {
+        return this.getCurrentValue(this.settings$);
+    }
+    /**
+     * Will provide the transcribing state of this call.
+     */
+    get transcribing() {
+        return this.getCurrentValue(this.transcribing$);
+    }
+    /**
+     * Will provide the user who ended this call.
+     */
+    get endedBy() {
+        return this.getCurrentValue(this.endedBy$);
+    }
 }
 
 /**
@@ -8462,40 +8629,16 @@ const watchCallEnded = (call) => {
         return __awaiter(this, void 0, void 0, function* () {
             if (event.type !== 'call.ended')
                 return;
-            if (call.state.callingState === CallingState.RINGING ||
-                call.state.callingState === CallingState.JOINED ||
-                call.state.callingState === CallingState.JOINING) {
-                call.state.setMetadata(event.call);
+            const { callingState } = call.state;
+            if (callingState === CallingState.RINGING ||
+                callingState === CallingState.JOINED ||
+                callingState === CallingState.JOINING) {
                 yield call.leave();
             }
         });
     };
 };
-/**
- * An event handler which listens to `call.updated` events
- * and updates the given call state accordingly.
- */
-const watchCallUpdated = (state) => {
-    return function onCallUpdated(event) {
-        if (event.type !== 'call.updated')
-            return;
-        state.setMetadata(event.call);
-    };
-};
 
-/**
- * Event handler that watches for `call.permissions_updated` events
- */
-const watchCallPermissionsUpdated = (state) => {
-    return function onCallPermissionsUpdated(event) {
-        if (event.type !== 'call.permissions_updated')
-            return;
-        const { localParticipant } = state;
-        if (event.user.id === (localParticipant === null || localParticipant === void 0 ? void 0 : localParticipant.userId)) {
-            state.setOwnCapabilities(event.own_capabilities);
-        }
-    };
-};
 /**
  * Event handler that watches for `callGrantsUpdated` events.
  *
@@ -8609,57 +8752,6 @@ const watchPinsUpdated = (state) => {
     };
 };
 
-/**
- * Watches for `call.member_added` events.
- */
-const watchCallMemberAdded = (state) => {
-    return function onCallMemberAdded(event) {
-        if (event.type !== 'call.member_added')
-            return;
-        state.setMembers((members) => [...members, ...event.members]);
-    };
-};
-/**
- * Watches for `call.member_removed` events.
- */
-const watchCallMemberRemoved = (state) => {
-    return function onCallMemberRemoved(event) {
-        if (event.type !== 'call.member_removed')
-            return;
-        state.setMembers((members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
-    };
-};
-/**
- * Watches for `call.member_updated_permission` events.
- */
-const watchCallMemberUpdatedPermission = (state) => {
-    return function onCallMemberUpdated(event) {
-        if (event.type !== 'call.member_updated_permission')
-            return;
-        state.setMembers((members) => members.map((member) => {
-            const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
-            if (memberUpdate) {
-                member.user.role = memberUpdate.role;
-                member = Object.assign({}, member);
-            }
-            return member;
-        }));
-    };
-};
-/**
- * Watches for `call.member_updated` events.
- */
-const watchCallMemberUpdated = (state) => {
-    return function onCallMemberUpdated(event) {
-        if (event.type !== 'call.member_updated')
-            return;
-        state.setMembers((members) => members.map((member) => {
-            const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
-            return memberUpdate ? memberUpdate : member;
-        }));
-    };
-};
-
 /**
  * An event responder which handles the `participantJoined` event.
  */
@@ -8741,74 +8833,6 @@ const watchTrackUnpublished = (state) => {
 };
 const unique = (v, i, arr) => arr.indexOf(v) === i;
 
-/**
- * Watches the delivery of CallReactionEvent.
- *
- * @param state the state store to update.
- */
-const watchNewReactions = (state) => {
-    return function onNewReactions(event) {
-        if (event.type !== 'call.reaction_new')
-            return;
-        const { reaction } = event;
-        const { user, custom, type, emoji_code } = reaction;
-        state.setParticipants((participants) => {
-            return participants.map((p) => {
-                // skip if the reaction is not for this participant
-                if (p.userId !== user.id)
-                    return p;
-                // update the participant with the new reaction
-                return Object.assign(Object.assign({}, p), { reaction: {
-                        type,
-                        emoji_code,
-                        custom,
-                    } });
-            });
-        });
-    };
-};
-
-/**
- * Watches for `call.recording_started` events.
- */
-const watchCallRecordingStarted = (state) => {
-    return function onCallRecordingStarted(event) {
-        if (event.type !== 'call.recording_started')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { recording: true })));
-    };
-};
-/**
- * Watches for `call.recording_stopped` events.
- */
-const watchCallRecordingStopped = (state) => {
-    return function onCallRecordingStopped(event) {
-        if (event.type !== 'call.recording_stopped')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { recording: false })));
-    };
-};
-/**
- * Watches for `call.broadcasting_started` events.
- */
-const watchCallBroadcastingStarted = (state) => {
-    return function onCallBroadcastingStarted(event) {
-        if (event.type !== 'call.broadcasting_started')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { egress: Object.assign(Object.assign({}, metadata.egress), { broadcasting: true, hls: Object.assign(Object.assign({}, metadata.egress.hls), { playlist_url: event.hls_playlist_url }) }) })));
-    };
-};
-/**
- * Watches for `call.broadcasting_stopped` events.
- */
-const watchCallBroadcastingStopped = (state) => {
-    return function onCallBroadcastingStopped(event) {
-        if (event.type !== 'call.broadcasting_stopped')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { egress: Object.assign(Object.assign({}, metadata.egress), { broadcasting: false }) })));
-    };
-};
-
 /**
  * Watches for `dominantSpeakerChanged` events.
  */
@@ -8851,98 +8875,6 @@ const watchAudioLevelChanged = (dispatcher, state) => {
     });
 };
 
-/**
- * Watch for call.session_started events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionStarted = (state) => {
-    return function onCallSessionStarted(event) {
-        if (event.type !== 'call.session_started')
-            return;
-        state.setMetadata(event.call);
-    };
-};
-/**
- * Watch for call.session_ended events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionEnded = (state) => {
-    return function onCallSessionEnded(event) {
-        if (event.type !== 'call.session_ended')
-            return;
-        state.setMetadata(event.call);
-    };
-};
-/**
- * Watch for call.session_participant_joined events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionParticipantJoined = (state) => {
-    return function onCallParticipantJoined(event) {
-        if (event.type !== 'call.session_participant_joined')
-            return;
-        const { participant } = event;
-        state.setMetadata((metadata) => {
-            if (!metadata || !metadata.session) {
-                state.logger('warn', `Received call.session_participant_joined event but the metadata structure is invalid.`, event);
-                return metadata;
-            }
-            const { session } = metadata;
-            const { participants, participants_count_by_role } = session;
-            const { user } = participant;
-            return Object.assign(Object.assign({}, metadata), { session: Object.assign(Object.assign({}, session), { participants: [...participants, participant], participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: (participants_count_by_role[user.role] || 0) + 1 }) }) });
-        });
-    };
-};
-/**
- * Watch for call.session_participant_left events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionParticipantLeft = (state) => {
-    return function onCallParticipantLeft(event) {
-        if (event.type !== 'call.session_participant_left')
-            return;
-        const { user, user_session_id } = event.participant;
-        state.setMetadata((metadata) => {
-            if (!metadata || !metadata.session) {
-                state.logger('warn', `Received call.session_participant_left event but the metadata structure is invalid.`, event);
-                return metadata;
-            }
-            const { session } = metadata;
-            const { participants, participants_count_by_role } = session;
-            return Object.assign(Object.assign({}, metadata), { session: Object.assign(Object.assign({}, session), { participants: participants.filter((p) => p.user_session_id !== user_session_id), participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: Math.max(0, (participants_count_by_role[user.role] || 0) - 1) }) }) });
-        });
-    };
-};
-
-/**
- * Event handler that watches for `call.blocked_user` events,
- * updates the call store `blocked_user_ids` property by adding
- * `event.user_id` to the list
- */
-const watchBlockedUser = (state) => (event) => {
-    if (event.type !== 'call.blocked_user')
-        return;
-    state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { blocked_user_ids: [...((metadata === null || metadata === void 0 ? void 0 : metadata.blocked_user_ids) || []), event.user.id] })));
-};
-/**
- * Event handler that watches for `call.unblocked_user` events,
- * updates the call store `blocked_user_ids` property by
- * removing `event.user_id` from the list
- */
-const watchUnblockedUser = (state) => (event) => {
-    if (event.type !== 'call.unblocked_user')
-        return;
-    state.setMetadata((metadata) => {
-        const blocked_user_ids = ((metadata === null || metadata === void 0 ? void 0 : metadata.blocked_user_ids) || []).filter((userId) => event.user.id !== userId);
-        return Object.assign(Object.assign({}, metadata), { blocked_user_ids });
-    });
-};
-
 /**
  * Registers the default event handlers for a call during its lifecycle.
  *
@@ -8951,29 +8883,8 @@ const watchUnblockedUser = (state) => (event) => {
  * @param dispatcher the dispatcher.
  */
 const registerEventHandlers = (call, state, dispatcher) => {
-    const coordinatorEvents = {
-        'call.blocked_user': watchBlockedUser(state),
-        'call.broadcasting_started': watchCallBroadcastingStarted(state),
-        'call.broadcasting_stopped': watchCallBroadcastingStopped(state),
-        'call.ended': watchCallEnded(call),
-        'call.live_started': watchCallLiveStarted(state),
-        'call.member_added': watchCallMemberAdded(state),
-        'call.member_removed': watchCallMemberRemoved(state),
-        'call.member_updated': watchCallMemberUpdated(state),
-        'call.member_updated_permission': watchCallMemberUpdatedPermission(state),
-        'call.permissions_updated': watchCallPermissionsUpdated(state),
-        'call.reaction_new': watchNewReactions(state),
-        'call.recording_started': watchCallRecordingStarted(state),
-        'call.recording_stopped': watchCallRecordingStopped(state),
-        'call.session_started': watchCallSessionStarted(state),
-        'call.session_ended': watchCallSessionEnded(state),
-        'call.session_participant_joined': watchCallSessionParticipantJoined(state),
-        'call.session_participant_left': watchCallSessionParticipantLeft(state),
-        'call.unblocked_user': watchUnblockedUser(state),
-        'call.updated': watchCallUpdated(state),
-        'call.user_muted': () => console.log('call.user_muted received'),
-    };
     const eventHandlers = [
+        call.on('call.ended', watchCallEnded(call)),
         watchLiveEnded(dispatcher, call),
         watchSfuErrorReports(dispatcher),
         watchChangePublishQuality(dispatcher, call),
@@ -8988,10 +8899,6 @@ const registerEventHandlers = (call, state, dispatcher) => {
         call.on('callGrantsUpdated', watchCallGrantsUpdated(state)),
         call.on('pinsUpdated', watchPinsUpdated(state)),
     ];
-    Object.keys(coordinatorEvents).forEach((event) => {
-        const eventName = event;
-        eventHandlers.push(call.on(eventName, coordinatorEvents[eventName]));
-    });
     if (call.ringing) {
         // these events are only relevant when the call is ringing
         eventHandlers.push(registerRingingCallEventHandlers(call));
@@ -9621,7 +9528,7 @@ class Call {
      * Use the [`StreamVideoClient.call`](./StreamVideoClient.md/#call)
      * method to construct a `Call` instance.
      */
-    constructor({ type, id, streamClient, metadata, members, ownCapabilities, sortParticipantsBy, clientStore, ringing = false, watching = false, }) {
+    constructor({ type, id, streamClient, members, ownCapabilities, sortParticipantsBy, clientStore, ringing = false, watching = false, }) {
         /**
          * ViewportTracker instance
          */
@@ -9700,7 +9607,7 @@ class Call {
             if ((params === null || params === void 0 ? void 0 : params.ring) && !this.ringing) {
                 this.ringingSubject.next(true);
             }
-            this.state.setMetadata(response.call);
+            this.state.updateFromCallResponse(response.call);
             this.state.setMembers(response.members);
             this.state.setOwnCapabilities(response.own_capabilities);
             if (this.streamClient._hasConnectionID()) {
@@ -9719,7 +9626,7 @@ class Call {
             if ((data === null || data === void 0 ? void 0 : data.ring) && !this.ringing) {
                 this.ringingSubject.next(true);
             }
-            this.state.setMetadata(response.call);
+            this.state.updateFromCallResponse(response.call);
             this.state.setMembers(response.members);
             this.state.setOwnCapabilities(response.own_capabilities);
             if (this.streamClient._hasConnectionID()) {
@@ -9800,7 +9707,7 @@ class Call {
             let connectionConfig;
             try {
                 const call = yield join(this.streamClient, this.type, this.id, data);
-                this.state.setMetadata(call.metadata);
+                this.state.updateFromCallResponse(call.metadata);
                 this.state.setMembers(call.members);
                 this.state.setOwnCapabilities(call.ownCapabilities);
                 connectionConfig = call.connectionConfig;
@@ -9965,7 +9872,7 @@ class Call {
                     connectionConfig,
                 });
             }
-            const audioSettings = (_f = this.data) === null || _f === void 0 ? void 0 : _f.settings.audio;
+            const audioSettings = (_f = this.state.settings) === null || _f === void 0 ? void 0 : _f.audio;
             const isDtxEnabled = !!(audioSettings === null || audioSettings === void 0 ? void 0 : audioSettings.opus_dtx_enabled);
             const isRedEnabled = !!(audioSettings === null || audioSettings === void 0 ? void 0 : audioSettings.redundant_coding_enabled);
             if (!this.publisher) {
@@ -10479,9 +10386,12 @@ class Call {
         });
         /**
          * Starts the livestreaming of the call.
+         *
+         * @param data the request data.
+         * @param params the request params.
          */
-        this.goLive = (params) => __awaiter(this, void 0, void 0, function* () {
-            return this.streamClient.post(`${this.streamClientBasePath}/go_live`, {}, params);
+        this.goLive = (data = {}, params) => __awaiter(this, void 0, void 0, function* () {
+            return this.streamClient.post(`${this.streamClientBasePath}/go_live`, data, params);
         });
         /**
          * Stops the livestreaming of the call.
@@ -10509,7 +10419,7 @@ class Call {
         this.update = (updates) => __awaiter(this, void 0, void 0, function* () {
             const response = yield this.streamClient.patch(`${this.streamClientBasePath}`, updates);
             const { call, members, own_capabilities } = response;
-            this.state.setMetadata(call);
+            this.state.updateFromCallResponse(call);
             this.state.setMembers(members);
             this.state.setOwnCapabilities(own_capabilities);
             return response;
@@ -10582,19 +10492,20 @@ class Call {
         this.scheduleAutoDrop = () => {
             if (this.dropTimeout)
                 clearTimeout(this.dropTimeout);
-            const subscription = this.state.metadata$
-                .pipe(pairwise(), tap(([prevMeta, currentMeta]) => {
-                if (!(currentMeta && this.clientStore.connectedUser))
+            const subscription = this.state.settings$
+                .pipe(pairwise(), tap(([prevSettings, currentSettings]) => {
+                var _a;
+                if (!currentSettings || !this.clientStore.connectedUser)
                     return;
-                const isOutgoingCall = this.currentUserId === currentMeta.created_by.id;
+                const isOutgoingCall = this.currentUserId === ((_a = this.state.createdBy) === null || _a === void 0 ? void 0 : _a.id);
                 const [prevTimeoutMs, timeoutMs] = isOutgoingCall
                     ? [
-                        prevMeta === null || prevMeta === void 0 ? void 0 : prevMeta.settings.ring.auto_cancel_timeout_ms,
-                        currentMeta.settings.ring.auto_cancel_timeout_ms,
+                        prevSettings === null || prevSettings === void 0 ? void 0 : prevSettings.ring.auto_cancel_timeout_ms,
+                        currentSettings.ring.auto_cancel_timeout_ms,
                     ]
                     : [
-                        prevMeta === null || prevMeta === void 0 ? void 0 : prevMeta.settings.ring.incoming_call_timeout_ms,
-                        currentMeta.settings.ring.incoming_call_timeout_ms,
+                        prevSettings === null || prevSettings === void 0 ? void 0 : prevSettings.ring.incoming_call_timeout_ms,
+                        currentSettings.ring.incoming_call_timeout_ms,
                     ];
                 if (typeof timeoutMs === 'undefined' ||
                     timeoutMs === prevTimeoutMs ||
@@ -10611,7 +10522,6 @@ class Call {
         };
         /**
          * Retrieves the list of recordings for the current call or call session.
-         * Updates the call state with the returned array of CallRecording objects.
          *
          * If `callSessionId` is provided, it will return the recordings for that call session.
          * Otherwise, all recordings for the current call will be returned.
@@ -10623,9 +10533,7 @@ class Call {
             if (callSessionId) {
                 endpoint = `${endpoint}/${callSessionId}`;
             }
-            const response = yield this.streamClient.get(`${endpoint}/recordings`);
-            this.state.setCallRecordingsList(response.recordings);
-            return response;
+            return this.streamClient.get(`${endpoint}/recordings`);
         });
         /**
          * Sends a custom event to all call participants.
@@ -10649,21 +10557,24 @@ class Call {
         if (participantSorter) {
             this.state.setSortParticipantsBy(participantSorter);
         }
-        this.state.setMetadata(metadata);
         this.state.setMembers(members || []);
         this.state.setOwnCapabilities(ownCapabilities || []);
         this.state.setCallingState(ringing ? CallingState.RINGING : CallingState.IDLE);
+        this.on('all', (event) => {
+            // update state with the latest event data
+            this.state.updateFromEvent(event);
+        });
         this.leaveCallHooks.push(registerEventHandlers(this, this.state, this.dispatcher));
         this.registerEffects();
         this.leaveCallHooks.push(createSubscription(this.trackSubscriptionsSubject.pipe(debounce((v) => timer(v.type)), map$2((v) => v.data)), (subscriptions) => { var _a; return (_a = this.sfuClient) === null || _a === void 0 ? void 0 : _a.updateSubscriptions(subscriptions); }));
     }
     registerEffects() {
         this.leaveCallHooks.push(
-        // handles updating the permissions context when the metadata changes.
-        createSubscription(this.state.metadata$, (metadata) => {
-            if (!metadata)
+        // handles updating the permissions context when the settings change.
+        createSubscription(this.state.settings$, (settings) => {
+            if (!settings)
                 return;
-            this.permissionsContext.setCallSettings(metadata.settings);
+            this.permissionsContext.setCallSettings(settings);
         }), 
         // handle the case when the user permissions are modified.
         createSubscription(this.state.ownCapabilities$, (ownCapabilities) => {
@@ -10687,12 +10598,11 @@ class Call {
             }
         }), 
         // handles the case when the user is blocked by the call owner.
-        createSubscription(this.state.metadata$, (metadata) => __awaiter(this, void 0, void 0, function* () {
-            if (!metadata)
+        createSubscription(this.state.blockedUserIds$, (blockedUserIds) => __awaiter(this, void 0, void 0, function* () {
+            if (!blockedUserIds)
                 return;
             const currentUserId = this.currentUserId;
-            if (currentUserId &&
-                metadata.blocked_user_ids.includes(currentUserId)) {
+            if (currentUserId && blockedUserIds.includes(currentUserId)) {
                 this.logger('info', 'Leaving call because of being blocked');
                 yield this.leave();
             }
@@ -10744,12 +10654,6 @@ class Call {
             }
         }
     }
-    /**
-     * A getter for the call metadata.
-     */
-    get data() {
-        return this.state.metadata;
-    }
     /**
      * A flag indicating whether the call is "ringing" type of call.
      */
@@ -10768,7 +10672,7 @@ class Call {
      */
     get isCreatedByMe() {
         var _a;
-        return ((_a = this.state.metadata) === null || _a === void 0 ? void 0 : _a.created_by.id) === this.currentUserId;
+        return ((_a = this.state.createdBy) === null || _a === void 0 ? void 0 : _a.id) === this.currentUserId;
     }
 }
 
@@ -11881,7 +11785,7 @@ class WSConnectionFallback {
     }
 }
 
-const version = '0.2.2';
+const version = '0.3.0';
 
 const logger = getLogger(['location']);
 const HINT_URL = `https://hint.stream-io-video.com/`;
@@ -12575,12 +12479,12 @@ class StreamVideoClient {
                     streamClient: this.streamClient,
                     id: c.call.id,
                     type: c.call.type,
-                    metadata: c.call,
                     members: c.members,
                     ownCapabilities: c.own_capabilities,
                     watching: data.watch,
                     clientStore: this.writeableStateStore,
                 });
+                call.state.updateFromCallResponse(c.call);
                 if (data.watch) {
                     this.writeableStateStore.registerCall(call);
                 }
@@ -12588,9 +12492,9 @@ class StreamVideoClient {
             });
             return Object.assign(Object.assign({}, response), { calls: calls });
         });
-        this.queryUsers = () => __awaiter(this, void 0, void 0, function* () {
-            console.log('Querying users is not implemented yet.');
-        });
+        /**
+         * Returns a list of available data centers available for hosting calls.
+         */
         this.edges = () => __awaiter(this, void 0, void 0, function* () {
             return this.streamClient.get(`/edges`);
         });
@@ -12765,14 +12669,15 @@ class StreamVideoClient {
                     return;
                 }
                 this.logger('info', `New call created and registered: ${call.cid}`);
-                this.writeableStateStore.registerCall(new Call({
+                const newCall = new Call({
                     streamClient: this.streamClient,
                     type: call.type,
                     id: call.id,
-                    metadata: call,
                     members,
                     clientStore: this.writeableStateStore,
-                }));
+                });
+                newCall.state.updateFromCallResponse(call);
+                this.writeableStateStore.registerCall(newCall);
             }));
             this.eventHandlersToUnregister.push(this.on('call.ring', (event) => __awaiter(this, void 0, void 0, function* () {
                 if (event.type !== 'call.ring')
@@ -12786,7 +12691,6 @@ class StreamVideoClient {
                 // if `call.created` was received before `call.ring`.
                 // In that case, we cleanup the already tracked call.
                 const prevCall = this.writeableStateStore.findCall(call.type, call.id);
-                const prevMetadata = prevCall === null || prevCall === void 0 ? void 0 : prevCall.state.metadata;
                 yield (prevCall === null || prevCall === void 0 ? void 0 : prevCall.leave());
                 // we create a new call
                 const theCall = new Call({
@@ -12796,8 +12700,8 @@ class StreamVideoClient {
                     members,
                     clientStore: this.writeableStateStore,
                     ringing: true,
-                    metadata: prevMetadata,
                 });
+                theCall.state.updateFromCallResponse(call);
                 // we fetch the latest metadata for the call from the server
                 yield theCall.get();
                 this.writeableStateStore.registerCall(theCall);