@stream-io/video-client 1.5.0-0 → 1.5.0

package/src/store/__tests__/CallState.test.ts

@@ -1,9 +1,8 @@
-import '../../rtc/__tests__/mocks/webrtc.mocks';
 import { describe, expect, it, vi } from 'vitest';
 import { anyNumber } from 'vitest-mock-extended';
 import { StreamVideoParticipant, VisibilityState } from '../../types';
 import { CallingState, CallState } from '../CallState';
-import { TrackType } from '../../gen/video/sfu/models/models';
+import { ConnectionQuality } from '../../gen/video/sfu/models/models';
 import {
   combineComparators,
   conditional,
@@ -464,17 +463,40 @@ describe('CallState', () => {
     describe('Call Permission Events', () => {
       it('handles call.permissions_updated', () => {
         const state = new CallState();
-        // @ts-expect-error incomplete data
-        state.setParticipants([{ userId: 'test', isLocalParticipant: true }]);
+        state.setParticipants([
+          {
+            userId: 'test',
+            name: 'test',
+            sessionId: 'test',
+            isDominantSpeaker: false,
+            isSpeaking: false,
+            audioLevel: 0,
+            image: '',
+            publishedTracks: [],
+            connectionQuality: ConnectionQuality.EXCELLENT,
+            roles: [],
+            trackLookupPrefix: '',
+            isLocalParticipant: true,
+          },
+        ]);
 
         state.updateFromEvent({
           type: 'call.permissions_updated',
+          created_at: '',
+          call_cid: 'development:12345',
           own_capabilities: [
             OwnCapability.SEND_AUDIO,
             OwnCapability.SEND_VIDEO,
           ],
-          // @ts-expect-error incomplete data
-          user: { id: 'test' },
+          user: {
+            id: 'test',
+            created_at: '',
+            role: '',
+            updated_at: '',
+            custom: {},
+            teams: [],
+            language: 'en',
+          },
         });
 
         expect(state.ownCapabilities).toEqual([
@@ -487,8 +509,15 @@ describe('CallState', () => {
           created_at: '',
           call_cid: 'development:12345',
           own_capabilities: [OwnCapability.SEND_VIDEO],
-          // @ts-expect-error incomplete data
-          user: { id: 'test' },
+          user: {
+            id: 'test',
+            created_at: '',
+            role: '',
+            updated_at: '',
+            custom: {},
+            teams: [],
+            language: 'en',
+          },
         });
         expect(state.ownCapabilities).toEqual([OwnCapability.SEND_VIDEO]);
       });
@@ -852,44 +881,4 @@ describe('CallState', () => {
       });
     });
   });
-
-  describe('orphaned tracks', () => {
-    it('registers orphaned tracks', () => {
-      const state = new CallState();
-      state.registerOrphanedTrack({
-        id: '123:TRACK_TYPE_VIDEO',
-        track: new MediaStream(),
-        trackLookupPrefix: '123',
-        trackType: TrackType.AUDIO,
-      });
-      expect(state['orphanedTracks'].length).toBe(1);
-    });
-
-    it('removes orphaned tracks once assigned', () => {
-      const state = new CallState();
-      state.registerOrphanedTrack({
-        id: '123:TRACK_TYPE_VIDEO',
-        track: new MediaStream(),
-        trackLookupPrefix: '123',
-        trackType: TrackType.VIDEO,
-      });
-      const orphans = state.takeOrphanedTracks('123');
-      expect(orphans.length).toBe(1);
-      expect(state['orphanedTracks'].length).toBe(0);
-    });
-
-    it('removes orphaned tracks', () => {
-      const state = new CallState();
-      const id = '123:TRACK_TYPE_VIDEO';
-      state.registerOrphanedTrack({
-        id,
-        track: new MediaStream(),
-        trackLookupPrefix: '123',
-        trackType: TrackType.VIDEO,
-      });
-      expect(state['orphanedTracks'].length).toBe(1);
-      state.removeOrphanedTrack(id);
-      expect(state['orphanedTracks'].length).toBe(0);
-    });
-  });
 });

package/dist/src/helpers/ensureExhausted.d.ts

@@ -1 +0,0 @@
-export declare const ensureExhausted: (x: never, message: string) => void;

package/dist/src/helpers/withResolvers.d.ts

@@ -1,14 +0,0 @@
-export type PromiseWithResolvers<T> = {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason: any) => void;
-    isResolved: boolean;
-    isRejected: boolean;
-};
-/**
- * Creates a new promise with resolvers.
- *
- * Based on:
- * - https://github.com/tc39/proposal-promise-with-resolvers/blob/main/polyfills.js
- */
-export declare const promiseWithResolvers: <T = void>() => PromiseWithResolvers<T>;

