@edge-base/web 0.1.5 → 0.2.1

package/dist/room-p2p-media.js

@@ -0,0 +1,690 @@
+import { createSubscription } from './room.js';
+const DEFAULT_SIGNAL_PREFIX = 'edgebase.media.p2p';
+const DEFAULT_ICE_SERVERS = [
+    { urls: 'stun:stun.l.google.com:19302' },
+];
+const DEFAULT_MEMBER_READY_TIMEOUT_MS = 10_000;
+function buildTrackKey(memberId, trackId) {
+    return `${memberId}:${trackId}`;
+}
+function buildExactDeviceConstraint(deviceId) {
+    return { deviceId: { exact: deviceId } };
+}
+function normalizeTrackKind(track) {
+    if (track.kind === 'audio')
+        return 'audio';
+    if (track.kind === 'video')
+        return 'video';
+    return null;
+}
+function serializeDescription(description) {
+    return {
+        type: description.type,
+        sdp: description.sdp ?? undefined,
+    };
+}
+function serializeCandidate(candidate) {
+    if ('toJSON' in candidate && typeof candidate.toJSON === 'function') {
+        return candidate.toJSON();
+    }
+    return candidate;
+}
+export class RoomP2PMediaTransport {
+    room;
+    options;
+    localTracks = new Map();
+    peers = new Map();
+    remoteTrackHandlers = [];
+    remoteTrackKinds = new Map();
+    emittedRemoteTracks = new Set();
+    pendingRemoteTracks = new Map();
+    subscriptions = [];
+    localMemberId = null;
+    connected = false;
+    constructor(room, options) {
+        this.room = room;
+        this.options = {
+            rtcConfiguration: {
+                ...options?.rtcConfiguration,
+                iceServers: options?.rtcConfiguration?.iceServers && options.rtcConfiguration.iceServers.length > 0
+                    ? options.rtcConfiguration.iceServers
+                    : DEFAULT_ICE_SERVERS,
+            },
+            peerConnectionFactory: options?.peerConnectionFactory
+                ?? ((configuration) => new RTCPeerConnection(configuration)),
+            mediaDevices: options?.mediaDevices
+                ?? (typeof navigator !== 'undefined' ? navigator.mediaDevices : undefined),
+            signalPrefix: options?.signalPrefix ?? DEFAULT_SIGNAL_PREFIX,
+        };
+    }
+    getSessionId() {
+        return this.localMemberId;
+    }
+    getPeerConnection() {
+        if (this.peers.size !== 1) {
+            return null;
+        }
+        return this.peers.values().next().value?.pc ?? null;
+    }
+    async connect(payload) {
+        if (this.connected && this.localMemberId) {
+            return this.localMemberId;
+        }
+        if (payload && typeof payload === 'object' && 'sessionDescription' in payload) {
+            throw new Error('RoomP2PMediaTransport.connect() does not accept sessionDescription; use room.signals through the built-in transport instead.');
+        }
+        const currentMember = await this.waitForCurrentMember();
+        if (!currentMember) {
+            throw new Error('Join the room before connecting a P2P media transport.');
+        }
+        this.localMemberId = currentMember.memberId;
+        this.connected = true;
+        this.hydrateRemoteTrackKinds();
+        this.attachRoomSubscriptions();
+        try {
+            for (const member of this.room.members.list()) {
+                if (member.memberId !== this.localMemberId) {
+                    this.ensurePeer(member.memberId);
+                }
+            }
+        }
+        catch (error) {
+            this.rollbackConnectedState();
+            throw error;
+        }
+        return this.localMemberId;
+    }
+    async waitForCurrentMember(timeoutMs = DEFAULT_MEMBER_READY_TIMEOUT_MS) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            const member = this.room.members.current();
+            if (member) {
+                return member;
+            }
+            await new Promise((resolve) => globalThis.setTimeout(resolve, 50));
+        }
+        return this.room.members.current();
+    }
+    async enableAudio(constraints = true) {
+        const track = await this.createUserMediaTrack('audio', constraints);
+        if (!track) {
+            throw new Error('P2P transport could not create a local audio track.');
+        }
+        const providerSessionId = await this.ensureConnectedMemberId();
+        this.rememberLocalTrack('audio', track, track.getSettings().deviceId, true);
+        await this.room.media.audio.enable?.({
+            trackId: track.id,
+            deviceId: track.getSettings().deviceId,
+            providerSessionId,
+        });
+        this.syncAllPeerSenders();
+        return track;
+    }
+    async enableVideo(constraints = true) {
+        const track = await this.createUserMediaTrack('video', constraints);
+        if (!track) {
+            throw new Error('P2P transport could not create a local video track.');
+        }
+        const providerSessionId = await this.ensureConnectedMemberId();
+        this.rememberLocalTrack('video', track, track.getSettings().deviceId, true);
+        await this.room.media.video.enable?.({
+            trackId: track.id,
+            deviceId: track.getSettings().deviceId,
+            providerSessionId,
+        });
+        this.syncAllPeerSenders();
+        return track;
+    }
+    async startScreenShare(constraints = { video: true, audio: false }) {
+        const devices = this.options.mediaDevices;
+        if (!devices?.getDisplayMedia) {
+            throw new Error('Screen sharing is not available in this environment.');
+        }
+        const stream = await devices.getDisplayMedia(constraints);
+        const track = stream.getVideoTracks()[0] ?? null;
+        if (!track) {
+            throw new Error('P2P transport could not create a screen-share track.');
+        }
+        track.addEventListener('ended', () => {
+            void this.stopScreenShare();
+        }, { once: true });
+        const providerSessionId = await this.ensureConnectedMemberId();
+        this.rememberLocalTrack('screen', track, track.getSettings().deviceId, true);
+        await this.room.media.screen.start?.({
+            trackId: track.id,
+            deviceId: track.getSettings().deviceId,
+            providerSessionId,
+        });
+        this.syncAllPeerSenders();
+        return track;
+    }
+    async disableAudio() {
+        this.releaseLocalTrack('audio');
+        this.syncAllPeerSenders();
+        await this.room.media.audio.disable();
+    }
+    async disableVideo() {
+        this.releaseLocalTrack('video');
+        this.syncAllPeerSenders();
+        await this.room.media.video.disable();
+    }
+    async stopScreenShare() {
+        this.releaseLocalTrack('screen');
+        this.syncAllPeerSenders();
+        await this.room.media.screen.stop();
+    }
+    async setMuted(kind, muted) {
+        const localTrack = this.localTracks.get(kind)?.track;
+        if (localTrack) {
+            localTrack.enabled = !muted;
+        }
+        if (kind === 'audio') {
+            await this.room.media.audio.setMuted?.(muted);
+        }
+        else {
+            await this.room.media.video.setMuted?.(muted);
+        }
+    }
+    async switchDevices(payload) {
+        if (payload.audioInputId && this.localTracks.has('audio')) {
+            const nextAudioTrack = await this.createUserMediaTrack('audio', buildExactDeviceConstraint(payload.audioInputId));
+            if (nextAudioTrack) {
+                this.rememberLocalTrack('audio', nextAudioTrack, payload.audioInputId, true);
+            }
+        }
+        if (payload.videoInputId && this.localTracks.has('video')) {
+            const nextVideoTrack = await this.createUserMediaTrack('video', buildExactDeviceConstraint(payload.videoInputId));
+            if (nextVideoTrack) {
+                this.rememberLocalTrack('video', nextVideoTrack, payload.videoInputId, true);
+            }
+        }
+        this.syncAllPeerSenders();
+        await this.room.media.devices.switch(payload);
+    }
+    onRemoteTrack(handler) {
+        this.remoteTrackHandlers.push(handler);
+        return createSubscription(() => {
+            const index = this.remoteTrackHandlers.indexOf(handler);
+            if (index >= 0) {
+                this.remoteTrackHandlers.splice(index, 1);
+            }
+        });
+    }
+    destroy() {
+        this.connected = false;
+        this.localMemberId = null;
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.unsubscribe();
+        }
+        for (const peer of this.peers.values()) {
+            this.destroyPeer(peer);
+        }
+        this.peers.clear();
+        for (const kind of Array.from(this.localTracks.keys())) {
+            this.releaseLocalTrack(kind);
+        }
+        this.remoteTrackKinds.clear();
+        this.emittedRemoteTracks.clear();
+        this.pendingRemoteTracks.clear();
+    }
+    attachRoomSubscriptions() {
+        if (this.subscriptions.length > 0) {
+            return;
+        }
+        this.subscriptions.push(this.room.members.onJoin((member) => {
+            if (member.memberId !== this.localMemberId) {
+                this.ensurePeer(member.memberId);
+            }
+        }), this.room.members.onSync((members) => {
+            const activeMemberIds = new Set();
+            for (const member of members) {
+                if (member.memberId !== this.localMemberId) {
+                    activeMemberIds.add(member.memberId);
+                    this.ensurePeer(member.memberId);
+                }
+            }
+            for (const memberId of Array.from(this.peers.keys())) {
+                if (!activeMemberIds.has(memberId)) {
+                    this.removeRemoteMember(memberId);
+                }
+            }
+        }), this.room.members.onLeave((member) => {
+            this.removeRemoteMember(member.memberId);
+        }), this.room.signals.on(this.offerEvent, (payload, meta) => {
+            void this.handleDescriptionSignal('offer', payload, meta);
+        }), this.room.signals.on(this.answerEvent, (payload, meta) => {
+            void this.handleDescriptionSignal('answer', payload, meta);
+        }), this.room.signals.on(this.iceEvent, (payload, meta) => {
+            void this.handleIceSignal(payload, meta);
+        }), this.room.media.onTrack((track, member) => {
+            if (member.memberId !== this.localMemberId) {
+                this.ensurePeer(member.memberId);
+            }
+            this.rememberRemoteTrackKind(track, member);
+        }), this.room.media.onTrackRemoved((track, member) => {
+            if (!track.trackId)
+                return;
+            const key = buildTrackKey(member.memberId, track.trackId);
+            this.remoteTrackKinds.delete(key);
+            this.emittedRemoteTracks.delete(key);
+            this.pendingRemoteTracks.delete(key);
+        }));
+    }
+    hydrateRemoteTrackKinds() {
+        this.remoteTrackKinds.clear();
+        this.emittedRemoteTracks.clear();
+        this.pendingRemoteTracks.clear();
+        for (const mediaMember of this.room.media.list()) {
+            for (const track of mediaMember.tracks) {
+                this.rememberRemoteTrackKind(track, mediaMember.member);
+            }
+        }
+    }
+    rememberRemoteTrackKind(track, member) {
+        if (!track.trackId || member.memberId === this.localMemberId) {
+            return;
+        }
+        const key = buildTrackKey(member.memberId, track.trackId);
+        this.remoteTrackKinds.set(key, track.kind);
+        const pending = this.pendingRemoteTracks.get(key);
+        if (pending) {
+            this.pendingRemoteTracks.delete(key);
+            this.emitRemoteTrack(member.memberId, pending.track, pending.stream, track.kind);
+            return;
+        }
+        this.flushPendingRemoteTracks(member.memberId, track.kind);
+    }
+    ensurePeer(memberId) {
+        const existing = this.peers.get(memberId);
+        if (existing) {
+            this.syncPeerSenders(existing);
+            return existing;
+        }
+        const pc = this.options.peerConnectionFactory(this.options.rtcConfiguration);
+        const peer = {
+            memberId,
+            pc,
+            polite: !!this.localMemberId && this.localMemberId.localeCompare(memberId) > 0,
+            makingOffer: false,
+            ignoreOffer: false,
+            isSettingRemoteAnswerPending: false,
+            pendingCandidates: [],
+            senders: new Map(),
+        };
+        pc.onicecandidate = (event) => {
+            if (!event.candidate)
+                return;
+            void this.room.signals.sendTo(memberId, this.iceEvent, {
+                candidate: serializeCandidate(event.candidate),
+            });
+        };
+        pc.onnegotiationneeded = () => {
+            void this.negotiatePeer(peer);
+        };
+        pc.ontrack = (event) => {
+            const stream = event.streams[0] ?? new MediaStream([event.track]);
+            const key = buildTrackKey(memberId, event.track.id);
+            const exactKind = this.remoteTrackKinds.get(key);
+            const fallbackKind = exactKind ? null : this.resolveFallbackRemoteTrackKind(memberId, event.track);
+            const kind = exactKind ?? fallbackKind ?? normalizeTrackKind(event.track);
+            if (!kind || (!exactKind && !fallbackKind && kind === 'video' && event.track.kind === 'video')) {
+                this.pendingRemoteTracks.set(key, { memberId, track: event.track, stream });
+                return;
+            }
+            this.emitRemoteTrack(memberId, event.track, stream, kind);
+        };
+        this.peers.set(memberId, peer);
+        this.syncPeerSenders(peer);
+        return peer;
+    }
+    async negotiatePeer(peer) {
+        if (!this.connected
+            || peer.pc.connectionState === 'closed'
+            || peer.makingOffer
+            || peer.isSettingRemoteAnswerPending
+            || peer.pc.signalingState !== 'stable') {
+            return;
+        }
+        try {
+            peer.makingOffer = true;
+            await peer.pc.setLocalDescription();
+            if (!peer.pc.localDescription) {
+                return;
+            }
+            await this.room.signals.sendTo(peer.memberId, this.offerEvent, {
+                description: serializeDescription(peer.pc.localDescription),
+            });
+        }
+        catch (error) {
+            console.warn('[RoomP2PMediaTransport] Failed to negotiate peer offer.', {
+                memberId: peer.memberId,
+                signalingState: peer.pc.signalingState,
+                error,
+            });
+        }
+        finally {
+            peer.makingOffer = false;
+        }
+    }
+    async handleDescriptionSignal(expectedType, payload, meta) {
+        const senderId = typeof meta.memberId === 'string' && meta.memberId.trim() ? meta.memberId.trim() : '';
+        if (!senderId || senderId === this.localMemberId) {
+            return;
+        }
+        const description = this.normalizeDescription(payload);
+        if (!description || description.type !== expectedType) {
+            return;
+        }
+        const peer = this.ensurePeer(senderId);
+        const readyForOffer = !peer.makingOffer && (peer.pc.signalingState === 'stable' || peer.isSettingRemoteAnswerPending);
+        const offerCollision = description.type === 'offer' && !readyForOffer;
+        peer.ignoreOffer = !peer.polite && offerCollision;
+        if (peer.ignoreOffer) {
+            return;
+        }
+        try {
+            peer.isSettingRemoteAnswerPending = description.type === 'answer';
+            await peer.pc.setRemoteDescription(description);
+            peer.isSettingRemoteAnswerPending = false;
+            await this.flushPendingCandidates(peer);
+            if (description.type === 'offer') {
+                this.syncPeerSenders(peer);
+                await peer.pc.setLocalDescription();
+                if (!peer.pc.localDescription) {
+                    return;
+                }
+                await this.room.signals.sendTo(senderId, this.answerEvent, {
+                    description: serializeDescription(peer.pc.localDescription),
+                });
+            }
+        }
+        catch (error) {
+            console.warn('[RoomP2PMediaTransport] Failed to apply remote session description.', {
+                memberId: senderId,
+                expectedType,
+                signalingState: peer.pc.signalingState,
+                error,
+            });
+            peer.isSettingRemoteAnswerPending = false;
+        }
+    }
+    async handleIceSignal(payload, meta) {
+        const senderId = typeof meta.memberId === 'string' && meta.memberId.trim() ? meta.memberId.trim() : '';
+        if (!senderId || senderId === this.localMemberId) {
+            return;
+        }
+        const candidate = this.normalizeCandidate(payload);
+        if (!candidate) {
+            return;
+        }
+        const peer = this.ensurePeer(senderId);
+        if (!peer.pc.remoteDescription) {
+            peer.pendingCandidates.push(candidate);
+            return;
+        }
+        try {
+            await peer.pc.addIceCandidate(candidate);
+        }
+        catch (error) {
+            console.warn('[RoomP2PMediaTransport] Failed to add ICE candidate.', {
+                memberId: senderId,
+                error,
+            });
+            if (!peer.ignoreOffer) {
+                peer.pendingCandidates.push(candidate);
+            }
+        }
+    }
+    async flushPendingCandidates(peer) {
+        if (!peer.pc.remoteDescription || peer.pendingCandidates.length === 0) {
+            return;
+        }
+        const pending = [...peer.pendingCandidates];
+        peer.pendingCandidates.length = 0;
+        for (const candidate of pending) {
+            try {
+                await peer.pc.addIceCandidate(candidate);
+            }
+            catch (error) {
+                console.warn('[RoomP2PMediaTransport] Failed to flush pending ICE candidate.', {
+                    memberId: peer.memberId,
+                    error,
+                });
+                if (!peer.ignoreOffer) {
+                    peer.pendingCandidates.push(candidate);
+                }
+            }
+        }
+    }
+    syncAllPeerSenders() {
+        for (const peer of this.peers.values()) {
+            this.syncPeerSenders(peer);
+        }
+    }
+    syncPeerSenders(peer) {
+        const activeKinds = new Set();
+        let changed = false;
+        for (const [kind, localTrack] of this.localTracks.entries()) {
+            activeKinds.add(kind);
+            const sender = peer.senders.get(kind);
+            if (sender) {
+                if (sender.track !== localTrack.track) {
+                    void sender.replaceTrack(localTrack.track);
+                    changed = true;
+                }
+                continue;
+            }
+            const addedSender = peer.pc.addTrack(localTrack.track, new MediaStream([localTrack.track]));
+            peer.senders.set(kind, addedSender);
+            changed = true;
+        }
+        for (const [kind, sender] of Array.from(peer.senders.entries())) {
+            if (activeKinds.has(kind)) {
+                continue;
+            }
+            try {
+                peer.pc.removeTrack(sender);
+            }
+            catch {
+                // Ignore duplicate removals during shutdown.
+            }
+            peer.senders.delete(kind);
+            changed = true;
+        }
+        if (changed) {
+            void this.negotiatePeer(peer);
+        }
+    }
+    emitRemoteTrack(memberId, track, stream, kind) {
+        const key = buildTrackKey(memberId, track.id);
+        if (this.emittedRemoteTracks.has(key)) {
+            return;
+        }
+        this.emittedRemoteTracks.add(key);
+        this.remoteTrackKinds.set(key, kind);
+        const participant = this.findMember(memberId);
+        const payload = {
+            kind,
+            track,
+            stream,
+            trackName: track.id,
+            providerSessionId: memberId,
+            participantId: memberId,
+            userId: participant?.userId,
+        };
+        for (const handler of this.remoteTrackHandlers) {
+            handler(payload);
+        }
+    }
+    resolveFallbackRemoteTrackKind(memberId, track) {
+        const normalizedKind = normalizeTrackKind(track);
+        if (!normalizedKind) {
+            return null;
+        }
+        if (normalizedKind === 'audio') {
+            return 'audio';
+        }
+        return this.getNextUnassignedPublishedVideoLikeKind(memberId);
+    }
+    flushPendingRemoteTracks(memberId, roomKind) {
+        const expectedTrackKind = roomKind === 'audio' ? 'audio' : 'video';
+        for (const [key, pending] of this.pendingRemoteTracks.entries()) {
+            if (pending.memberId !== memberId || pending.track.kind !== expectedTrackKind) {
+                continue;
+            }
+            this.pendingRemoteTracks.delete(key);
+            this.emitRemoteTrack(memberId, pending.track, pending.stream, roomKind);
+            return;
+        }
+    }
+    getPublishedVideoLikeKinds(memberId) {
+        const mediaMember = this.room.media.list().find((entry) => entry.member.memberId === memberId);
+        if (!mediaMember) {
+            return [];
+        }
+        const publishedKinds = new Set();
+        for (const track of mediaMember.tracks) {
+            if ((track.kind === 'video' || track.kind === 'screen') && track.trackId) {
+                publishedKinds.add(track.kind);
+            }
+        }
+        return Array.from(publishedKinds);
+    }
+    getNextUnassignedPublishedVideoLikeKind(memberId) {
+        const publishedKinds = this.getPublishedVideoLikeKinds(memberId);
+        if (publishedKinds.length === 0) {
+            return null;
+        }
+        const assignedKinds = new Set();
+        for (const key of this.emittedRemoteTracks) {
+            if (!key.startsWith(`${memberId}:`)) {
+                continue;
+            }
+            const kind = this.remoteTrackKinds.get(key);
+            if (kind === 'video' || kind === 'screen') {
+                assignedKinds.add(kind);
+            }
+        }
+        return publishedKinds.find((kind) => !assignedKinds.has(kind)) ?? null;
+    }
+    closePeer(memberId) {
+        const peer = this.peers.get(memberId);
+        if (!peer)
+            return;
+        this.destroyPeer(peer);
+        this.peers.delete(memberId);
+    }
+    removeRemoteMember(memberId) {
+        this.remoteTrackKinds.forEach((_kind, key) => {
+            if (key.startsWith(`${memberId}:`)) {
+                this.remoteTrackKinds.delete(key);
+            }
+        });
+        this.emittedRemoteTracks.forEach((key) => {
+            if (key.startsWith(`${memberId}:`)) {
+                this.emittedRemoteTracks.delete(key);
+            }
+        });
+        this.pendingRemoteTracks.forEach((_pending, key) => {
+            if (key.startsWith(`${memberId}:`)) {
+                this.pendingRemoteTracks.delete(key);
+            }
+        });
+        this.closePeer(memberId);
+    }
+    findMember(memberId) {
+        return this.room.members.list().find((member) => member.memberId === memberId);
+    }
+    rollbackConnectedState() {
+        this.connected = false;
+        this.localMemberId = null;
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.unsubscribe();
+        }
+        for (const peer of this.peers.values()) {
+            this.destroyPeer(peer);
+        }
+        this.peers.clear();
+        this.remoteTrackKinds.clear();
+        this.emittedRemoteTracks.clear();
+        this.pendingRemoteTracks.clear();
+    }
+    destroyPeer(peer) {
+        peer.pc.onicecandidate = null;
+        peer.pc.onnegotiationneeded = null;
+        peer.pc.ontrack = null;
+        try {
+            peer.pc.close();
+        }
+        catch {
+            // Ignore duplicate closes.
+        }
+    }
+    async createUserMediaTrack(kind, constraints) {
+        const devices = this.options.mediaDevices;
+        if (!devices?.getUserMedia || constraints === false) {
+            return null;
+        }
+        const stream = await devices.getUserMedia(kind === 'audio'
+            ? { audio: constraints, video: false }
+            : { audio: false, video: constraints });
+        return kind === 'audio' ? stream.getAudioTracks()[0] ?? null : stream.getVideoTracks()[0] ?? null;
+    }
+    rememberLocalTrack(kind, track, deviceId, stopOnCleanup) {
+        this.releaseLocalTrack(kind);
+        this.localTracks.set(kind, {
+            kind,
+            track,
+            deviceId,
+            stopOnCleanup,
+        });
+    }
+    releaseLocalTrack(kind) {
+        const local = this.localTracks.get(kind);
+        if (!local)
+            return;
+        if (local.stopOnCleanup) {
+            local.track.stop();
+        }
+        this.localTracks.delete(kind);
+    }
+    async ensureConnectedMemberId() {
+        if (this.localMemberId) {
+            return this.localMemberId;
+        }
+        return this.connect();
+    }
+    normalizeDescription(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return null;
+        }
+        const raw = payload.description;
+        if (!raw || typeof raw.type !== 'string') {
+            return null;
+        }
+        return {
+            type: raw.type,
+            sdp: typeof raw.sdp === 'string' ? raw.sdp : undefined,
+        };
+    }
+    normalizeCandidate(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return null;
+        }
+        const raw = payload.candidate;
+        if (!raw || typeof raw.candidate !== 'string') {
+            return null;
+        }
+        return raw;
+    }
+    get offerEvent() {
+        return `${this.options.signalPrefix}.offer`;
+    }
+    get answerEvent() {
+        return `${this.options.signalPrefix}.answer`;
+    }
+    get iceEvent() {
+        return `${this.options.signalPrefix}.ice`;
+    }
+}
+//# sourceMappingURL=room-p2p-media.js.map