@noatgnu/cupcake-mint-chocolate 1.2.9 → 1.2.11

package/fesm2022/noatgnu-cupcake-mint-chocolate.mjs

@@ -796,6 +796,7 @@ class WebRTCSignallingService {
         this._peers.next([]);
     }
     sendCheck(peerRole = PeerRole.PARTICIPANT) {
+        console.log('[Signalling] Sending check with role:', peerRole);
         this.send({
             type: 'check',
             peerRole: peerRole
@@ -844,6 +845,7 @@ class WebRTCSignallingService {
         }
     }
     handleMessage(message) {
+        console.log('[Signalling] Received message:', message.type, message);
         switch (message.type) {
             case 'connection.established':
                 this.handleConnectionEstablished(message);
@@ -856,6 +858,7 @@ class WebRTCSignallingService {
             case 'answer':
             case 'ice_candidate':
             case 'peer.state_update':
+                console.log('[Signalling] Forwarding message to WebRTC service:', message.type);
                 this._messages.next(message);
                 break;
             case 'error':
@@ -868,19 +871,26 @@ class WebRTCSignallingService {
     handleConnectionEstablished(message) {
         if (message.peerId) {
             this._peerId.next(message.peerId);
+            console.log('[Signalling] Peer ID assigned:', message.peerId);
         }
         if (message.sessionId) {
             this._sessionId.next(message.sessionId);
+            console.log('[Signalling] Session ID assigned:', message.sessionId);
         }
         if (message.iceServers) {
             this._iceServers.next(message.iceServers);
+            console.log('[Signalling] ICE servers received:', message.iceServers);
         }
-        console.log('WebRTC signalling connection established:', message);
+        console.log('[Signalling] WebRTC connection established:', message);
     }
     handleCheckResponse(message) {
+        console.log('[Signalling] Received check.response with peers:', message.peers);
         if (message.peers) {
             this._peers.next(message.peers);
-            console.log('Received peer list:', message.peers);
+            console.log('[Signalling] Peer list updated, count:', message.peers.length);
+        }
+        else {
+            console.log('[Signalling] No peers in check.response');
         }
     }
     get peerId() {
@@ -914,14 +924,20 @@ class WebRTCService {
     peerConnections = new Map();
     localStream;
     signallingSubscription;
+    fileTransfers = new Map();
+    DEFAULT_CHUNK_SIZE = 16384;
     _localStreamReady = new BehaviorSubject(false);
     _remoteStreams = new BehaviorSubject(new Map());
     _connectionState = new BehaviorSubject('disconnected');
     _activePeers = new BehaviorSubject([]);
+    _chatMessages = new Subject();
+    _fileTransferProgress = new Subject();
     localStreamReady$ = this._localStreamReady.asObservable();
     remoteStreams$ = this._remoteStreams.asObservable();
     connectionState$ = this._connectionState.asObservable();
     activePeers$ = this._activePeers.asObservable();
+    chatMessages$ = this._chatMessages.asObservable();
+    fileTransferProgress$ = this._fileTransferProgress.asObservable();
     defaultConfig = {
         iceServers: [
             { urls: 'stun:stun.l.google.com:19302' },
@@ -956,9 +972,11 @@ class WebRTCService {
             }
         });
         setTimeout(() => {
+            console.log('[WebRTC] Sending peer check with role:', role);
             this.signalling.sendCheck(role);
         }, 1000);
         this.signalling.peers$.subscribe(peers => {
+            console.log('[WebRTC] Peers list updated:', peers);
             this._activePeers.next(peers);
         });
     }
@@ -1030,9 +1048,11 @@ class WebRTCService {
     }
     async handleSignallingMessage(message) {
         try {
+            console.log('[WebRTC] Received signalling message:', message.type, message);
             switch (message.type) {
                 case 'peer.check':
                     if (message.fromPeerId) {
+                        console.log('[WebRTC] Handling peer check from:', message.fromUsername, message.fromPeerId);
                         await this.handlePeerCheck(message.fromPeerId, message.fromUserId, message.fromUsername, message.peerRole);
                     }
                     break;
@@ -1210,6 +1230,7 @@ class WebRTCService {
         };
         dataChannel.onmessage = (event) => {
             console.log(`Data received from peer ${peerId}:`, event.data);
+            this.handleDataChannelMessage(event.data, peerId);
         };
         dataChannel.onclose = () => {
             console.log(`Data channel closed with peer ${peerId}`);
@@ -1218,6 +1239,89 @@ class WebRTCService {
             console.error(`Data channel error with peer ${peerId}:`, error);
         };
     }
+    handleDataChannelMessage(data, peerId) {
+        if (data instanceof ArrayBuffer) {
+            return;
+        }
+        try {
+            const message = JSON.parse(data);
+            this.zone.run(() => {
+                switch (message.type) {
+                    case 'chat':
+                        const chatMessage = message.data;
+                        this._chatMessages.next(chatMessage);
+                        console.log('Chat message received:', chatMessage);
+                        break;
+                    case 'file_request':
+                        this.handleFileRequest(message.data, peerId);
+                        break;
+                    case 'file_accept':
+                        this.handleFileAccept(message.data, peerId);
+                        break;
+                    case 'file_chunk':
+                        this.handleFileChunk(message.data);
+                        break;
+                    case 'file_complete':
+                        this.handleFileComplete(message.data.fileId);
+                        break;
+                    case 'file_cancel':
+                        this.handleFileCancel(message.data.fileId);
+                        break;
+                    case 'ping':
+                        this.sendDataChannelMessage(peerId, { type: 'pong', data: {} });
+                        break;
+                    case 'pong':
+                        console.log(`Received pong from peer ${peerId}`);
+                        break;
+                    default:
+                        console.log('Unknown data channel message type:', message.type);
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error parsing data channel message:', error);
+        }
+    }
+    sendChatMessage(message) {
+        const connection = this.peerConnections.values().next().value;
+        if (!connection) {
+            console.warn('No peer connection available');
+            return;
+        }
+        const chatMessage = {
+            type: 'chat',
+            peerId: this.signalling.peerId || 'unknown',
+            userId: 0,
+            username: 'You',
+            message: message,
+            timestamp: new Date().toISOString()
+        };
+        const dataChannelMessage = {
+            type: 'chat',
+            data: chatMessage
+        };
+        this.peerConnections.forEach((conn) => {
+            this.sendDataChannelMessage(conn.peerId, dataChannelMessage);
+        });
+        this._chatMessages.next(chatMessage);
+    }
+    sendDataChannelMessage(peerId, message) {
+        const connection = this.peerConnections.get(peerId);
+        if (!connection || !connection.dataChannel) {
+            console.warn(`No data channel available for peer ${peerId}`);
+            return;
+        }
+        if (connection.dataChannel.readyState !== 'open') {
+            console.warn(`Data channel not open for peer ${peerId}, state: ${connection.dataChannel.readyState}`);
+            return;
+        }
+        try {
+            connection.dataChannel.send(JSON.stringify(message));
+        }
+        catch (error) {
+            console.error(`Error sending data channel message to peer ${peerId}:`, error);
+        }
+    }
     closePeerConnection(peerId) {
         const connection = this.peerConnections.get(peerId);
         if (!connection)
@@ -1255,6 +1359,353 @@ class WebRTCService {
     updatePeerState(connectionState, hasVideo, hasAudio, hasScreenShare) {
         this.signalling.sendPeerState(connectionState, hasVideo, hasAudio, hasScreenShare);
     }
+    offerFile(file) {
+        const fileId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
+        const chunkSize = this.DEFAULT_CHUNK_SIZE;
+        const totalChunks = Math.ceil(file.size / chunkSize);
+        const fileOffer = {
+            fileId,
+            fileName: file.name,
+            fileSize: file.size,
+            fileType: file.type,
+            chunkSize,
+            totalChunks
+        };
+        const fileTransfer = {
+            fileId,
+            fileName: file.name,
+            fileSize: file.size,
+            fileType: file.type,
+            file,
+            chunks: new Map(),
+            totalChunks,
+            chunkSize,
+            sentChunks: 0,
+            receivedChunks: 0,
+            status: 'pending',
+            requestedBy: new Set()
+        };
+        this.fileTransfers.set(fileId, fileTransfer);
+        const chatMessage = {
+            type: 'chat',
+            peerId: this.signalling.peerId || 'unknown',
+            userId: 0,
+            username: 'You',
+            message: `📎 ${file.name} (${this.formatFileSize(file.size)})`,
+            timestamp: new Date().toISOString(),
+            fileOffer
+        };
+        const dataChannelMessage = {
+            type: 'chat',
+            data: chatMessage
+        };
+        this.peerConnections.forEach((conn) => {
+            this.sendDataChannelMessage(conn.peerId, dataChannelMessage);
+        });
+        this._chatMessages.next(chatMessage);
+        console.log('File offered:', fileOffer);
+    }
+    requestFile(fileId) {
+        const request = {
+            type: 'file_request',
+            fileId,
+            requesterId: this.signalling.peerId || 'unknown'
+        };
+        this.peerConnections.forEach((conn) => {
+            this.sendDataChannelMessage(conn.peerId, {
+                type: 'file_request',
+                data: request
+            });
+        });
+        console.log('File requested:', fileId);
+    }
+    handleFileRequest(request, fromPeerId) {
+        const transfer = this.fileTransfers.get(request.fileId);
+        if (!transfer || !transfer.file) {
+            console.warn('File not found for request:', request.fileId);
+            return;
+        }
+        transfer.requestedBy.add(fromPeerId);
+        transfer.status = 'transferring';
+        const accept = {
+            type: 'file_accept',
+            fileId: request.fileId,
+            toPeerId: request.requesterId
+        };
+        this.sendDataChannelMessage(fromPeerId, {
+            type: 'file_accept',
+            data: accept
+        });
+        this.startSendingFile(request.fileId, fromPeerId);
+    }
+    async handleFileAccept(accept, fromPeerId) {
+        console.log('File transfer accepted:', accept.fileId);
+        const chatMessages = this._chatMessages._buffer || [];
+        const relatedMessage = chatMessages.find((msg) => msg.fileOffer?.fileId === accept.fileId);
+        if (!relatedMessage?.fileOffer) {
+            console.error('Cannot find file offer for accepted transfer:', accept.fileId);
+            return;
+        }
+        const fileOffer = relatedMessage.fileOffer;
+        try {
+            const downloadStream = await this.createFileDownloadStream(fileOffer.fileName);
+            const transfer = {
+                fileId: accept.fileId,
+                fileName: fileOffer.fileName,
+                fileSize: fileOffer.fileSize,
+                fileType: fileOffer.fileType,
+                chunks: new Map(),
+                totalChunks: fileOffer.totalChunks,
+                chunkSize: fileOffer.chunkSize,
+                sentChunks: 0,
+                receivedChunks: 0,
+                status: 'transferring',
+                requestedBy: new Set(),
+                downloadStream: downloadStream,
+                streamWriter: downloadStream.getWriter()
+            };
+            this.fileTransfers.set(accept.fileId, transfer);
+            console.log('Streaming download started for:', fileOffer.fileName);
+        }
+        catch (error) {
+            console.error('Failed to create download stream:', error);
+            const transfer = {
+                fileId: accept.fileId,
+                fileName: fileOffer.fileName,
+                fileSize: fileOffer.fileSize,
+                fileType: fileOffer.fileType,
+                chunks: new Map(),
+                totalChunks: fileOffer.totalChunks,
+                chunkSize: fileOffer.chunkSize,
+                sentChunks: 0,
+                receivedChunks: 0,
+                status: 'transferring',
+                requestedBy: new Set()
+            };
+            this.fileTransfers.set(accept.fileId, transfer);
+            console.log('Fallback to in-memory assembly for:', fileOffer.fileName);
+        }
+    }
+    async createFileDownloadStream(fileName) {
+        if ('showSaveFilePicker' in window) {
+            try {
+                const handle = await window.showSaveFilePicker({
+                    suggestedName: fileName,
+                    types: [{
+                            description: 'File',
+                            accept: { '*/*': [] }
+                        }]
+                });
+                const writable = await handle.createWritable();
+                return writable;
+            }
+            catch (error) {
+                if (error.name === 'AbortError') {
+                    throw new Error('User cancelled file save');
+                }
+                throw error;
+            }
+        }
+        return this.createStreamSaverFallback(fileName);
+    }
+    createStreamSaverFallback(fileName) {
+        let chunks = [];
+        return new WritableStream({
+            write(chunk) {
+                chunks.push(chunk);
+            },
+            close() {
+                const blob = new Blob(chunks);
+                const url = URL.createObjectURL(blob);
+                const a = document.createElement('a');
+                a.href = url;
+                a.download = fileName;
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+                URL.revokeObjectURL(url);
+                chunks = [];
+            },
+            abort(reason) {
+                console.error('Stream aborted:', reason);
+                chunks = [];
+            }
+        });
+    }
+    async startSendingFile(fileId, toPeerId) {
+        const transfer = this.fileTransfers.get(fileId);
+        if (!transfer || !transfer.file) {
+            console.error('File transfer not found:', fileId);
+            return;
+        }
+        const file = transfer.file;
+        let offset = 0;
+        let chunkIndex = 0;
+        while (offset < file.size) {
+            const chunk = file.slice(offset, offset + transfer.chunkSize);
+            const arrayBuffer = await chunk.arrayBuffer();
+            const fileChunk = {
+                type: 'file_chunk',
+                fileId,
+                chunkIndex,
+                totalChunks: transfer.totalChunks,
+                data: arrayBuffer,
+                isLast: offset + transfer.chunkSize >= file.size
+            };
+            const base64Data = this.arrayBufferToBase64(arrayBuffer);
+            this.sendDataChannelMessage(toPeerId, {
+                type: 'file_chunk',
+                data: {
+                    ...fileChunk,
+                    data: base64Data
+                }
+            });
+            transfer.sentChunks++;
+            offset += transfer.chunkSize;
+            chunkIndex++;
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        this.sendDataChannelMessage(toPeerId, {
+            type: 'file_complete',
+            data: { fileId }
+        });
+        console.log('File sending completed:', fileId);
+    }
+    async handleFileChunk(chunk) {
+        const fileId = chunk.fileId;
+        let transfer = this.fileTransfers.get(fileId);
+        if (!transfer) {
+            console.warn('File transfer not found:', fileId);
+            return;
+        }
+        const arrayBuffer = this.base64ToArrayBuffer(chunk.data);
+        const uint8Array = new Uint8Array(arrayBuffer);
+        if (transfer.streamWriter) {
+            try {
+                await transfer.streamWriter.write(uint8Array);
+                console.log(`Streamed chunk ${chunk.chunkIndex + 1}/${transfer.totalChunks} directly to disk`);
+            }
+            catch (error) {
+                console.error('Error writing to stream, falling back to in-memory:', error);
+                transfer.streamWriter = undefined;
+                transfer.chunks.set(chunk.chunkIndex, arrayBuffer);
+            }
+        }
+        else {
+            transfer.chunks.set(chunk.chunkIndex, arrayBuffer);
+        }
+        transfer.receivedChunks++;
+        const progress = {
+            fileId,
+            fileName: transfer.fileName,
+            fileSize: transfer.fileSize,
+            chunksReceived: transfer.receivedChunks,
+            totalChunks: transfer.totalChunks,
+            bytesReceived: transfer.receivedChunks * transfer.chunkSize,
+            percentage: (transfer.receivedChunks / transfer.totalChunks) * 100
+        };
+        this.zone.run(() => {
+            this._fileTransferProgress.next(progress);
+        });
+    }
+    async handleFileComplete(fileId) {
+        const transfer = this.fileTransfers.get(fileId);
+        if (!transfer) {
+            console.warn('File transfer not found:', fileId);
+            return;
+        }
+        transfer.status = 'completed';
+        if (transfer.streamWriter) {
+            try {
+                await transfer.streamWriter.close();
+                console.log('File streamed to disk successfully:', transfer.fileName);
+            }
+            catch (error) {
+                console.error('Error closing stream:', error);
+            }
+        }
+        else {
+            const chunks = [];
+            for (let i = 0; i < transfer.totalChunks; i++) {
+                const chunk = transfer.chunks.get(i);
+                if (chunk) {
+                    chunks.push(chunk);
+                }
+            }
+            const blob = new Blob(chunks, { type: transfer.fileType });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = transfer.fileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+            console.log('File downloaded from memory:', transfer.fileName);
+        }
+        this.fileTransfers.delete(fileId);
+    }
+    async handleFileCancel(fileId) {
+        const transfer = this.fileTransfers.get(fileId);
+        if (transfer) {
+            transfer.status = 'failed';
+            if (transfer.streamWriter) {
+                try {
+                    await transfer.streamWriter.abort('Transfer cancelled');
+                }
+                catch (error) {
+                    console.error('Error aborting stream:', error);
+                }
+            }
+            this.fileTransfers.delete(fileId);
+            console.log('File transfer cancelled:', fileId);
+        }
+    }
+    async cancelFileTransfer(fileId) {
+        const transfer = this.fileTransfers.get(fileId);
+        if (!transfer)
+            return;
+        if (transfer.streamWriter) {
+            try {
+                await transfer.streamWriter.abort('Transfer cancelled by user');
+            }
+            catch (error) {
+                console.error('Error aborting stream:', error);
+            }
+        }
+        this.peerConnections.forEach((conn) => {
+            this.sendDataChannelMessage(conn.peerId, {
+                type: 'file_cancel',
+                data: { fileId }
+            });
+        });
+        this.fileTransfers.delete(fileId);
+        console.log('File transfer cancelled:', fileId);
+    }
+    arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    formatFileSize(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+    }
     get localMediaStream() {
         return this.localStream;
     }
@@ -1287,6 +1738,9 @@ class WebRTCSessionService extends BaseApiService {
     createSession(data) {
         return this.post(`${this.baseUrl}/`, data);
     }
+    updateSession(id, data) {
+        return this.patch(`${this.baseUrl}/${id}/`, data);
+    }
     endSession(id) {
         return this.post(`${this.baseUrl}/${id}/end_session/`, {});
     }