@stream-io/video-client 1.0.0 → 1.0.1

package/dist/src/events/participant.d.ts

@@ -1,4 +1,4 @@
-import type { ParticipantJoined, ParticipantLeft, TrackPublished, TrackUnpublished } from '../gen/video/sfu/event/events';
+import type { ParticipantJoined, ParticipantLeft, ParticipantUpdated, TrackPublished, TrackUnpublished } from '../gen/video/sfu/event/events';
 import { CallState } from '../store';
 /**
  * An event responder which handles the `participantJoined` event.
@@ -8,6 +8,10 @@ export declare const watchParticipantJoined: (state: CallState) => (e: Participa
  * An event responder which handles the `participantLeft` event.
  */
 export declare const watchParticipantLeft: (state: CallState) => (e: ParticipantLeft) => void;
+/**
+ * An event responder which handles the `participantUpdated` event.
+ */
+export declare const watchParticipantUpdated: (state: CallState) => (e: ParticipantUpdated) => void;
 /**
  * An event responder which handles the `trackPublished` event.
  * The SFU will send this event when a participant publishes a track.

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -1,6 +1,6 @@
 import type { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, PartialMessage } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
-import { CallGrants, CallState, ClientDetails, Codec, ConnectionQuality, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, PeerType, Pin, TrackInfo, TrackType, TrackUnpublishReason } from '../models/models';
+import { CallEndedReason, CallGrants, CallState, ClientDetails, Codec, ConnectionQuality, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, PeerType, Pin, TrackInfo, TrackType, TrackUnpublishReason, WebsocketReconnectStrategy } from '../models/models';
 import { TrackSubscriptionDetails } from '../signal_rpc/signal';
 /**
  * SFUEvent is a message that is sent from the SFU to the client.
@@ -176,6 +176,23 @@ export interface SfuEvent {
          * @generated from protobuf field: stream.video.sfu.event.PinsChanged pins_updated = 22;
          */
         pinsUpdated: PinsChanged;
+    } | {
+        oneofKind: 'callEnded';
+        /**
+         * CallEnded is sent by the SFU to the client to signal that the call has ended.
+         * The reason may specify why the call has ended.
+         *
+         * @generated from protobuf field: stream.video.sfu.event.CallEnded call_ended = 23;
+         */
+        callEnded: CallEnded;
+    } | {
+        oneofKind: 'participantUpdated';
+        /**
+         * ParticipantUpdated is sent when user data is updated
+         *
+         * @generated from protobuf field: stream.video.sfu.event.ParticipantUpdated participant_updated = 24;
+         */
+        participantUpdated: ParticipantUpdated;
     } | {
         oneofKind: undefined;
     };
@@ -200,6 +217,12 @@ export interface Error {
      * @generated from protobuf field: stream.video.sfu.models.Error error = 4;
      */
     error?: Error$;
+    /**
+     * returns the reconnect strategy to be used by the client
+     *
+     * @generated from protobuf field: stream.video.sfu.models.WebsocketReconnectStrategy reconnect_strategy = 5;
+     */
+    reconnectStrategy: WebsocketReconnectStrategy;
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.ICETrickle
@@ -424,6 +447,21 @@ export interface ParticipantLeft {
      */
     participant?: Participant;
 }
+/**
+ * ParticipantUpdated is fired when user data is updated
+ *
+ * @generated from protobuf message stream.video.sfu.event.ParticipantUpdated
+ */
+export interface ParticipantUpdated {
+    /**
+     * @generated from protobuf field: string call_cid = 1;
+     */
+    callCid: string;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Participant participant = 2;
+     */
+    participant?: Participant;
+}
 /**
  * SubscriberOffer is sent when the SFU adds tracks to a subscription
  *
@@ -697,6 +735,18 @@ export interface GoAway {
      */
     reason: GoAwayReason;
 }