package/dist/src/rpc/retryable.d.ts

@@ -1,23 +0,0 @@
-import { FinishedUnaryCall, UnaryCall } from '@protobuf-ts/runtime-rpc';
-import { Error as SfuError } from '../gen/video/sfu/models/models';
-/**
- * An internal interface which asserts that "retryable" SFU responses
- * contain a field called "error".
- * Ideally, this should be coming from the Protobuf definitions.
- */
-export interface SfuResponseWithError {
-    /**
-     * An optional error field which should be present in all SFU responses.
-     */
-    error?: SfuError;
-}
-/**
- * Creates a closure which wraps the given RPC call and retries invoking
- * the RPC until it succeeds or the maximum number of retries is reached.
- *
- * For each retry, there would be a delay to avoid request bursts toward the SFU.
- *
- * @param rpc the closure around the RPC call to execute.
- * @param signal the signal to abort the RPC call and retries loop.
- */
-export declare const retryable: <I extends object, O extends SfuResponseWithError>(rpc: () => UnaryCall<I, O>, signal?: AbortSignal) => Promise<FinishedUnaryCall<I, O>>;

package/dist/src/rtc/helpers/rtcConfiguration.d.ts

@@ -1,2 +0,0 @@
-import { ICEServer } from '../../gen/coordinator';
-export declare const toRtcConfiguration: (config: ICEServer[]) => RTCConfiguration;

package/src/helpers/ensureExhausted.ts

@@ -1,5 +0,0 @@
-import { getLogger } from '../logger';
-
-export const ensureExhausted = (x: never, message: string) => {
-  getLogger(['helpers'])('warn', message, x);
-};

package/src/helpers/withResolvers.ts

