@stream-io/video-client 0.0.1-alpha.7

package/dist/src/coordinator/connection/events.d.ts

@@ -0,0 +1,7 @@
+export declare const EVENT_MAP: {
+    'health.check': boolean;
+    'call.created': boolean;
+    'connection.changed': boolean;
+    'connection.recovered': boolean;
+    'transport.changed': boolean;
+};

package/dist/src/coordinator/connection/insights.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="ws" />
+import { StableWSConnection } from './connection';
+export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure' | 'http_hi_failed';
+export declare class InsightMetrics {
+    connectionStartTimestamp: number | null;
+    wsConsecutiveFailures: number;
+    wsTotalFailures: number;
+    instanceClientId: string;
+    constructor();
+}
+/**
+ * postInsights is not supposed to be used by end users directly within chat application, and thus is kept isolated
+ * from all the client/connection code/logic.
+ *
+ * @param insightType
+ * @param insights
+ */
+export declare const postInsights: (insightType: InsightTypes, insights: Record<string, unknown>) => Promise<void>;
+export declare function buildWsFatalInsight(connection: StableWSConnection, event: Record<string, unknown>): {
+    ready_state: 0 | 1 | 2 | 3 | undefined;
+    url: string;
+    api_key: string;
+    start_ts: number | null;
+    end_ts: number;
+    auth_type: string;
+    token: string | undefined;
+    user_id: string | undefined;
+    user_details: import("./types").UserResponse | import("./types").OwnUserResponse | undefined;
+    device: string;
+    client_id: string | undefined;
+    ws_details: import("ws") | undefined;
+    ws_consecutive_failures: number;
+    ws_total_failures: number;
+    request_id: string | undefined;
+    online: boolean | null;
+    user_agent: string | null;
+    instance_client_id: string;
+};
+export declare function buildWsSuccessAfterFailureInsight(connection: StableWSConnection): {
+    ready_state: 0 | 1 | 2 | 3 | undefined;
+    url: string;
+    api_key: string;
+    start_ts: number | null;
+    end_ts: number;
+    auth_type: string;
+    token: string | undefined;
+    user_id: string | undefined;
+    user_details: import("./types").UserResponse | import("./types").OwnUserResponse | undefined;
+    device: string;
+    client_id: string | undefined;
+    ws_details: import("ws") | undefined;
+    ws_consecutive_failures: number;
+    ws_total_failures: number;
+    request_id: string | undefined;
+    online: boolean | null;
+    user_agent: string | null;
+    instance_client_id: string;
+};

package/dist/src/coordinator/connection/signing.d.ts

@@ -0,0 +1,30 @@
+import { Secret, SignOptions } from 'jsonwebtoken';
+import { UR } from './types';
+/**
+ * Creates the JWT token that can be used for a UserSession
+ * @method JWTUserToken
+ * @memberof signing
+ * @private
+ * @param {Secret} apiSecret - API Secret key
+ * @param {string} userId - The user_id key in the JWT payload
+ * @param {UR} [extraData] - Extra that should be part of the JWT token
+ * @param {SignOptions} [jwtOptions] - Options that can be past to jwt.sign
+ * @return {string} JWT Token
+ */
+export declare function JWTUserToken(apiSecret: Secret, userId: string, extraData?: UR, jwtOptions?: SignOptions): string;
+export declare function JWTServerToken(apiSecret: Secret, jwtOptions?: SignOptions): string;
+export declare function UserFromToken(token: string): string;
+/**
+ *
+ * @param {string} userId the id of the user
+ * @return {string}
+ */
+export declare function DevToken(userId: string): string;
+/**
+ *
+ * @param {string} body the signed message
+ * @param {string} secret the shared secret used to generate the signature (Stream API secret)
+ * @param {string} signature the signature to validate
+ * @return {boolean}
+ */
+export declare function CheckSignature(body: string, secret: string, signature: string): boolean;

package/dist/src/coordinator/connection/token_manager.d.ts