+/**
+ * CallEnded is sent by the SFU to the client to signal that the call has ended.
+ * The reason may specify why the call has ended.
+ *
+ * @generated from protobuf message stream.video.sfu.event.CallEnded
+ */
+export interface CallEnded {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.CallEndedReason reason = 1;
+     */
+    reason: CallEndedReason;
+}
 declare class SfuEvent$Type extends MessageType<SfuEvent> {
     constructor();
     create(value?: PartialMessage<SfuEvent>): SfuEvent;
@@ -847,6 +897,16 @@ declare class ParticipantLeft$Type extends MessageType<ParticipantLeft> {
  * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantLeft
  */
 export declare const ParticipantLeft: ParticipantLeft$Type;
+declare class ParticipantUpdated$Type extends MessageType<ParticipantUpdated> {
+    constructor();
+    create(value?: PartialMessage<ParticipantUpdated>): ParticipantUpdated;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParticipantUpdated): ParticipantUpdated;
+    internalBinaryWrite(message: ParticipantUpdated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantUpdated
+ */
+export declare const ParticipantUpdated: ParticipantUpdated$Type;
 declare class SubscriberOffer$Type extends MessageType<SubscriberOffer> {
     constructor();
     create(value?: PartialMessage<SubscriberOffer>): SubscriberOffer;
@@ -997,4 +1057,14 @@ declare class GoAway$Type extends MessageType<GoAway> {
  * @generated MessageType for protobuf message stream.video.sfu.event.GoAway
  */
 export declare const GoAway: GoAway$Type;
+declare class CallEnded$Type extends MessageType<CallEnded> {
+    constructor();
+    create(value?: PartialMessage<CallEnded>): CallEnded;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CallEnded): CallEnded;
+    internalBinaryWrite(message: CallEnded, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.CallEnded
+ */
+export declare const CallEnded: CallEnded$Type;
 export {};

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -676,6 +676,9 @@ export declare enum TrackUnpublishReason {
     MODERATION = 3
 }
 /**
+ * GoAwayReason represents the reason for the SFU to
+ * disconnect the client.
+ *
  * @generated from protobuf enum stream.video.sfu.models.GoAwayReason
  */
 export declare enum GoAwayReason {
@@ -692,6 +695,73 @@ export declare enum GoAwayReason {
      */
     REBALANCE = 2
 }
+/**
+ * CallEndedReason represents the reason for the call to end.
+ *
+ * @generated from protobuf enum stream.video.sfu.models.CallEndedReason
+ */
+export declare enum CallEndedReason {
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_ENDED = 1;
+     */
+    ENDED = 1,
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_LIVE_ENDED = 2;
+     */
+    LIVE_ENDED = 2,
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_KICKED = 3;
+     */
+    KICKED = 3
+}
+/**
+ * WebsocketReconnectStrategy defines the ws strategies available for handling reconnections.
+ *
+ * @generated from protobuf enum stream.video.sfu.models.WebsocketReconnectStrategy
+ */
+export declare enum WebsocketReconnectStrategy {
+    /**
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Sent after reaching the maximum reconnection attempts, leading to permanent disconnect.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_DISCONNECT = 1;
+     */
+    DISCONNECT = 1,
+    /**
+     * SDK should maintaining existing publisher/subscriber pc instances
+     * and establish a new WebSocket connection.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_FAST = 2;
+     */
+    FAST = 2,
+    /**
+     * SDK should drop existing pc instances and creates a fresh WebSocket connection,
+     * ensuring a clean state for the reconnection.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_CLEAN = 3;
+     */
+    CLEAN = 3,
+    /**
+     * SDK should obtain new credentials from the coordinator, drops existing pc instances, and initializes
+     * a completely new WebSocket connection, ensuring a comprehensive reset.
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_FULL = 4;
+     */
+    FULL = 4,
+    /**
+     * SDK should migrate to a new SFU instance
+     *
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_MIGRATE = 5;
+     */
+    MIGRATE = 5
+}
 declare class CallState$Type extends MessageType<CallState> {
     constructor();
     create(value?: PartialMessage<CallState>): CallState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/events/__tests__/participant.test.ts

@@ -2,26 +2,31 @@ import { describe, expect, it } from 'vitest';
 import { CallState } from '../../store';
 import { VisibilityState } from '../../types';
 import { TrackType } from '../../gen/video/sfu/models/models';
+import { noopComparator } from '../../sorting';
 import {
   watchParticipantJoined,
   watchParticipantLeft,
+  watchParticipantUpdated,
   watchTrackPublished,
   watchTrackUnpublished,
 } from '../participant';
 
 describe('Participant events', () => {
-  describe('participantJoined / participantLeft', () => {
+  describe('participantJoined / participantLeft / participantUpdated', () => {
     it('adds and removes the participant to the list of participants', () => {
       const state = new CallState();
+      state.setSortParticipantsBy(noopComparator());
 
       const onParticipantJoined = watchParticipantJoined(state);
       const onParticipantLeft = watchParticipantLeft(state);
+      const onParticipantUpdated = watchParticipantUpdated(state);
 
       onParticipantJoined({
         // @ts-ignore
         participant: {
           userId: 'user-id',
           sessionId: 'session-id',
+          roles: ['user'],
         },
       });
 
@@ -29,6 +34,28 @@ describe('Participant events', () => {
         {
           userId: 'user-id',
           sessionId: 'session-id',
+          roles: ['user'],
+          viewportVisibilityState: {
+            videoTrack: VisibilityState.UNKNOWN,
+            screenShareTrack: VisibilityState.UNKNOWN,
+          },
+        },
+      ]);
+
+      onParticipantUpdated({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          roles: ['host'],
+        },
+      });
+
+      expect(state.participants).toEqual([
+        {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          roles: ['host'],
           viewportVisibilityState: {
             videoTrack: VisibilityState.UNKNOWN,
             screenShareTrack: VisibilityState.UNKNOWN,

package/src/events/callEventHandlers.ts

@@ -15,6 +15,7 @@ import {
   watchParticipantCountChanged,
   watchParticipantJoined,
   watchParticipantLeft,
+  watchParticipantUpdated,
   watchPinsUpdated,
   watchSfuErrorReports,
   watchTrackPublished,
@@ -54,6 +55,7 @@ export const registerEventHandlers = (
 
     call.on('participantJoined', watchParticipantJoined(state)),
     call.on('participantLeft', watchParticipantLeft(state)),
+    call.on('participantUpdated', watchParticipantUpdated(state)),
 
     call.on('trackPublished', watchTrackPublished(state)),
     call.on('trackUnpublished', watchTrackUnpublished(state)),

package/src/events/participant.ts

@@ -1,6 +1,7 @@
 import type {
   ParticipantJoined,
   ParticipantLeft,
+  ParticipantUpdated,
   TrackPublished,
   TrackUnpublished,
 } from '../gen/video/sfu/event/events';
@@ -51,6 +52,17 @@ export const watchParticipantLeft = (state: CallState) => {
   };
 };
 
+/**
+ * An event responder which handles the `participantUpdated` event.
+ */
+export const watchParticipantUpdated = (state: CallState) => {
+  return function onParticipantUpdated(e: ParticipantUpdated) {
+    const { participant } = e;
+    if (!participant) return;
+    state.updateParticipant(participant.sessionId, participant);
+  };
+};
+
 /**
  * An event responder which handles the `trackPublished` event.
  * The SFU will send this event when a participant publishes a track.