@whereby.com/browser-sdk 2.0.0-alpha9 → 2.0.0-beta1

package/dist/RoomConnection.js

@@ -0,0 +1,627 @@
+import { __awaiter } from "tslib";
+import RtcManagerDispatcher from "@whereby/jslib-media/src/webrtc/RtcManagerDispatcher";
+import { fromLocation } from "@whereby/jslib-media/src/utils/urls";
+import { ApiClient, CredentialsService, OrganizationApiClient, OrganizationService, OrganizationServiceCache, RoomService, } from "./api";
+import { LocalParticipant, RemoteParticipant } from "./RoomParticipant";
+import ServerSocket from "@whereby/jslib-media/src/utils/ServerSocket";
+import { sdkVersion } from "./version";
+import LocalMedia from "./LocalMedia";
+class RoomConnectionEvent extends CustomEvent {
+    constructor(eventType, eventInitDict) {
+        super(eventType, eventInitDict);
+    }
+}
+const API_BASE_URL = process.env["REACT_APP_API_BASE_URL"] || "https://api.whereby.dev";
+const SIGNAL_BASE_URL = process.env["REACT_APP_SIGNAL_BASE_URL"] || "wss://signal.appearin.net";
+const NON_PERSON_ROLES = ["recorder", "streamer"];
+const reportedStreamResolutions = new Map();
+function createSocket() {
+    const parsedUrl = new URL(SIGNAL_BASE_URL);
+    const socketHost = parsedUrl.origin;
+    const socketOverrides = {
+        autoConnect: false,
+    };
+    return new ServerSocket(socketHost, socketOverrides);
+}
+export function handleStreamAdded(remoteParticipants, { clientId, stream, streamId, streamType }) {
+    if (!streamId) {
+        streamId = stream.id;
+    }
+    const remoteParticipant = remoteParticipants.find((p) => p.id === clientId);
+    if (!remoteParticipant) {
+        return;
+    }
+    const remoteParticipantStream = remoteParticipant.streams.find((s) => s.id === streamId) || remoteParticipant.streams[0];
+    if ((remoteParticipant.stream && remoteParticipant.stream.id === streamId) ||
+        (!remoteParticipant.stream && streamType === "webcam") ||
+        (!remoteParticipant.stream && !streamType && remoteParticipant.streams.indexOf(remoteParticipantStream) < 1)) {
+        return new RoomConnectionEvent("participant_stream_added", {
+            detail: { participantId: clientId, stream, streamId },
+        });
+    }
+    return new RoomConnectionEvent("screenshare_started", {
+        detail: {
+            participantId: clientId,
+            stream,
+            id: streamId,
+            isLocal: false,
+            hasAudioTrack: stream.getAudioTracks().length > 0,
+        },
+    });
+}
+const noop = () => {
+    return;
+};
+const TypedEventTarget = EventTarget;
+export default class RoomConnection extends TypedEventTarget {
+    constructor(roomUrl, { displayName, localMedia, localMediaConstraints, logger, roomKey, externalId }) {
+        super();
+        this.remoteParticipants = [];
+        this.screenshares = [];
+        this._deviceCredentials = null;
+        this._ownsLocalMedia = false;
+        this.organizationId = "";
+        this.connectionStatus = "initializing";
+        this.selfId = null;
+        this.roomUrl = new URL(roomUrl);
+        const searchParams = new URLSearchParams(this.roomUrl.search);
+        this._roomKey = roomKey || searchParams.get("roomKey");
+        this.roomName = this.roomUrl.pathname;
+        this.logger = logger || {
+            debug: noop,
+            error: noop,
+            log: noop,
+            warn: noop,
+        };
+        this.displayName = displayName;
+        this.externalId = externalId;
+        this.localMediaConstraints = localMediaConstraints;
+        const urls = fromLocation({ host: this.roomUrl.host });
+        if (localMedia) {
+            this.localMedia = localMedia;
+        }
+        else if (localMediaConstraints) {
+            this.localMedia = new LocalMedia(localMediaConstraints);
+            this._ownsLocalMedia = true;
+        }
+        else {
+            throw new Error("Missing constraints");
+        }
+        this.credentialsService = CredentialsService.create({ baseUrl: API_BASE_URL });
+        this.apiClient = new ApiClient({
+            fetchDeviceCredentials: this.credentialsService.getCredentials.bind(this.credentialsService),
+            baseUrl: API_BASE_URL,
+        });
+        this.organizationService = new OrganizationService({ apiClient: this.apiClient });
+        this.organizationServiceCache = new OrganizationServiceCache({
+            organizationService: this.organizationService,
+            subdomain: urls.subdomain,
+        });
+        this.organizationApiClient = new OrganizationApiClient({
+            apiClient: this.apiClient,
+            fetchOrganization: () => __awaiter(this, void 0, void 0, function* () {
+                const organization = yield this.organizationServiceCache.fetchOrganization();
+                return organization || undefined;
+            }),
+        });
+        this.roomService = new RoomService({ organizationApiClient: this.organizationApiClient });
+        this.signalSocket = createSocket();
+        this.signalSocket.on("new_client", this._handleNewClient.bind(this));
+        this.signalSocket.on("chat_message", this._handleNewChatMessage.bind(this));
+        this.signalSocket.on("client_left", this._handleClientLeft.bind(this));
+        this.signalSocket.on("audio_enabled", this._handleClientAudioEnabled.bind(this));
+        this.signalSocket.on("video_enabled", this._handleClientVideoEnabled.bind(this));
+        this.signalSocket.on("client_metadata_received", this._handleClientMetadataReceived.bind(this));
+        this.signalSocket.on("knock_handled", this._handleKnockHandled.bind(this));
+        this.signalSocket.on("knocker_left", this._handleKnockerLeft.bind(this));
+        this.signalSocket.on("room_joined", this._handleRoomJoined.bind(this));
+        this.signalSocket.on("room_knocked", this._handleRoomKnocked.bind(this));
+        this.signalSocket.on("cloud_recording_stopped", this._handleCloudRecordingStopped.bind(this));
+        this.signalSocket.on("screenshare_started", this._handleScreenshareStarted.bind(this));
+        this.signalSocket.on("screenshare_stopped", this._handleScreenshareStopped.bind(this));
+        this.signalSocket.on("streaming_stopped", this._handleStreamingStopped.bind(this));
+        this.signalSocket.on("disconnect", this._handleDisconnect.bind(this));
+        this.signalSocket.on("connect_error", this._handleDisconnect.bind(this));
+        this.signalSocketManager = this.signalSocket.getManager();
+        this.signalSocketManager.on("reconnect", this._handleReconnect.bind(this));
+        this.localMedia.addEventListener("camera_enabled", (e) => {
+            const { enabled } = e.detail;
+            this.signalSocket.emit("enable_video", { enabled });
+            this.dispatchEvent(new RoomConnectionEvent("local_camera_enabled", { detail: { enabled } }));
+        });
+        this.localMedia.addEventListener("microphone_enabled", (e) => {
+            const { enabled } = e.detail;
+            this.signalSocket.emit("enable_audio", { enabled });
+            this.dispatchEvent(new RoomConnectionEvent("local_microphone_enabled", { detail: { enabled } }));
+        });
+        const webrtcProvider = {
+            getMediaConstraints: () => ({
+                audio: this.localMedia.isMicrophoneEnabled(),
+                video: this.localMedia.isCameraEnabled(),
+            }),
+            deferrable(clientId) {
+                return !clientId;
+            },
+        };
+        this.rtcManagerDispatcher = new RtcManagerDispatcher({
+            emitter: {
+                emit: this._handleRtcEvent.bind(this),
+            },
+            serverSocket: this.signalSocket,
+            webrtcProvider,
+            features: {
+                lowDataModeEnabled: false,
+                sfuServerOverrideHost: undefined,
+                turnServerOverrideHost: undefined,
+                useOnlyTURN: undefined,
+                vp9On: false,
+                h264On: false,
+                simulcastScreenshareOn: false,
+            },
+        });
+    }
+    get roomKey() {
+        return this._roomKey;
+    }
+    _handleNewChatMessage(message) {
+        this.dispatchEvent(new RoomConnectionEvent("chat_message", { detail: message }));
+    }
+    _handleCloudRecordingStarted({ client }) {
+        this.dispatchEvent(new RoomConnectionEvent("cloud_recording_started", {
+            detail: {
+                status: "recording",
+                startedAt: client.startedCloudRecordingAt
+                    ? new Date(client.startedCloudRecordingAt).getTime()
+                    : new Date().getTime(),
+            },
+        }));
+    }
+    _handleStreamingStarted() {
+        this.dispatchEvent(new RoomConnectionEvent("streaming_started", {
+            detail: {
+                status: "streaming",
+                startedAt: new Date().getTime(),
+            },
+        }));
+    }
+    _handleNewClient({ client }) {
+        if (client.role.roleName === "recorder") {
+            this._handleCloudRecordingStarted({ client });
+        }
+        if (client.role.roleName === "streamer") {
+            this._handleStreamingStarted();
+        }
+        if (NON_PERSON_ROLES.includes(client.role.roleName)) {
+            return;
+        }
+        const remoteParticipant = new RemoteParticipant(Object.assign(Object.assign({}, client), { newJoiner: true }));
+        this.remoteParticipants = [...this.remoteParticipants, remoteParticipant];
+        this._handleAcceptStreams([remoteParticipant]);
+        this.dispatchEvent(new RoomConnectionEvent("participant_joined", {
+            detail: { remoteParticipant },
+        }));
+    }
+    _handleClientLeft({ clientId }) {
+        const remoteParticipant = this.remoteParticipants.find((p) => p.id === clientId);
+        this.remoteParticipants = this.remoteParticipants.filter((p) => p.id !== clientId);
+        if (!remoteParticipant) {
+            return;
+        }
+        this.dispatchEvent(new RoomConnectionEvent("participant_left", { detail: { participantId: remoteParticipant.id } }));
+    }
+    _handleClientAudioEnabled({ clientId, isAudioEnabled }) {
+        const remoteParticipant = this.remoteParticipants.find((p) => p.id === clientId);
+        if (!remoteParticipant) {
+            return;
+        }
+        this.dispatchEvent(new RoomConnectionEvent("participant_audio_enabled", {
+            detail: { participantId: remoteParticipant.id, isAudioEnabled },
+        }));
+    }
+    _handleClientVideoEnabled({ clientId, isVideoEnabled }) {
+        const remoteParticipant = this.remoteParticipants.find((p) => p.id === clientId);
+        if (!remoteParticipant) {
+            return;
+        }
+        this.dispatchEvent(new RoomConnectionEvent("participant_video_enabled", {
+            detail: { participantId: remoteParticipant.id, isVideoEnabled },
+        }));
+    }
+    _handleClientMetadataReceived({ payload: { clientId, displayName } }) {
+        const remoteParticipant = this.remoteParticipants.find((p) => p.id === clientId);
+        if (!remoteParticipant) {
+            return;
+        }
+        this.dispatchEvent(new RoomConnectionEvent("participant_metadata_changed", {
+            detail: { participantId: remoteParticipant.id, displayName },
+        }));
+    }
+    _handleKnockHandled(payload) {
+        const { clientId, resolution } = payload;
+        if (clientId !== this.selfId) {
+            return;
+        }
+        if (resolution === "accepted") {
+            this._roomKey = payload.metadata.roomKey;
+            this._joinRoom();
+        }
+        else if (resolution === "rejected") {
+            this.connectionStatus = "knock_rejected";
+            this.dispatchEvent(new RoomConnectionEvent("connection_status_changed", {
+                detail: {
+                    connectionStatus: this.connectionStatus,
+                },
+            }));
+        }
+    }
+    _handleKnockerLeft(payload) {
+        const { clientId } = payload;
+        this.dispatchEvent(new RoomConnectionEvent("waiting_participant_left", {
+            detail: { participantId: clientId },
+        }));
+    }
+    _handleRoomJoined(event) {
+        const { error, isLocked, room, selfId } = event;
+        this.selfId = selfId;
+        if (error === "room_locked" && isLocked) {
+            this.connectionStatus = "room_locked";
+            this.dispatchEvent(new RoomConnectionEvent("connection_status_changed", {
+                detail: {
+                    connectionStatus: this.connectionStatus,
+                },
+            }));
+            return;
+        }
+        if (room) {
+            const { clients, knockers } = room;
+            const localClient = clients.find((c) => c.id === selfId);
+            if (!localClient)
+                throw new Error("Missing local client");
+            this.localParticipant = new LocalParticipant(Object.assign(Object.assign({}, localClient), { stream: this.localMedia.stream || undefined }));
+            const recorderClient = clients.find((c) => c.role.roleName === "recorder");
+            if (recorderClient) {
+                this._handleCloudRecordingStarted({ client: recorderClient });
+            }
+            const streamerClient = clients.find((c) => c.role.roleName === "streamer");
+            if (streamerClient) {
+                this._handleStreamingStarted();
+            }
+            this.remoteParticipants = clients
+                .filter((c) => c.id !== selfId)
+                .filter((c) => !NON_PERSON_ROLES.includes(c.role.roleName))
+                .map((c) => new RemoteParticipant(Object.assign(Object.assign({}, c), { newJoiner: false })));
+            this.connectionStatus = "connected";
+            this.dispatchEvent(new RoomConnectionEvent("room_joined", {
+                detail: {
+                    localParticipant: this.localParticipant,
+                    remoteParticipants: this.remoteParticipants,
+                    waitingParticipants: knockers.map((knocker) => {
+                        return { id: knocker.clientId, displayName: knocker.displayName };
+                    }),
+                },
+            }));
+        }
+    }
+    _handleRoomKnocked(event) {
+        const { clientId, displayName } = event;
+        this.dispatchEvent(new RoomConnectionEvent("waiting_participant_joined", {
+            detail: { participantId: clientId, displayName },
+        }));
+    }
+    _handleReconnect() {
+        this.logger.log("Reconnected to signal socket");
+        this.signalSocket.emit("identify_device", { deviceCredentials: this._deviceCredentials });
+        this.signalSocket.once("device_identified", () => {
+            this._joinRoom();
+        });
+    }
+    _handleDisconnect() {
+        this.connectionStatus = "disconnected";
+        this.dispatchEvent(new RoomConnectionEvent("connection_status_changed", {
+            detail: {
+                connectionStatus: this.connectionStatus,
+            },
+        }));
+    }
+    _handleCloudRecordingStopped() {
+        this.dispatchEvent(new RoomConnectionEvent("cloud_recording_stopped"));
+    }
+    _handleStreamingStopped() {
+        this.dispatchEvent(new RoomConnectionEvent("streaming_stopped"));
+    }
+    _handleScreenshareStarted(screenshare) {
+        const { clientId: participantId, streamId: id, hasAudioTrack } = screenshare;
+        const remoteParticipant = this.remoteParticipants.find((p) => p.id === participantId);
+        if (!remoteParticipant) {
+            this.logger.log("WARN: Could not find participant for screenshare");
+            return;
+        }
+        const foundScreenshare = this.screenshares.find((s) => s.id === id);
+        if (foundScreenshare) {
+            this.logger.log("WARN: Screenshare already exists");
+            return;
+        }
+        remoteParticipant.addStream(id, "to_accept");
+        this._handleAcceptStreams([remoteParticipant]);
+        this.screenshares = [
+            ...this.screenshares,
+            { participantId, id, hasAudioTrack, stream: undefined, isLocal: false },
+        ];
+    }
+    _handleScreenshareStopped(screenshare) {
+        const { clientId: participantId, streamId: id } = screenshare;
+        const remoteParticipant = this.remoteParticipants.find((p) => p.id === participantId);
+        if (!remoteParticipant) {
+            this.logger.log("WARN: Could not find participant for screenshare");
+            return;
+        }
+        remoteParticipant.removeStream(id);
+        this.screenshares = this.screenshares.filter((s) => !(s.participantId === participantId && s.id === id));
+        this.dispatchEvent(new RoomConnectionEvent("screenshare_stopped", { detail: { participantId, id } }));
+    }
+    _handleRtcEvent(eventName, data) {
+        if (eventName === "rtc_manager_created") {
+            return this._handleRtcManagerCreated(data);
+        }
+        else if (eventName === "stream_added") {
+            return this._handleStreamAdded(data);
+        }
+        else if (eventName === "rtc_manager_destroyed") {
+            return this._handleRtcManagerDestroyed();
+        }
+        else {
+            this.logger.log(`Unhandled RTC event ${eventName}`);
+        }
+    }
+    _handleRtcManagerCreated({ rtcManager }) {
+        var _a;
+        this.rtcManager = rtcManager;
+        this.localMedia.addRtcManager(rtcManager);
+        if (this.localMedia.stream) {
+            (_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.addNewStream("0", this.localMedia.stream, !this.localMedia.isMicrophoneEnabled(), !this.localMedia.isCameraEnabled());
+        }
+        if (this.remoteParticipants.length) {
+            this._handleAcceptStreams(this.remoteParticipants);
+        }
+    }
+    _handleRtcManagerDestroyed() {
+        this.rtcManager = undefined;
+    }
+    _handleAcceptStreams(remoteParticipants) {
+        var _a, _b;
+        if (!this.rtcManager) {
+            this.logger.log("Unable to accept streams, no rtc manager");
+            return;
+        }
+        const shouldAcceptNewClients = (_b = (_a = this.rtcManager).shouldAcceptStreamsFromBothSides) === null || _b === void 0 ? void 0 : _b.call(_a);
+        const activeBreakout = false;
+        const myselfBroadcasting = false;
+        remoteParticipants.forEach((participant) => {
+            const { id: participantId, streams, newJoiner } = participant;
+            streams.forEach((stream) => {
+                var _a, _b;
+                const { id: streamId, state: streamState } = stream;
+                let newState = undefined;
+                const isInSameRoomOrGroupOrClientBroadcasting = true;
+                if (isInSameRoomOrGroupOrClientBroadcasting) {
+                    if (streamState !== "done_accept") {
+                        newState = `${newJoiner && streamId === "0" ? "new" : "to"}_accept`;
+                    }
+                }
+                else if (myselfBroadcasting) {
+                    if (streamState !== "done_accept") {
+                        newState = `${newJoiner && streamId === "0" ? "done" : "old"}_accept`;
+                    }
+                }
+                else {
+                    if (streamState !== "done_unaccept") {
+                        newState = "to_unaccept";
+                    }
+                }
+                if (!newState) {
+                    return;
+                }
+                if (newState === "to_accept" ||
+                    (newState === "new_accept" && shouldAcceptNewClients) ||
+                    (newState === "old_accept" && !shouldAcceptNewClients)) {
+                    this.logger.log(`Accepting stream ${streamId} from ${participantId}`);
+                    (_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.acceptNewStream({
+                        streamId: streamId === "0" ? participantId : streamId,
+                        clientId: participantId,
+                        shouldAddLocalVideo: streamId === "0",
+                        activeBreakout,
+                    });
+                }
+                else if (newState === "new_accept" || newState === "old_accept") {
+                }
+                else if (newState === "to_unaccept") {
+                    this.logger.log(`Disconnecting stream ${streamId} from ${participantId}`);
+                    (_b = this.rtcManager) === null || _b === void 0 ? void 0 : _b.disconnect(streamId === "0" ? participantId : streamId, activeBreakout);
+                }
+                else if (newState !== "done_accept") {
+                    this.logger.warn(`Stream state not handled: ${newState} for ${participantId}-${streamId}`);
+                    return;
+                }
+                else {
+                }
+                participant.updateStreamState(streamId, streamState.replace(/to_|new_|old_/, "done_"));
+            });
+        });
+    }
+    _handleStreamAdded(args) {
+        const streamAddedEvent = handleStreamAdded(this.remoteParticipants, args);
+        if (streamAddedEvent) {
+            this.dispatchEvent(streamAddedEvent);
+        }
+    }
+    _joinRoom() {
+        this.signalSocket.emit("join_room", {
+            avatarUrl: null,
+            config: {
+                isAudioEnabled: this.localMedia.isMicrophoneEnabled(),
+                isVideoEnabled: this.localMedia.isCameraEnabled(),
+            },
+            deviceCapabilities: { canScreenshare: true },
+            displayName: this.displayName,
+            isCoLocated: false,
+            isDevicePermissionDenied: false,
+            kickFromOtherRooms: false,
+            organizationId: this.organizationId,
+            roomKey: this.roomKey,
+            roomName: this.roomName,
+            selfId: "",
+            userAgent: `browser-sdk:${sdkVersion || "unknown"}`,
+            externalId: this.externalId,
+        });
+    }
+    join() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (["connected", "connecting"].includes(this.connectionStatus)) {
+                console.warn(`Trying to join when room state is already ${this.connectionStatus}`);
+                return;
+            }
+            this.signalSocket.connect();
+            this.connectionStatus = "connecting";
+            this.dispatchEvent(new RoomConnectionEvent("connection_status_changed", {
+                detail: {
+                    connectionStatus: this.connectionStatus,
+                },
+            }));
+            const organization = yield this.organizationServiceCache.fetchOrganization();
+            if (!organization) {
+                throw new Error("Invalid room url");
+            }
+            this.organizationId = organization.organizationId;
+            if (this._ownsLocalMedia) {
+                yield this.localMedia.start();
+            }
+            this._deviceCredentials = yield this.credentialsService.getCredentials();
+            this.logger.log("Connected to signal socket");
+            this.signalSocket.emit("identify_device", { deviceCredentials: this._deviceCredentials });
+            this.signalSocket.once("device_identified", () => {
+                this._joinRoom();
+            });
+        });
+    }
+    knock() {
+        this.connectionStatus = "knocking";
+        this.dispatchEvent(new RoomConnectionEvent("connection_status_changed", {
+            detail: {
+                connectionStatus: this.connectionStatus,
+            },
+        }));
+        this.signalSocket.emit("knock_room", {
+            displayName: this.displayName,
+            imageUrl: null,
+            kickFromOtherRooms: true,
+            liveVideo: false,
+            organizationId: this.organizationId,
+            roomKey: this._roomKey,
+            roomName: this.roomName,
+            externalId: this.externalId,
+        });
+    }
+    leave() {
+        this.connectionStatus = "disconnecting";
+        if (this._ownsLocalMedia) {
+            this.localMedia.stop();
+        }
+        if (this.rtcManager) {
+            this.localMedia.removeRtcManager(this.rtcManager);
+            this.rtcManager.disconnectAll();
+            this.rtcManager = undefined;
+        }
+        if (!this.signalSocket) {
+            return;
+        }
+        this.signalSocket.emit("leave_room");
+        this.signalSocket.disconnect();
+        this.connectionStatus = "disconnected";
+    }
+    sendChatMessage(text) {
+        this.signalSocket.emit("chat_message", {
+            text,
+        });
+    }
+    setDisplayName(displayName) {
+        this.signalSocket.emit("send_client_metadata", {
+            type: "UserData",
+            payload: {
+                displayName,
+            },
+        });
+    }
+    acceptWaitingParticipant(participantId) {
+        this.signalSocket.emit("handle_knock", {
+            action: "accept",
+            clientId: participantId,
+            response: {},
+        });
+    }
+    rejectWaitingParticipant(participantId) {
+        this.signalSocket.emit("handle_knock", {
+            action: "reject",
+            clientId: participantId,
+            response: {},
+        });
+    }
+    updateStreamResolution({ streamId, width, height }) {
+        var _a, _b;
+        if (!streamId || !this.rtcManager) {
+            return;
+        }
+        if (((_b = (_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id) === streamId) {
+            return;
+        }
+        const old = reportedStreamResolutions.get(streamId);
+        if (!old || old.width !== width || old.height !== height) {
+            this.rtcManager.updateStreamResolution(streamId, null, { width: width || 1, height: height || 1 });
+        }
+        reportedStreamResolutions.set(streamId, { width, height });
+    }
+    startScreenshare() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const screenshareStream = this.localMedia.screenshareStream || (yield this.localMedia.startScreenshare());
+            const onEnded = () => {
+                this.stopScreenshare();
+            };
+            if ("oninactive" in screenshareStream) {
+                screenshareStream.addEventListener("inactive", onEnded);
+            }
+            else {
+                (_a = screenshareStream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.addEventListener("ended", onEnded);
+            }
+            (_b = this.rtcManager) === null || _b === void 0 ? void 0 : _b.addNewStream(screenshareStream.id, screenshareStream, false, true);
+            this.screenshares = [
+                ...this.screenshares,
+                {
+                    participantId: this.selfId || "",
+                    id: screenshareStream.id,
+                    hasAudioTrack: false,
+                    stream: screenshareStream,
+                    isLocal: true,
+                },
+            ];
+            this.dispatchEvent(new RoomConnectionEvent("screenshare_started", {
+                detail: {
+                    participantId: this.selfId || "",
+                    id: screenshareStream.id,
+                    hasAudioTrack: false,
+                    stream: screenshareStream,
+                    isLocal: true,
+                },
+            }));
+        });
+    }
+    stopScreenshare() {
+        var _a;
+        if (this.localMedia.screenshareStream) {
+            const { id } = this.localMedia.screenshareStream;
+            (_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.removeStream(id, this.localMedia.screenshareStream, null);
+            this.screenshares = this.screenshares.filter((s) => s.id !== id);
+            this.dispatchEvent(new RoomConnectionEvent("screenshare_stopped", { detail: { participantId: this.selfId || "", id } }));
+            this.localMedia.stopScreenshare();
+        }
+    }
+}

