@whereby.com/browser-sdk 2.0.0-alpha25 → 2.0.0-alpha27

package/dist/RoomConnection.js

@@ -1,608 +0,0 @@
-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 "./index";
-import LocalMedia from "./LocalMedia";
-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 path = `${parsedUrl.pathname.replace(/^\/$/, "")}/protocol/socket.io/v4`;
-    const SOCKET_HOST = parsedUrl.origin;
-    const socketConf = {
-        autoConnect: false,
-        host: SOCKET_HOST,
-        path,
-        reconnectionDelay: 5000,
-        reconnectionDelayMax: 30000,
-        timeout: 10000,
-        withCredentials: true,
-    };
-    return new ServerSocket(SOCKET_HOST, socketConf);
-}
-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 CustomEvent("participant_stream_added", { detail: { participantId: clientId, stream, streamId } });
-    }
-    return new CustomEvent("screenshare_started", {
-        detail: { participantId: clientId, stream, id: streamId, isLocal: false },
-    });
-}
-const noop = () => {
-    return;
-};
-const TypedEventTarget = EventTarget;
-export default class RoomConnection extends TypedEventTarget {
-    constructor(roomUrl, { displayName, localMedia, localMediaConstraints, logger, roomKey }) {
-        super();
-        this.localParticipant = null;
-        this.remoteParticipants = [];
-        this.screenshares = [];
-        this._deviceCredentials = null;
-        this._ownsLocalMedia = false;
-        this.organizationId = "";
-        this.roomConnectionStatus = "";
-        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.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.localMedia.addEventListener("microphone_enabled", (e) => {
-            const { enabled } = e.detail;
-            this.signalSocket.emit("enable_audio", { 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 CustomEvent("chat_message", { detail: message }));
-    }
-    _handleCloudRecordingStarted({ client }) {
-        this.dispatchEvent(new CustomEvent("cloud_recording_started", {
-            detail: {
-                status: "recording",
-                startedAt: client.startedCloudRecordingAt
-                    ? new Date(client.startedCloudRecordingAt).getTime()
-                    : new Date().getTime(),
-            },
-        }));
-    }
-    _handleStreamingStarted() {
-        this.dispatchEvent(new CustomEvent("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 CustomEvent("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 CustomEvent("participant_left", { detail: { participantId: remoteParticipant.id } }));
-    }
-    _handleClientAudioEnabled({ clientId, isAudioEnabled }) {
-        const remoteParticipant = this.remoteParticipants.find((p) => p.id === clientId);
-        if (!remoteParticipant) {
-            return;
-        }
-        this.dispatchEvent(new CustomEvent("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 CustomEvent("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 CustomEvent("participant_metadata_changed", {
-            detail: { participantId: remoteParticipant.id, displayName },
-        }));
-    }
-    _handleKnockHandled(payload) {
-        const { clientId, resolution } = payload;
-        if (clientId !== this.selfId) {
-            return;
-        }
-        if (resolution === "accepted") {
-            this.roomConnectionStatus = "accepted";
-            this._roomKey = payload.metadata.roomKey;
-            this._joinRoom();
-        }
-        else if (resolution === "rejected") {
-            this.roomConnectionStatus = "rejected";
-            this.dispatchEvent(new CustomEvent("room_connection_status_changed", {
-                detail: {
-                    roomConnectionStatus: this.roomConnectionStatus,
-                },
-            }));
-        }
-    }
-    _handleKnockerLeft(payload) {
-        const { clientId } = payload;
-        this.dispatchEvent(new CustomEvent("waiting_participant_left", {
-            detail: { participantId: clientId },
-        }));
-    }
-    _handleRoomJoined(event) {
-        const { error, isLocked, room, selfId } = event;
-        this.selfId = selfId;
-        if (error === "room_locked" && isLocked) {
-            this.roomConnectionStatus = "room_locked";
-            this.dispatchEvent(new CustomEvent("room_connection_status_changed", {
-                detail: {
-                    roomConnectionStatus: this.roomConnectionStatus,
-                },
-            }));
-            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.roomConnectionStatus = "connected";
-            this.dispatchEvent(new CustomEvent("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 CustomEvent("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.roomConnectionStatus = "disconnected";
-        this.dispatchEvent(new CustomEvent("room_connection_status_changed", {
-            detail: {
-                roomConnectionStatus: this.roomConnectionStatus,
-            },
-        }));
-    }
-    _handleCloudRecordingStopped() {
-        this.dispatchEvent(new CustomEvent("cloud_recording_stopped"));
-    }
-    _handleStreamingStopped() {
-        this.dispatchEvent(new CustomEvent("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 CustomEvent("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"}`,
-        });
-    }
-    join() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (["connected", "connecting"].includes(this.roomConnectionStatus)) {
-                console.warn(`Trying to join when room state is already ${this.roomConnectionStatus}`);
-                return;
-            }
-            this.logger.log("Joining room");
-            this.signalSocket.connect();
-            this.roomConnectionStatus = "connecting";
-            this.dispatchEvent(new CustomEvent("room_connection_status_changed", {
-                detail: {
-                    roomConnectionStatus: this.roomConnectionStatus,
-                },
-            }));
-            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.roomConnectionStatus = "knocking";
-        this.dispatchEvent(new CustomEvent("room_connection_status_changed", {
-            detail: {
-                roomConnectionStatus: this.roomConnectionStatus,
-            },
-        }));
-        this.signalSocket.emit("knock_room", {
-            displayName: this.displayName,
-            imageUrl: null,
-            kickFromOtherRooms: true,
-            liveVideo: false,
-            organizationId: this.organizationId,
-            roomKey: this._roomKey,
-            roomName: this.roomName,
-        });
-    }
-    leave() {
-        this.roomConnectionStatus = "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.roomConnectionStatus = "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;
-        return __awaiter(this, void 0, void 0, function* () {
-            const screenshareStream = this.localMedia.screenshareStream || (yield this.localMedia.startScreenshare());
-            (_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.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 CustomEvent("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 CustomEvent("screenshare_stopped", { detail: { participantId: this.selfId, id } }));
-            this.localMedia.stopScreenshare();
-        }
-    }
-}

package/dist/RoomParticipant.d.ts

@@ -1,50 +0,0 @@
-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 {};