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

package/dist/src/rtc/publisher.d.ts

@@ -0,0 +1,53 @@
+import { StreamSfuClient } from '../StreamSfuClient';
+import { TrackType } from '../gen/video/sfu/models/models';
+import { PublishOptions } from './types';
+export type PublisherOpts = {
+    rpcClient: StreamSfuClient;
+    connectionConfig?: RTCConfiguration;
+};
+/**
+ * @internal
+ * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
+ */
+export declare class Publisher {
+    private readonly publisher;
+    private readonly rpcClient;
+    private readonly transceiverRegistry;
+    private readonly trackKindRegistry;
+    constructor({ connectionConfig, rpcClient }: PublisherOpts);
+    /**
+     * Starts publishing the given track of the given media stream.
+     *
+     * Consecutive calls to this method will replace the stream.
+     * The previous stream will be stopped.
+     * @param mediaStream
+     * @param track
+     * @param trackType
+     * @param opts
+     */
+    publishStream: (mediaStream: MediaStream, track: MediaStreamTrack, trackType: TrackType, opts?: PublishOptions) => Promise<void>;
+    /**
+     * Stops publishing the given track type to the SFU, if it is currently being published.
+     * Underlying track will be stopped and removed from the publisher.
+     * @param trackType
+     * @returns `true` if track with the given track type was found, otherwise `false`
+     */
+    unpublishStream: (trackType: TrackType) => boolean;
+    /**
+     * Stops publishing all tracks and stop all tracks.
+     */
+    stopPublishing: () => void;
+    updateVideoPublishQuality: (enabledRids: string[]) => Promise<void>;
+    /**
+     * Returns the result of the `RTCPeerConnection.getStats()` method
+     * @param selector
+     * @returns
+     */
+    getStats(selector?: MediaStreamTrack | null | undefined): Promise<RTCStatsReport>;
+    private onIceCandidate;
+    private onNegotiationNeeded;
+    private onIceCandidateError;
+    private onIceConnectionStateChange;
+    private onIceGatheringStateChange;
+    private ridToVideoQuality;
+}

package/dist/src/rtc/signal.d.ts

@@ -0,0 +1,5 @@
+import { SfuEvent } from '../gen/video/sfu/event/events';
+export declare const createWebSocketSignalChannel: (opts: {
+    endpoint: string;
+    onMessage?: ((message: SfuEvent) => void) | undefined;
+}) => Promise<WebSocket>;

package/dist/src/rtc/subscriber.d.ts

@@ -0,0 +1,7 @@
+import { StreamSfuClient } from '../StreamSfuClient';
+export type SubscriberOpts = {
+    rpcClient: StreamSfuClient;
+    connectionConfig?: RTCConfiguration;
+    onTrack?: (e: RTCTrackEvent) => void;
+};
+export declare const createSubscriber: ({ rpcClient, connectionConfig, onTrack, }: SubscriberOpts) => RTCPeerConnection;

package/dist/src/rtc/types.d.ts