@@ -0,0 +1,39 @@
+import { Secret } from 'jsonwebtoken';
+import { TokenOrProvider, UserResponse } from './types';
+/**
+ * TokenManager
+ *
+ * Handles all the operations around user token.
+ */
+export declare class TokenManager {
+    loadTokenPromise: Promise<string> | null;
+    type: 'static' | 'provider';
+    secret?: Secret;
+    token?: string;
+    tokenProvider?: TokenOrProvider;
+    user?: UserResponse;
+    /**
+     * Constructor
+     *
+     * @param {Secret} secret
+     */
+    constructor(secret?: Secret);
+    /**
+     * Set the static string token or token provider.
+     * Token provider should return a token string or a promise which resolves to string token.
+     *
+     * @param {TokenOrProvider} tokenOrProvider
+     * @param {UserResponse} user
+     */
+    setTokenOrProvider: (tokenOrProvider: TokenOrProvider, user: UserResponse) => Promise<void>;
+    /**
+     * Resets the token manager.
+     * Useful for client disconnection or switching user.
+     */
+    reset: () => void;
+    validateToken: (tokenOrProvider: TokenOrProvider, user: UserResponse) => void;
+    tokenReady: () => Promise<string> | null;
+    loadToken: () => Promise<string>;
+    getToken: () => string | undefined;
+    isStatic: () => boolean;
+}

package/dist/src/coordinator/connection/types.d.ts

@@ -0,0 +1,96 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { EVENT_MAP } from './events';
+import { StableWSConnection } from './connection';
+export type UR = Record<string, unknown>;
+export type User = {
+    id: string;
+    anon?: boolean;
+    name?: string;
+    role?: string;
+    teams?: string[];
+    username?: string;
+};
+export type UserResponse = User & {
+    banned?: boolean;
+    created_at?: string;
+    deactivated_at?: string;
+    deleted_at?: string;
+    last_active?: string;
+    online?: boolean;
+    revoke_tokens_issued_before?: string;
+    shadow_banned?: boolean;
+    updated_at?: string;
+};
+export type OwnUserBase = {
+    invisible?: boolean;
+    roles?: string[];
+};
+export type OwnUserResponse = UserResponse & OwnUserBase;
+export type ConnectionOpen = {
+    connection_id: string;
+    cid?: string;
+    created_at?: string;
+    me?: OwnUserResponse;
+    type?: string;
+};
+export type ConnectAPIResponse = Promise<void | ConnectionOpen>;
+export type LogLevel = 'info' | 'error' | 'warn';
+type ErrorResponseDetails = {
+    code: number;
+    messages: string[];
+};
+export type APIErrorResponse = {
+    code: number;
+    duration: string;
+    message: string;
+    more_info: string;
+    StatusCode: number;
+    details?: ErrorResponseDetails;
+};
+export declare class ErrorFromResponse<T> extends Error {
+    code?: number;
+    response?: AxiosResponse<T>;
+    status?: number;
+}
+export type EventTypes = 'all' | keyof typeof EVENT_MAP;
+export type Event = {
+    type: EventTypes;
+    received_at?: string | Date;
+    online?: boolean;
+    mode?: string;
+};
+export type EventHandler = (event: Event) => void;
+export type Logger = (logLevel: LogLevel, message: string, extraData?: Record<string, unknown>) => void;
+export type StreamClientOptions = Partial<AxiosRequestConfig> & {
+    /**
+     * Used to disable warnings that are triggered by using connectUser or connectAnonymousUser server-side.
+     */
+    allowServerSideConnect?: boolean;
+    axiosRequestConfig?: AxiosRequestConfig;
+    /**
+     * Base url to use for API
+     * such as https://chat-proxy-dublin.stream-io-api.com
+     */
+    baseURL?: string;
+    browser?: boolean;
+    enableInsights?: boolean;
+    /** experimental feature, please contact support if you want this feature enabled for you */
+    enableWSFallback?: boolean;
+    logger?: Logger;
+    /**
+     * When true, user will be persisted on client. Otherwise if `connectUser` call fails, then you need to
+     * call `connectUser` again to retry.
+     * This is mainly useful for chat application working in offline mode, where you will need client.user to
+     * persist even if connectUser call fails.
+     */
+    persistUserOnConnectionFailure?: boolean;
+    /**
+     * The secret key for the API key. This is only needed for server side authentication.
+     */
+    secret?: string;
+    warmUp?: boolean;
+    wsConnection?: StableWSConnection;
+};
+export type TokenProvider = () => Promise<string>;
+export type TokenOrProvider = null | string | TokenProvider | undefined;
+export {};