@@ -1,43 +0,0 @@
-export type PromiseWithResolvers<T> = {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason: any) => void;
-  isResolved: boolean;
-  isRejected: boolean;
-};
-
-/**
- * Creates a new promise with resolvers.
- *
- * Based on:
- * - https://github.com/tc39/proposal-promise-with-resolvers/blob/main/polyfills.js
- */
-export const promiseWithResolvers = <T = void>(): PromiseWithResolvers<T> => {
-  let resolve: (value: T | PromiseLike<T>) => void;
-  let reject: (reason: any) => void;
-  const promise = new Promise<T>((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-
-  let isResolved = false;
-  let isRejected = false;
-
-  const resolver = (value: T | PromiseLike<T>) => {
-    isResolved = true;
-    resolve(value);
-  };
-
-  const rejecter = (reason: any) => {
-    isRejected = true;
-    reject(reason);
-  };
-
-  return {
-    promise,
-    resolve: resolver,
-    reject: rejecter,
-    isResolved,
-    isRejected,
-  };
-};

package/src/rpc/__tests__/retryable.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { RpcError, UnaryCall } from '@protobuf-ts/runtime-rpc';
-import { TwirpErrorCode } from '@protobuf-ts/twirp-transport';
-import { retryable, SfuResponseWithError } from '../retryable';
-
-interface TestResponseWithError extends SfuResponseWithError {
-  value: number;
-}
-
-describe('retryable', () => {
-  it('retries the RPC when the SFU instructs to do so', async () => {
-    // @ts-expect-error incomplete unary call
-    const rpc = vi.fn<any[], UnaryCall<{}, TestResponseWithError>>(() => {
-      if (rpc.mock.calls.length <= 2) {
-        return { response: { error: { shouldRetry: true } } };
-      }
-      return { response: { value: 10 } };
-    });
-
-    const result = await retryable(rpc);
-    expect(result).toBeDefined();
-    expect(result.response.value).toBe(10);
-    expect(rpc).toHaveBeenCalledTimes(3);
-  });
-
-  it('retries when the RPC fails', async () => {
-    // @ts-expect-error incomplete unary call
-    const rpc = vi.fn<any[], UnaryCall<{}, TestResponseWithError>>(() => {
-      if (rpc.mock.calls.length === 1) throw new Error('failed');
-      return { response: { value: 10 } };
-    });
-
-    const result = await retryable(rpc);
-    expect(result).toBeDefined();
-    expect(result.response.value).toBe(10);
-    expect(rpc).toHaveBeenCalledTimes(2);
-  });
-
-  it('stops retrying when the RPC is rejected with cancellation error', async () => {
-    // @ts-expect-error incomplete unary call
-    const rpc = vi.fn<any[], UnaryCall<{}, TestResponseWithError>>(() => {
-      if (rpc.mock.calls.length <= 1) {
-        throw new Error('Generic error, should retry');
-      }
-      if (rpc.mock.calls.length === 2) {
-        throw new RpcError(
-          'Request aborted, should not retry',
-          TwirpErrorCode[TwirpErrorCode.cancelled],
-        );
-      }
-    });
-
-    const result = retryable(rpc);
-    await expect(result).rejects.toThrow('Request aborted, should not retry');
-    expect(rpc).toHaveBeenCalledTimes(2);
-  });
-
-  it('stops retrying when the aborted via signal', async () => {
-    const controller = new AbortController();
-    const rpc = vi.fn<any[], UnaryCall<{}, TestResponseWithError>>(() => {
-      if (rpc.mock.calls.length <= 1) {
-        throw new Error('Generic error, should retry');
-      }
-      controller.abort();
-      throw new Error('Request aborted, should not retry');
-    });
-
-    const result = retryable(rpc, controller.signal);
-    await expect(result).rejects.toThrow('Request aborted, should not retry');
-    expect(rpc).toHaveBeenCalledTimes(2);
-  });
-});

package/src/rpc/retryable.ts

@@ -1,57 +0,0 @@
-import {
-  FinishedUnaryCall,
-  RpcError,
-  UnaryCall,
-} from '@protobuf-ts/runtime-rpc';
-import { TwirpErrorCode } from '@protobuf-ts/twirp-transport';
-import { retryInterval, sleep } from '../coordinator/connection/utils';
-import { Error as SfuError } from '../gen/video/sfu/models/models';
-import { getLogger } from '../logger';
-
-/**
- * An internal interface which asserts that "retryable" SFU responses
- * contain a field called "error".
- * Ideally, this should be coming from the Protobuf definitions.
- */
-export interface SfuResponseWithError {
-  /**
-   * An optional error field which should be present in all SFU responses.
-   */
-  error?: SfuError;
-}
-
-/**
- * Creates a closure which wraps the given RPC call and retries invoking
- * the RPC until it succeeds or the maximum number of retries is reached.
- *
- * For each retry, there would be a delay to avoid request bursts toward the SFU.
- *
- * @param rpc the closure around the RPC call to execute.
- * @param signal the signal to abort the RPC call and retries loop.
- */
-export const retryable = async <
-  I extends object,
-  O extends SfuResponseWithError,
->(
-  rpc: () => UnaryCall<I, O>,
-  signal?: AbortSignal,
-): Promise<FinishedUnaryCall<I, O>> => {
-  let attempt = 0;
-  let result: FinishedUnaryCall<I, O> | undefined = undefined;
-  do {
-    if (attempt > 0) await sleep(retryInterval(attempt));
-    try {
-      result = await rpc();
-    } catch (err) {
-      const isRequestCancelled =
-        err instanceof RpcError &&
-        err.code === TwirpErrorCode[TwirpErrorCode.cancelled];
-      const isAborted = signal?.aborted ?? false;
-      if (isRequestCancelled || isAborted) throw err;
-      getLogger(['sfu-client', 'rpc'])('debug', `rpc failed (${attempt})`, err);
-      attempt++;
-    }
-  } while (!result || result.response.error?.shouldRetry);
-
-  return result;
-};

package/src/rtc/helpers/rtcConfiguration.ts

@@ -1,11 +0,0 @@
-import { ICEServer } from '../../gen/coordinator';
-
-export const toRtcConfiguration = (config: ICEServer[]): RTCConfiguration => {
-  return {
-    iceServers: config.map((ice) => ({
-      urls: ice.urls,
-      username: ice.username,
-      credential: ice.password,
-    })),
-  };
-};