@@ -0,0 +1,84 @@
+import type { UserResponse } from '../gen/coordinator';
+import type { Participant, VideoDimension } from '../gen/video/sfu/models/models';
+export interface StreamVideoParticipant extends Participant {
+    /**
+     * The participant's audio stream, if they are publishing audio and
+     * we have subscribed to it.
+     */
+    audioStream?: MediaStream;
+    /**
+     * The participant's video stream, if they are sharing their video,
+     * and we are subscribed to it.
+     */
+    videoStream?: MediaStream;
+    /**
+     * The participant's screen share stream, if they are sharing their screen,
+     * and we are subscribed to it.
+     */
+    screenShareStream?: MediaStream;
+    /**
+     * The preferred video dimensions for this participant.
+     * Set it to `undefined` to unsubscribe from this participant's video.
+     */
+    videoDimension?: VideoDimension;
+    /**
+     * The preferred screen share dimensions for this participant.
+     * Set it to `undefined` to unsubscribe from this participant's screen share.
+     */
+    screenShareDimension?: VideoDimension;
+    /**
+     * True if the participant is the local participant.
+     */
+    isLoggedInUser?: boolean;
+    /**
+     * True when the participant is pinned
+     */
+    isPinned?: boolean;
+    /**
+     * User metadata (profile picture, name...)
+     */
+    user?: UserResponse;
+}
+export interface StreamVideoLocalParticipant extends StreamVideoParticipant {
+    /**
+     * The device ID of the currently selected audio input device of the local participant (returned by the [MediaDevices API](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia))
+     */
+    audioDeviceId?: string;
+    /**
+     * The device ID of the currently selected video input device of the local participant (returned by the [MediaDevices API](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia))
+     */
+    videoDeviceId?: string;
+    /**
+     * The device ID of the currently selected audio output device of the local participant (returned by the [MediaDevices API](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia))
+     *
+     * If the value is not defined, the user hasn't selected any device (in these cases the default system audio output could be used)
+     */
+    audioOutputDeviceId?: string;
+}
+/**
+ * A partial representation of the StreamVideoParticipant.
+ */
+export type StreamVideoParticipantPatch = Partial<StreamVideoParticipant | StreamVideoLocalParticipant>;
+/**
+ * A collection of {@link StreamVideoParticipantPatch} organized by sessionId.
+ */
+export type StreamVideoParticipantPatches = {
+    [sessionId: string]: StreamVideoParticipantPatch;
+};
+export type SubscriptionChange = {
+    /**
+     * The video dimension to request.
+     * Set it to `undefined` in case you want to unsubscribe.
+     */
+    dimension: VideoDimension | undefined;
+};
+export type SubscriptionChanges = {
+    [sessionId: string]: SubscriptionChange;
+};
+export type CallOptions = {
+    connectionConfig?: RTCConfiguration;
+    edgeName?: string;
+};
+export type PublishOptions = {
+    preferredCodec?: string | null;
+};

package/dist/src/rtc/videoLayers.d.ts

@@ -0,0 +1,17 @@
+export type OptimalVideoLayer = RTCRtpEncodingParameters & {
+    width: number;
+    height: number;
+    maxFramerate?: number;
+};
+export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack) => {
+    rid: string;
+    active?: boolean | undefined;
+    maxBitrate?: number | undefined;
+    maxFramerate?: number | undefined;
+    networkPriority?: RTCPriorityType | undefined;
+    priority?: RTCPriorityType | undefined;
+    scaleResolutionDownBy?: number | undefined;
+    width: number;
+    height: number;
+}[];
+export declare const findOptimalScreenSharingLayers: (videoTrack: MediaStreamTrack) => OptimalVideoLayer[];

package/dist/src/stats/coordinator-stats-reporter.d.ts

@@ -0,0 +1,10 @@
+import { StreamVideoReadOnlyStateStore } from '../store';
+import { ReportCallStatEventRequest, ReportCallStatEventResponse, ReportCallStatsResponse } from '../gen/video/coordinator/client_v1_rpc/client_rpc';
+/**
+ * Collects stat metrics and events from the state store and sends them to the Coordinator API
+ * @param readOnlyStateStore
+ * @param sendStatMetrics
+ * @param sendStatEvent
+ */
+export declare const reportStats: (readOnlyStateStore: StreamVideoReadOnlyStateStore, sendStatMetrics: (stats: Object) => Promise<ReportCallStatsResponse | void>, sendStatEvent: (statEvent: ReportCallStatEventRequest['event']) => Promise<ReportCallStatEventResponse | void>) => void;
+export declare const reportStatEvents: (store: StreamVideoReadOnlyStateStore, sendStatEvent: (statEvent: ReportCallStatEventRequest['event']) => Promise<ReportCallStatEventResponse | void>) => void;

package/dist/src/stats/state-store-stats-reporter.d.ts