package/dist/src/coordinator/connection/utils.d.ts

@@ -0,0 +1,25 @@
+export declare const sleep: (m: number) => Promise<void>;
+export declare function isFunction<T>(value: Function | T): value is Function;
+export declare const chatCodes: {
+    TOKEN_EXPIRED: number;
+    WS_CLOSED_SUCCESS: number;
+};
+/**
+ * retryInterval - A retry interval which increases acc to number of failures
+ *
+ * @return {number} Duration to wait in milliseconds
+ */
+export declare function retryInterval(numberOfFailures: number): number;
+export declare function randomId(): string;
+export declare function generateUUIDv4(): string;
+export declare function convertErrorToJson(err: Error): Record<string, unknown>;
+/**
+ * isOnline safely return the navigator.online value for browser env
+ * if navigator is not in global object, it always return true
+ */
+export declare function isOnline(): boolean;
+/**
+ * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
+ */
+export declare function addConnectionEventListeners(cb: (e: Event) => void): void;
+export declare function removeConnectionEventListeners(cb: (e: Event) => void): void;

package/dist/src/devices.d.ts

@@ -0,0 +1,79 @@
+import { Observable } from 'rxjs';
+/**
+ * [Tells if the browser supports audio output change on 'audio' elements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId).
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ */
+export declare const checkIfAudioOutputChangeSupported: () => boolean;
+/**
+ * Prompts the user for a permission to use audio devices (if not already granted) and lists the available 'audioinput' devices, if devices are added/removed the list is updated.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @returns
+ */
+export declare const getAudioDevices: () => Observable<MediaDeviceInfo[]>;
+/**
+ * Prompts the user for a permission to use video devices (if not already granted) and lists the available 'videoinput' devices, if devices are added/removed the list is updated.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @returns
+ */
+export declare const getVideoDevices: () => Observable<MediaDeviceInfo[]>;
+/**
+ * Prompts the user for a permission to use audio devices (if not already granted) and lists the available 'audiooutput' devices, if devices are added/removed the list is updated. Selecting 'audiooutput' device only makes sense if [the browser has support for changing audio output on 'audio' elements](#checkifaudiooutputchangesupported)
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @returns
+ */
+export declare const getAudioOutputDevices: () => Observable<MediaDeviceInfo[]>;
+/**
+ * Returns an 'audioinput' media stream with the given `deviceId`, if no `deviceId` is provided, it uses the first available device.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId
+ * @returns
+ */
+export declare const getAudioStream: (deviceId?: string) => Promise<MediaStream>;
+/**
+ * Returns a 'videoinput' media stream with the given `deviceId`, if no `deviceId` is provided, it uses the first available device.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId
+ * @returns
+ */
+export declare const getVideoStream: (deviceId?: string) => Promise<MediaStream>;
+/**
+ * Prompts the user for a permission to share a screen.
+ * If the user grants the permission, a screen sharing stream is returned. Throws otherwise.
+ *
+ * The callers of this API are responsible to handle the possible errors.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ *
+ * @param options any additional options to pass to the [`getDisplayMedia`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia) API.
+ */
+export declare const getScreenShareStream: (options?: Record<string, any>) => Promise<MediaStream>;
+/**
+ * Notifies the subscriber if a given 'audioinput' device is disconnected
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId$ an Observable that specifies which device to watch for
+ * @returns
+ */
+export declare const watchForDisconnectedAudioDevice: (deviceId$: Observable<string | undefined>) => Observable<boolean>;
+/**
+ * Notifies the subscriber if a given 'videoinput' device is disconnected
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId$ an Observable that specifies which device to watch for
+ * @returns
+ */
+export declare const watchForDisconnectedVideoDevice: (deviceId$: Observable<string | undefined>) => Observable<boolean>;
+/**
+ * Notifies the subscriber if a given 'audiooutput' device is disconnected
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId$ an Observable that specifies which device to watch for
+ * @returns
+ */
+export declare const watchForDisconnectedAudioOutputDevice: (deviceId$: Observable<string | undefined>) => Observable<boolean>;

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