package/dist/RoomParticipant.d.ts

@@ -0,0 +1,50 @@
+interface RoomParticipantData {
+    displayName: string;
+    id: string;
+    stream?: MediaStream;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+}
+export default class RoomParticipant {
+    readonly displayName: string;
+    readonly id: string;
+    readonly stream?: MediaStream;
+    readonly isAudioEnabled: boolean;
+    readonly isLocalParticipant: boolean;
+    readonly isVideoEnabled: boolean;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+interface RemoteParticipantData {
+    newJoiner: boolean;
+    streams: string[];
+}
+export type StreamState = "new_accept" | "to_accept" | "old_accept" | "done_accept" | "to_unaccept" | "done_unaccept" | "auto";
+interface Stream {
+    id: string;
+    state: StreamState;
+}
+export declare class RemoteParticipant extends RoomParticipant {
+    readonly newJoiner: boolean;
+    readonly streams: Stream[];
+    constructor({ displayName, id, newJoiner, streams, isAudioEnabled, isVideoEnabled, }: RoomParticipantData & RemoteParticipantData);
+    addStream(streamId: string, state: StreamState): void;
+    removeStream(streamId: string): void;
+    updateStreamState(streamId: string, state: StreamState): void;
+}
+export declare class LocalParticipant extends RoomParticipant {
+    readonly isLocalParticipant = true;
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+export interface WaitingParticipant {
+    id: string;
+    displayName: string | null;
+}
+export declare class Screenshare {
+    readonly participantId: string;
+    readonly id: string;
+    readonly hasAudioTrack: boolean;
+    readonly stream?: MediaStream;
+    readonly isLocal: boolean;
+    constructor({ participantId, id, hasAudioTrack, stream, isLocal }: Screenshare);
+}
+export {};