@@ -0,0 +1,57 @@
+import type { StatsReport } from './types';
+import { StreamVideoWriteableStateStore } from '../store';
+import { Publisher } from '../rtc/publisher';
+export type StatsReporterOpts = {
+    subscriber: RTCPeerConnection;
+    publisher: Publisher;
+    store: StreamVideoWriteableStateStore;
+    pollingIntervalInMs?: number;
+    edgeName?: string;
+};
+export type StatsReporter = {
+    /**
+     * Will turn on stats reporting for a given sessionId.
+     *
+     * @param sessionId the session id.
+     */
+    startReportingStatsFor: (sessionId: string) => void;
+    /**
+     * Will turn off stats reporting for a given sessionId.
+     *
+     * @param sessionId the session id.
+     */
+    stopReportingStatsFor: (sessionId: string) => void;
+    /**
+     * Helper method for retrieving stats for a given peer connection kind
+     * and media stream flowing through it.
+     *
+     * @param kind the peer connection kind (subscriber or publisher).
+     * @param mediaStream the media stream.
+     */
+    getStatsForStream: (kind: 'subscriber' | 'publisher', mediaStream: MediaStream) => Promise<StatsReport[]>;
+    /**
+     * Helper method for retrieving raw stats for a given peer connection kind.
+     *
+     * @param kind the peer connection kind (subscriber or publisher).
+     * @param selector the track selector. If not provided, stats for all tracks will be returned.
+     */
+    getRawStatsForTrack: (kind: 'subscriber' | 'publisher', selector?: MediaStreamTrack) => Promise<RTCStatsReport | undefined>;
+    /**
+     * Stops the stats reporter and releases all resources.
+     */
+    stop: () => void;
+};
+/**
+ * Creates a new StatsReporter instance that collects metrics about the ongoing call and reports them to the state store
+ */
+export declare const createStatsReporter: ({ subscriber, publisher, store, edgeName, pollingIntervalInMs, }: StatsReporterOpts) => StatsReporter;
+export type StatsTransformOpts = {
+    /**
+     * The kind of track we are transforming stats for.
+     */
+    trackKind: 'audio' | 'video';
+    /**
+     * The kind of peer connection we are transforming stats for.
+     */
+    kind: 'subscriber' | 'publisher';
+};

package/dist/src/stats/types.d.ts

@@ -0,0 +1,42 @@
+export type BaseStats = {
+    bytesSent?: number;
+    bytesReceived?: number;
+    codec?: string;
+    currentRoundTripTime?: number;
+    frameWidth?: number;
+    frameHeight?: number;
+    framesPerSecond?: number;
+    jitter?: number;
+    kind?: string;
+    qualityLimitationReason?: string;
+    rid?: string;
+    ssrc?: number;
+};
+export type StatsReport = {
+    rawStats?: RTCStatsReport;
+    streams: BaseStats[];
+    timestamp: number;
+};
+export type AggregatedStatsReport = {
+    totalBytesSent: number;
+    totalBytesReceived: number;
+    averageJitterInMs: number;
+    averageRoundTripTimeInMs: number;
+    qualityLimitationReasons: string;
+    highestFrameWidth: number;
+    highestFrameHeight: number;
+    highestFramesPerSecond: number;
+    timestamp: number;
+};
+export type ParticipantsStatsReport = {
+    [sessionId: string]: StatsReport[] | undefined;
+};
+export type CallStatsReport = {
+    datacenter: string;
+    publisherStats: AggregatedStatsReport;
+    publisherRawStats?: RTCStatsReport;
+    subscriberStats: AggregatedStatsReport;
+    subscriberRawStats?: RTCStatsReport;
+    participants: ParticipantsStatsReport;
+    timestamp: number;
+};

package/dist/src/store/index.d.ts

@@ -0,0 +1,2 @@
+export * as RxUtils from './rxUtils';
+export * from './stateStore';