@@ -0,0 +1,26 @@
+import { StreamVideoWriteableStateStore } from '../store';
+import { CallAccepted, CallCancelled, CallCreated, CallRejected } from '../gen/coordinator';
+/**
+ * Event handler that watches the delivery of CallCreated Websocket event
+ * Updates the state store and notifies its subscribers that
+ * a new pending call has been initiated.
+ */
+export declare const watchCallCreated: (store: StreamVideoWriteableStateStore) => (event: CallCreated) => void;
+/**
+ * Event handler that watched the delivery of CallAccepted Websocket event
+ * Updates the state store and notifies its subscribers that
+ * the given user will be joining the call.
+ */
+export declare const watchCallAccepted: (store: StreamVideoWriteableStateStore) => (event: CallAccepted) => void;
+/**
+ * Event handler that watches delivery of CallRejected Websocket event.
+ * Updates the state store and notifies its subscribers that
+ * the given user will not be joining the call.
+ */
+export declare const watchCallRejected: (store: StreamVideoWriteableStateStore) => (event: CallRejected) => void;
+/**
+ * Event handler that watches the delivery of CallCancelled Websocket event
+ * Updates the state store and notifies its subscribers that
+ * the call is now considered terminated.
+ */
+export declare const watchCallCancelled: (store: StreamVideoWriteableStateStore) => (event: CallCancelled) => void;

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

@@ -0,0 +1,8 @@
+import { Dispatcher } from '../rtc/Dispatcher';
+import { Call } from '../rtc/Call';
+import { StreamVideoWriteableStateStore } from '../store';
+/**
+ * An event responder which handles the `changePublishQuality` event.
+ */
+export declare const watchChangePublishQuality: (dispatcher: Dispatcher, call: Call) => () => void;
+export declare const watchConnectionQualityChanged: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore) => () => void;

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

@@ -0,0 +1,21 @@
+import { Batcher } from '../Batcher';
+import { Dispatcher } from '../rtc/Dispatcher';
+import { StreamVideoWriteableStateStore } from '../store';
+/**
+ * An event responder which handles the `participantJoined` event.
+ */
+export declare const watchParticipantJoined: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore, userBatcher: Batcher<string>) => () => void;
+/**
+ * An event responder which handles the `participantLeft` event.
+ */
+export declare const watchParticipantLeft: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore) => () => void;
+/**
+ * An event responder which handles the `trackPublished` event.
+ * The SFU will send this event when a participant publishes a track.
+ */
+export declare const watchTrackPublished: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore) => () => void;
+/**
+ * An event responder which handles the `trackUnpublished` event.
+ * The SFU will send this event when a participant unpublishes a track.
+ */
+export declare const watchTrackUnpublished: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore) => () => void;

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

@@ -0,0 +1,10 @@
+import { Dispatcher } from '../rtc/Dispatcher';
+import { StreamVideoWriteableStateStore } from '../store';
+/**
+ * Watches for `dominantSpeakerChanged` events.
+ */
+export declare const watchDominantSpeakerChanged: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore) => () => void;
+/**
+ * Watches for `audioLevelChanged` events.
+ */
+export declare const watchAudioLevelChanged: (dispatcher: Dispatcher, store: StreamVideoWriteableStateStore) => () => void;