package/dist/src/store/rxUtils.d.ts

@@ -0,0 +1,18 @@
+import { Observable, Subject } from 'rxjs';
+/**
+ * Gets the current value of an observable, or undefined if the observable has
+ * not emitted a value yet.
+ *
+ * @param observable$ the observable to get the value from.
+ */
+export declare const getCurrentValue: <T>(observable$: Observable<T>) => T;
+/**
+ * Updates the value of the provided Subject.
+ * An `update` can either be a new value or a function which takes
+ * the current value and returns a new value.
+ *
+ * @param subject the subject to update.
+ * @param update the update to apply to the subject.
+ * @return the updated value.
+ */
+export declare const setCurrentValue: <T>(subject: Subject<T>, update: T | ((currentValue: T) => T)) => T;

package/dist/src/store/stateStore.d.ts

@@ -0,0 +1,182 @@
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { Call as CallController } from '../rtc/Call';
+import { CallMetadata } from '../rtc/CallMetadata';
+import type { StreamVideoLocalParticipant, StreamVideoParticipant, StreamVideoParticipantPatch, StreamVideoParticipantPatches } from '../rtc/types';
+import type { CallStatsReport } from '../stats/types';
+import type { User } from '../coordinator/connection/types';
+import type { CallAccepted } from '../gen/coordinator';
+export declare class StreamVideoWriteableStateStore {
+    /**
+     * A store keeping data of a successfully connected user over WS to the coordinator server.
+     */
+    connectedUserSubject: BehaviorSubject<User | undefined>;
+    /**
+     * A store that keeps track of all created calls that have not been yet accepted, rejected nor cancelled.
+     */
+    pendingCallsSubject: BehaviorSubject<CallMetadata[]>;
+    /**
+     * A list of objects describing incoming calls.
+     */
+    incomingCalls$: Observable<CallMetadata[]>;
+    /**
+     * A list of objects describing calls initiated by the current user (connectedUser).
+     */
+    outgoingCalls$: Observable<CallMetadata[]>;
+    /**
+     * A store that keeps track of all the notifications describing accepted call.
+     */
+    acceptedCallSubject: BehaviorSubject<CallAccepted | undefined>;
+    /**
+     * A store that keeps reference to a call controller instance.
+     */
+    activeCallSubject: BehaviorSubject<CallController | undefined>;
+    /**
+     * All participants of the current call (including the logged-in user).
+     */
+    participantsSubject: ReplaySubject<(StreamVideoParticipant | StreamVideoLocalParticipant)[]>;
+    /**
+     * Remote participants of the current call (this includes every participant except the logged-in user).
+     */
+    remoteParticipants$: Observable<StreamVideoParticipant[]>;
+    /**
+     * The local participant of the current call (the logged-in user).
+     */
+    localParticipant$: Observable<StreamVideoLocalParticipant | undefined>;
+    /**
+     * Pinned participants of the current call.
+     */
+    pinnedParticipants$: Observable<StreamVideoParticipant[]>;
+    /**
+     * The currently elected dominant speaker in the active call.
+     */
+    dominantSpeaker$: Observable<StreamVideoParticipant | undefined>;
+    callStatsReportSubject: BehaviorSubject<CallStatsReport | undefined>;
+    callRecordingInProgressSubject: ReplaySubject<boolean>;
+    hasOngoingScreenShare$: Observable<boolean>;
+    constructor();
+    /**
+     * Gets the current value of an observable, or undefined if the observable has
+     * not emitted a value yet.
+     *
+     * @param observable$ the observable to get the value from.
+     */
+    getCurrentValue: <T>(observable$: Observable<T>) => T;
+    /**
+     * Updates the value of the provided Subject.
+     * An `update` can either be a new value or a function which takes
+     * the current value and returns a new value.
+     *
+     * @param subject the subject to update.
+     * @param update the update to apply to the subject.
+     * @return the updated value.
+     */
+    setCurrentValue: <T>(subject: import("rxjs").Subject<T>, update: T | ((currentValue: T) => T)) => T;
+    /**
+     * Will try to find the participant with the given sessionId in the active call.
+     *
+     * @param sessionId the sessionId of the participant to find.
+     * @returns the participant with the given sessionId or undefined if not found.
+     */
+    findParticipantBySessionId: (sessionId: string) => StreamVideoParticipant | undefined;
+    /**
+     * Updates a participant in the active call identified by the given `sessionId`.
+     * If the participant can't be found, this operation is no-op.
+     *
+     * @param sessionId the session ID of the participant to update.
+     * @param patch the patch to apply to the participant.
+     * @returns the updated participant or `undefined` if the participant couldn't be found.
+     */
+    updateParticipant: (sessionId: string, patch: StreamVideoParticipantPatch | ((p: StreamVideoParticipant) => StreamVideoParticipantPatch)) => (StreamVideoParticipant | StreamVideoLocalParticipant)[] | undefined;
+    /**
+     * Updates all participants in the active call whose session ID is in the given `sessionIds`.
+     * If no patch are provided, this operation is no-op.
+     *
+     * @param patch the patch to apply to the participants.
+     * @returns all participants, with all patch applied.
+     */
+    updateParticipants: (patch: StreamVideoParticipantPatches) => (StreamVideoParticipant | StreamVideoLocalParticipant)[] | undefined;
+}
+/**
+ * A reactive store that exposes state variables in a reactive manner - you can subscribe to changes of the different state variables. This central store contains all the state variables related to [`StreamVideoClient`](./StreamVideClient.md) and [`Call`](./Call.md).
+ *
+ */
+export declare class StreamVideoReadOnlyStateStore {
+    /**
+     * Data describing a user successfully connected over WS to coordinator server.
+     */
+    connectedUser$: Observable<User | undefined>;
+    /**
+     * A list of objects describing all created calls that have not been yet accepted, rejected nor cancelled.
+     */
+    pendingCalls$: Observable<CallMetadata[]>;
+    /**
+     * A list of objects describing calls initiated by the current user (connectedUser).
+     */
+    outgoingCalls$: Observable<CallMetadata[]>;
+    /**
+     * A list of objects describing incoming calls.
+     */
+    incomingCalls$: Observable<CallMetadata[]>;
+    /**
+     * The call data describing an incoming call accepted by a participant.
+     * Serves as a flag decide, whether an incoming call should be joined.
+     */
+    acceptedCall$: Observable<CallAccepted | undefined>;
+    /**
+     * The call controller instance representing the call the user attends.
+     * The controller instance exposes call metadata as well.
+     * `activeCall$` will be set after calling [`join` on a `Call` instance](./Call.md/#join) and cleared after calling [`leave`](./Call.md/#leave).
+     */
+    activeCall$: Observable<CallController | undefined>;
+    /**
+     * The currently elected dominant speaker in the active call.
+     */
+    dominantSpeaker$: Observable<StreamVideoParticipant | undefined>;
+    /**
+     * All participants of the current call (this includes the current user and other participants as well).
+     */
+    participants$: Observable<(StreamVideoParticipant | StreamVideoLocalParticipant)[]>;
+    /**
+     * The local participant of the current call (the logged-in user).
+     */
+    localParticipant$: Observable<StreamVideoLocalParticipant | undefined>;
+    /**
+     * Remote participants of the current call (this includes every participant except the logged-in user).
+     */
+    remoteParticipants$: Observable<StreamVideoParticipant[]>;
+    /**
+     * Pinned participants of the current call.
+     */
+    pinnedParticipants$: Observable<StreamVideoParticipant[]>;
+    /**
+     * Emits true whenever there is an active screen sharing session within
+     * the current call. Useful for displaying a "screen sharing" indicator and
+     * switching the layout to a screen sharing layout.
+     *
+     * The actual screen sharing track isn't exposed here, but can be retrieved
+     * from the list of call participants. We also don't want to be limiting
+     * to the number of share screen tracks are displayed in a call.
+     */
+    hasOngoingScreenShare$: Observable<boolean>;
+    /**
+     * 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 stats data.
+     */
+    callStatsReport$: Observable<CallStatsReport | undefined>;
+    /**
+     * Emits a boolean indicating whether a call recording is currently in progress.
+     */
+    callRecordingInProgress$: Observable<boolean>;
+    /**
+     * This method allows you the get the current value of a state variable.
+     *
+     * @param observable the observable to get the current value of.
+     * @returns the current value of the observable.
+     */
+    getCurrentValue: <T>(observable: Observable<T>) => T;
+    constructor(store: StreamVideoWriteableStateStore);
+}

package/generate-openapi.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -euo pipefail
+
+CHAT_REPO_ROOT_DIR="../../../chat"
+SCHEMA_FILE="$CHAT_REPO_ROOT_DIR/releases/video-openapi.yaml"
+OUTPUT_DIR="./src/gen/coordinator"
+TEMP_OUTPUT_DIR="./src/gen/openapi-temp"
+
+# Generate the Coordinator OpenAPI schema
+make -C $CHAT_REPO_ROOT_DIR video-openapi-yaml
+
+# Clean previous output
+rm -rf $TEMP_OUTPUT_DIR
+rm -rf $OUTPUT_DIR
+
+# NOTE: https://openapi-generator.tech/docs/generators/typescript-fetch/
+# Generate the Coordinator API models
+yarn openapi-generator-cli generate \
+  -i "$SCHEMA_FILE" \
+  -g typescript-fetch \
+  -o "$TEMP_OUTPUT_DIR" \
+  --skip-validate-spec \
+  --additional-properties=supportsES6=true \
+  --additional-properties=modelPropertyNaming=original \
+  --additional-properties=enumPropertyNaming=original \
+  --additional-properties=withoutRuntimeChecks=true
+
+# Remove the generated API client, just keep the models
+cp -r $TEMP_OUTPUT_DIR/models $OUTPUT_DIR
+rm -rf $TEMP_OUTPUT_DIR
+
+yarn prettier --write $OUTPUT_DIR

package/index.ts

@@ -0,0 +1,30 @@
+import 'webrtc-adapter';
+
+export * as CoordinatorModels from './src/gen/coordinator';
+export * from './src/coordinator/connection/types';
+
+export * as SfuEvents from './src/gen/video/sfu/event/events';
+export * as SfuModels from './src/gen/video/sfu/models/models';
+// due to name collision with `/rtc/Call.ts`
+export * as CallMeta from './src/gen/video/coordinator/call_v1/call';
+
+export * from './src/gen/google/protobuf/timestamp';
+export * from './src/gen/video/coordinator/client_v1_rpc/client_rpc';
+export * from './src/gen/video/coordinator/edge_v1/edge';
+export * from './src/gen/video/coordinator/event_v1/event';
+export * from './src/gen/video/coordinator/stat_v1/stat';
+
+export * from './src/config/types';
+export * from './src/config/defaultConfigs';
+export * from './src/rtc/types';
+export * from './src/stats/types';
+
+export * from './src/rtc/Call';
+export * from './src/rtc/CallMetadata';
+export * from './src/StreamVideoClient';
+export * from './src/StreamSfuClient';
+export * from './src/devices';
+export * from './src/store';
+
+export * from './src/helpers/sound-detector';
+export * as Browsers from './src/helpers/browsers';

package/openapitools.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "./node_modules/@openapitools/openapi-generator-cli/config.schema.json",
+  "spaces": 2,
+  "generator-cli": {
+    "version": "6.2.1"
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@stream-io/video-client",
+  "packageManager": "yarn@3.2.4",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "See license in LICENSE",
+  "scripts": {
+    "clean": "rimraf dist",
+    "start": "rollup -w -c",
+    "build": "yarn clean && rollup -c",
+    "test": "vitest",
+    "clean:docs": "rimraf generated-docs",
+    "generate-docs": "yarn clean:docs && yarn generate-docs:classes && yarn generate-docs:utils",
+    "test-ci": "vitest --coverage",
+    "generate:open-api": "./generate-openapi.sh",
+    "generate-docs:classes": "typedoc --options typedoc.json --exclude '!**/*(Call|StreamVideoClient).ts' ./index.ts && replace-in-file '# Class: ' '# ' temp-docs/** && cp -a temp-docs/classes/. generated-docs && rm -r temp-docs",
+    "generate-docs:utils": "typedoc --options typedoc.json --exclude '!**/*(devices).ts' ./index.ts && replace-in-file '# @stream-io/video-client' '# Utilities' temp-docs/** && cp temp-docs/modules.md generated-docs/utilities.md && rm -r temp-docs"
+  },
+  "dependencies": {
+    "@protobuf-ts/runtime": "^2.8.2",
+    "@protobuf-ts/runtime-rpc": "^2.8.2",
+    "@protobuf-ts/twirp-transport": "^2.8.2",
+    "axios": "^1.3.2",
+    "base64-js": "^1.5.1",
+    "isomorphic-ws": "^5.0.0",
+    "jsonwebtoken": "^9.0.0",
+    "rxjs": "~7.5.7",
+    "uuid": "^9.0.0",
+    "webrtc-adapter": "^8.2.0",
+    "ws": "^8.12.0"
+  },
+  "devDependencies": {
+    "@openapitools/openapi-generator-cli": "^2.5.2",
+    "@rollup/plugin-replace": "^5.0.2",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@types/jsonwebtoken": "^9.0.1",
+    "@types/rimraf": "^3.0.2",
+    "@types/uuid": "^9.0.0",
+    "@types/ws": "^8.5.4",
+    "@vitest/coverage-c8": "^0.25.3",
+    "prettier": "^2.8.3",
+    "replace-in-file": "^6.3.5",
+    "rimraf": "^3.0.2",
+    "rollup": "^3.14.0",
+    "typedoc": "^0.23.23",
+    "typedoc-plugin-markdown": "^3.13.6",
+    "typescript": "^4.9.4",
+    "vite": "^3.2.5",
+    "vitest": "^0.25.4",
+    "vitest-mock-extended": "^1.0.7"
+  },
+  "version": "0.0.1-alpha.7"
+}

package/rollup.config.mjs

@@ -0,0 +1,48 @@
+import typescript from '@rollup/plugin-typescript';
+import replace from '@rollup/plugin-replace';
+
+import pkg from './package.json' assert { type: 'json' };
+
+// these modules are used only in nodejs and are not needed in the browser
+const browserIgnoredModules = [
+  'jsonwebtoken',
+  'https',
+  'crypto',
+  'util',
+  'stream',
+];
+
+/**
+ * A plugin which converts the nodejs modules to empty modules for the browser.
+ *
+ * @type {import('rollup').Plugin}
+ */
+const browserIgnorePlugin = {
+  name: 'browser-remapper',
+  resolveId: (importee) =>
+    browserIgnoredModules.includes(importee) ? importee : null,
+  load: (id) =>
+    browserIgnoredModules.includes(id) ? 'export default null;' : null,
+};
+
+/**
+ * @type {import('rollup').RollupOptions}
+ */
+const rollupConfig = {
+  input: 'index.ts',
+  output: {
+    dir: 'dist',
+    format: 'es',
+    sourcemap: true,
+  },
+  plugins: [
+    replace({
+      preventAssignment: true,
+      'process.env.PKG_VERSION': JSON.stringify(pkg.version),
+    }),
+    browserIgnorePlugin,
+    typescript(),
+  ],
+};
+
+export default rollupConfig;