filepizza-client 0.1.0

package/dist/filepizza-downloader.js

@@ -0,0 +1,687 @@
+// src/filepizza-downloader.ts
+import Peer from 'peerjs';
+import { EventEmitter } from './event-emitter';
+import { DownloadHelper } from './download-helper';
+import { ConnectionStatus, MessageType } from './types';
+/**
+ * FilePizza Downloader - connects to FilePizza uploads
+ */
+export class FilePizzaDownloader extends EventEmitter {
+    /**
+     * Create a new FilePizza downloader
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super();
+        this.filesInfo = [];
+        this.currentFileIndex = 0;
+        this.currentFileBytesReceived = 0;
+        this.totalBytesReceived = 0;
+        this.totalBytes = 0;
+        this.status = ConnectionStatus.Pending;
+        this.fileStreams = new Map();
+        this.isPasswordRequired = false;
+        this.isPasswordInvalid = false;
+        this.completedFiles = [];
+        this.filePizzaServerUrl = options.filePizzaServerUrl || 'http://localhost:8081';
+    }
+    /**
+     * Initialize the downloader
+     */
+    async initialize() {
+        if (this.peer) {
+            return;
+        }
+        // Get ICE servers
+        await this.getIceServers();
+        // Initialize PeerJS
+        this.peer = new Peer({
+            config: {
+                iceServers: this.iceServers || [{ urls: 'stun:stun.l.google.com:19302' }],
+            },
+            debug: 2,
+        });
+        // Wait for peer to be ready
+        if (!this.peer.id) {
+            await new Promise((resolve) => {
+                const onOpen = () => {
+                    this.peer?.off('open', onOpen);
+                    resolve();
+                };
+                this.peer?.on('open', onOpen);
+            });
+        }
+    }
+    /**
+     * Connect to an uploader using a FilePizza URL or slug
+     */
+    async connect(urlOrSlug) {
+        // Extract slug from URL if needed
+        const slug = this.extractSlug(urlOrSlug);
+        try {
+            // Look up the uploader's peer ID
+            const uploaderPeerID = await this.lookupUploaderPeerID(slug);
+            // Now connect directly to the uploader
+            return this.connectToPeer(uploaderPeerID);
+        }
+        catch (error) {
+            this.errorMessage = `Failed to connect: ${error instanceof Error ? error.message : String(error)}`;
+            this.emit('error', this.errorMessage);
+            return false;
+        }
+    }
+    /**
+     * Submit password for protected download
+     */
+    submitPassword(password) {
+        if (!this.connection || this.status !== ConnectionStatus.Authenticating) {
+            throw new Error('Not in authentication state');
+        }
+        this.connection.send({
+            type: MessageType.UsePassword,
+            password,
+        });
+    }
+    /**
+     * Start downloading the files
+     */
+    async startDownload() {
+        // This is just a stub - actual implementation will depend on how you want to save files
+        // The real FilePizza implementation uses the StreamSaver library
+        if (!this.connection) {
+            throw new Error('Not connected');
+        }
+        if (this.filesInfo.length === 0) {
+            throw new Error('No files available');
+        }
+        if (this.status !== ConnectionStatus.Ready) {
+            throw new Error(`Cannot start download in current state: ${this.status}`);
+        }
+        this.status = ConnectionStatus.Downloading;
+        this.currentFileIndex = 0;
+        this.currentFileBytesReceived = 0;
+        this.totalBytesReceived = 0;
+        // Initialize file streams
+        this.initializeFileStreams();
+        // Request the first file
+        this.requestNextFile();
+    }
+    /**
+     * Pause the download
+     */
+    pauseDownload() {
+        if (!this.connection || this.status !== ConnectionStatus.Downloading) {
+            return;
+        }
+        this.connection.send({ type: MessageType.Pause });
+        this.status = ConnectionStatus.Paused;
+        this.emit('paused');
+    }
+    /**
+     * Resume the download
+     */
+    resumeDownload() {
+        if (!this.connection || this.status !== ConnectionStatus.Paused) {
+            return;
+        }
+        const currentFile = this.filesInfo[this.currentFileIndex];
+        this.connection.send({
+            type: MessageType.Resume,
+            fileName: currentFile.fileName,
+            offset: this.currentFileBytesReceived,
+        });
+        this.status = ConnectionStatus.Downloading;
+        this.emit('resumed');
+    }
+    /**
+     * Cancel the download
+     */
+    /**
+     * Cancel the download
+     */
+    cancelDownload() {
+        // Close all file streams
+        for (const fileStreamData of this.fileStreams.values()) {
+            // Check if the stream is already closed before closing it
+            if (fileStreamData.stream.locked) {
+                try {
+                    fileStreamData.close();
+                }
+                catch (error) {
+                    console.warn('Error closing stream:', error);
+                }
+            }
+        }
+        this.fileStreams.clear();
+        // Close the connection
+        if (this.connection) {
+            if (this.connection.open) {
+                this.connection.close();
+            }
+            this.connection = undefined;
+        }
+        this.status = ConnectionStatus.Closed;
+        this.emit('cancelled');
+    }
+    /**
+     * Get file information
+     */
+    getFileInfo() {
+        return this.filesInfo;
+    }
+    /**
+     * Get download status
+     */
+    getStatus() {
+        return {
+            status: this.status,
+            isPasswordRequired: this.isPasswordRequired,
+            isPasswordInvalid: this.isPasswordInvalid,
+            errorMessage: this.errorMessage,
+        };
+    }
+    /**
+     * Get progress information
+     */
+    getProgress() {
+        return {
+            fileIndex: this.currentFileIndex,
+            fileName: this.filesInfo[this.currentFileIndex]?.fileName || '',
+            totalFiles: this.filesInfo.length,
+            currentFileProgress: this.currentFileBytesReceived /
+                (this.filesInfo[this.currentFileIndex]?.size || 1),
+            overallProgress: this.totalBytesReceived / (this.totalBytes || 1),
+            bytesTransferred: this.totalBytesReceived,
+            totalBytes: this.totalBytes,
+        };
+    }
+    /**
+     * Extract slug from URL or use directly
+     */
+    extractSlug(urlOrSlug) {
+        // Check if it's a URL
+        if (urlOrSlug.startsWith('http')) {
+            const url = new URL(urlOrSlug);
+            const pathParts = url.pathname.split('/').filter(Boolean);
+            // Extract the download slug
+            if (pathParts[0] === 'download' && pathParts.length > 1) {
+                return pathParts.slice(1).join('/');
+            }
+            else {
+                throw new Error('Invalid FilePizza URL');
+            }
+        }
+        // If it's not a URL, assume it's already a slug
+        return urlOrSlug;
+    }
+    /**
+     * Extract uploader peer IDs from the FilePizza server when multiple uploaders are present
+     */
+    async extractUploaderPeerIDs(slug) {
+        try {
+            const response = await fetch(`${this.filePizzaServerUrl}/download/${slug}`);
+            if (!response.ok) {
+                throw new Error(`FilePizza server returned ${response.status}`);
+            }
+            const html = await response.text();
+            if (!html || html.trim() === '') {
+                throw new Error('Received empty response from server');
+            }
+            // Match either "uploaderPeerID" (for single uploader) or "primaryUploaderID" and "additionalUploaders" (for multiple)
+            const primaryMatch = html.match(/\\"primaryUploaderID\\":\\"([^\\]+)\\"/);
+            const singleMatch = html.match(/\\"uploaderPeerID\\":\\"([^\\]+)\\"/);
+            if (primaryMatch && primaryMatch[1]) {
+                // Handle multiple uploader case
+                const uploaderIDs = [primaryMatch[1]];
+                // Look for additional uploaders
+                const additionalMatch = html.match(/\\"additionalUploaders\\":\[([^\]]+)\]/);
+                if (additionalMatch && additionalMatch[1]) {
+                    // Parse additional uploader IDs from JSON string
+                    const additionalIDs = additionalMatch[1].split(',')
+                        .map(id => id.trim().replace(/\\"|"/g, ''))
+                        .filter(id => id.length > 0);
+                    uploaderIDs.push(...additionalIDs);
+                }
+                return uploaderIDs;
+            }
+            else if (singleMatch && singleMatch[1]) {
+                // Handle single uploader case
+                return [singleMatch[1]];
+            }
+            throw new Error('Could not find uploader peer ID');
+        }
+        catch (error) {
+            console.error('Error extracting uploader peer IDs:', error);
+            throw new Error('Failed to look up uploader information');
+        }
+    }
+    /**
+     * Look up the uploader's peer ID from the FilePizza server
+     */
+    async lookupUploaderPeerID(slug) {
+        try {
+            const uploaderIDs = await this.extractUploaderPeerIDs(slug);
+            if (uploaderIDs.length === 0) {
+                throw new Error('No uploader peer IDs found');
+            }
+            // Return the first uploader ID by default
+            return uploaderIDs[0];
+        }
+        catch (error) {
+            console.error('Error looking up uploader peer ID:', error);
+            throw new Error('Failed to look up uploader information');
+        }
+    }
+    /**
+     * Connect to a specific uploader by ID
+     */
+    async getAvailableUploaders(urlOrSlug) {
+        const slug = this.extractSlug(urlOrSlug);
+        return this.extractUploaderPeerIDs(slug);
+    }
+    /**
+     * Connect to a specific uploader by ID
+     */
+    async connectToUploader(uploaderId) {
+        try {
+            return this.connectToPeer(uploaderId);
+        }
+        catch (error) {
+            this.errorMessage = `Failed to connect to uploader: ${error instanceof Error ? error.message : String(error)}`;
+            this.emit('error', this.errorMessage);
+            return false;
+        }
+    }
+    /**
+     * Get ICE servers from the FilePizza server
+     */
+    async getIceServers() {
+        try {
+            const response = await fetch(`${this.filePizzaServerUrl}/api/ice`, {
+                method: 'POST',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to get ICE servers: ${response.status}`);
+            }
+            const data = await response.json();
+            this.iceServers = data.iceServers;
+            return data.iceServers;
+        }
+        catch (error) {
+            console.error('Error getting ICE servers:', error);
+            return [{ urls: 'stun:stun.l.google.com:19302' }];
+        }
+    }
+    /**
+     * Connect directly to a peer
+     */
+    async connectToPeer(peerId) {
+        // Make sure we're initialized
+        await this.initialize();
+        if (!this.peer) {
+            throw new Error('Peer not initialized');
+        }
+        try {
+            // Close existing connection if any
+            if (this.connection) {
+                this.connection.close();
+            }
+            // Connect to the uploader
+            this.connection = this.peer.connect(peerId, { reliable: true });
+            this.status = ConnectionStatus.Pending;
+            // Set up connection event handlers
+            return new Promise((resolve) => {
+                if (!this.connection) {
+                    resolve(false);
+                    return;
+                }
+                this.connection.on('open', () => {
+                    this.status = ConnectionStatus.Ready;
+                    // Send request for file info
+                    if (this.connection) {
+                        this.connection.send({
+                            type: MessageType.RequestInfo,
+                            browserName: this.getBrowserName(),
+                            browserVersion: this.getBrowserVersion(),
+                            osName: this.getOSName(),
+                            osVersion: this.getOSVersion(),
+                            mobileVendor: this.getMobileVendor(),
+                            mobileModel: this.getMobileModel(),
+                        });
+                    }
+                    this.emit('connected');
+                    resolve(true);
+                });
+                this.connection.on('data', this.handleData.bind(this));
+                this.connection.on('close', () => {
+                    this.status = ConnectionStatus.Closed;
+                    this.emit('disconnected');
+                });
+                this.connection.on('error', (error) => {
+                    this.errorMessage = `Connection error: ${error.message}`;
+                    this.status = ConnectionStatus.Error;
+                    this.emit('error', this.errorMessage);
+                });
+            });
+        }
+        catch (error) {
+            this.errorMessage = `Failed to connect: ${error instanceof Error ? error.message : String(error)}`;
+            this.emit('error', this.errorMessage);
+            return false;
+        }
+    }
+    /**
+     * Handle incoming data from uploader
+     */
+    handleData(data) {
+        try {
+            // WebRTC messages follow a specific format with a type field
+            const message = data;
+            switch (message.type) {
+                case MessageType.PasswordRequired:
+                    this.handlePasswordRequired(message);
+                    break;
+                case MessageType.Info:
+                    this.handleInfo(message);
+                    break;
+                case MessageType.Chunk:
+                    this.handleChunk(message);
+                    break;
+                case MessageType.Error:
+                    this.handleError(message);
+                    break;
+                case MessageType.Report:
+                    this.handleReport();
+                    break;
+            }
+        }
+        catch (error) {
+            console.error('Error handling message:', error);
+            this.errorMessage = `Error processing data: ${error instanceof Error ? error.message : String(error)}`;
+            this.emit('error', this.errorMessage);
+        }
+    }
+    /**
+     * Handle password required message
+     */
+    handlePasswordRequired(message) {
+        this.isPasswordRequired = true;
+        this.status = ConnectionStatus.Authenticating;
+        if (message.errorMessage) {
+            this.errorMessage = message.errorMessage;
+            this.isPasswordInvalid = true;
+            this.emit('passwordInvalid', message.errorMessage);
+        }
+        else {
+            this.emit('passwordRequired');
+        }
+    }
+    /**
+     * Handle file info message
+     */
+    handleInfo(message) {
+        this.filesInfo = message.files;
+        this.totalBytes = this.filesInfo.reduce((sum, file) => sum + file.size, 0);
+        this.isPasswordRequired = false;
+        this.isPasswordInvalid = false;
+        this.status = ConnectionStatus.Ready;
+        this.emit('info', this.filesInfo);
+    }
+    /**
+     * Handle error message
+     */
+    handleError(message) {
+        this.errorMessage = message.error;
+        this.status = ConnectionStatus.Error;
+        this.emit('error', this.errorMessage);
+    }
+    /**
+     * Handle report message (channel reported for violation)
+     */
+    handleReport() {
+        this.emit('reported');
+        // Redirect to reported page if in browser
+        if (typeof window !== 'undefined') {
+            window.location.href = `${this.filePizzaServerUrl}/reported`;
+        }
+    }
+    /**
+     * Handle chunk message
+     */
+    handleChunk(message) {
+        const { fileName, bytes, final } = message;
+        const fileStream = this.fileStreams.get(fileName);
+        if (!fileStream) {
+            console.error(`No stream found for file: ${fileName}`);
+            return;
+        }
+        // Convert bytes to Uint8Array if needed
+        const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+        // Update progress
+        this.currentFileBytesReceived += data.byteLength;
+        this.totalBytesReceived += data.byteLength;
+        // Add to file stream
+        fileStream.enqueue(data);
+        // Emit progress
+        this.emit('progress', this.getProgress());
+        // Handle file completion
+        if (final) {
+            // Close this file's stream
+            fileStream.close();
+            // Store the completed file
+            this.storeCompletedFile(fileName);
+            // Move to next file if available
+            this.currentFileIndex++;
+            this.currentFileBytesReceived = 0;
+            if (this.currentFileIndex < this.filesInfo.length) {
+                this.requestNextFile();
+            }
+            else {
+                this.status = ConnectionStatus.Done;
+                this.emit('complete', this.completedFiles);
+            }
+        }
+    }
+    /**
+     * Initialize streams for all files
+     */
+    initializeFileStreams() {
+        this.fileStreams.clear();
+        for (const fileInfo of this.filesInfo) {
+            let enqueue = null;
+            let close = null;
+            const stream = new ReadableStream({
+                start(controller) {
+                    enqueue = (chunk) => controller.enqueue(chunk);
+                    close = () => controller.close();
+                },
+            });
+            if (!enqueue || !close) {
+                throw new Error('Failed to initialize stream controllers');
+            }
+            this.fileStreams.set(fileInfo.fileName, {
+                stream,
+                enqueue,
+                close,
+            });
+        }
+    }
+    /**
+     * Store a completed file
+     */
+    async storeCompletedFile(fileName) {
+        const fileStream = this.fileStreams.get(fileName);
+        const fileInfo = this.filesInfo.find(info => info.fileName === fileName);
+        if (!fileStream || !fileInfo) {
+            console.error(`No stream or file info found for file: ${fileName}`);
+            return;
+        }
+        try {
+            // Clone the stream since we're going to use it
+            const [streamToRead, streamToStore] = fileStream.stream.tee();
+            // Convert stream to Uint8Array
+            const fileData = await DownloadHelper.streamToUint8Array(streamToRead);
+            // Store the completed file
+            const completedFile = {
+                ...fileInfo,
+                data: fileData,
+            };
+            this.completedFiles.push(completedFile);
+            // Emit fileComplete event
+            this.emit('fileComplete', completedFile);
+        }
+        catch (error) {
+            console.error(`Error storing file ${fileName}:`, error);
+            this.emit('error', `Failed to store file: ${error.message}`);
+        }
+    }
+    /**
+     * Download a completed file
+     */
+    async downloadFile(fileName) {
+        const completedFile = this.completedFiles.find(file => file.fileName === fileName);
+        if (!completedFile) {
+            throw new Error(`File not found: ${fileName}`);
+        }
+        try {
+            await DownloadHelper.downloadFile(fileName, completedFile.data);
+        }
+        catch (error) {
+            console.error(`Error downloading file ${fileName}:`, error);
+            throw new Error(`Failed to download file: ${error.message}`);
+        }
+    }
+    /**
+     * Get completed files
+     */
+    getCompletedFiles() {
+        return [...this.completedFiles];
+    }
+    /**
+     * Download all completed files
+     */
+    async downloadAllFiles() {
+        for (const file of this.completedFiles) {
+            try {
+                await this.downloadFile(file.fileName);
+            }
+            catch (error) {
+                console.error(`Error downloading file ${file.fileName}:`, error);
+                // Continue with other files even if one fails
+            }
+        }
+    }
+    /**
+     * Request the next file
+     */
+    requestNextFile() {
+        if (!this.connection || this.currentFileIndex >= this.filesInfo.length) {
+            return;
+        }
+        const nextFile = this.filesInfo[this.currentFileIndex];
+        this.connection.send({
+            type: MessageType.Start,
+            fileName: nextFile.fileName,
+            offset: 0,
+        });
+    }
+    // Browser detection helper methods
+    getBrowserName() {
+        if (typeof navigator === 'undefined')
+            return 'unknown';
+        const ua = navigator.userAgent;
+        if (ua.includes('Firefox'))
+            return 'Firefox';
+        if (ua.includes('Chrome'))
+            return 'Chrome';
+        if (ua.includes('Safari'))
+            return 'Safari';
+        if (ua.includes('Edge'))
+            return 'Edge';
+        if (ua.includes('MSIE') || ua.includes('Trident/'))
+            return 'IE';
+        return 'unknown';
+    }
+    getBrowserVersion() {
+        if (typeof navigator === 'undefined')
+            return 'unknown';
+        const ua = navigator.userAgent;
+        let match;
+        if ((match = ua.match(/(Firefox|Chrome|Safari|Edge|MSIE)\/(\d+\.\d+)/))) {
+            return match[2];
+        }
+        if ((match = ua.match(/rv:(\d+\.\d+)/))) {
+            return match[1];
+        }
+        return 'unknown';
+    }
+    getOSName() {
+        if (typeof navigator === 'undefined')
+            return 'unknown';
+        const ua = navigator.userAgent;
+        if (ua.includes('Windows'))
+            return 'Windows';
+        if (ua.includes('Mac OS X'))
+            return 'macOS';
+        if (ua.includes('Linux'))
+            return 'Linux';
+        if (ua.includes('Android'))
+            return 'Android';
+        if (ua.includes('iOS'))
+            return 'iOS';
+        return 'unknown';
+    }
+    getOSVersion() {
+        if (typeof navigator === 'undefined')
+            return 'unknown';
+        const ua = navigator.userAgent;
+        let match;
+        if ((match = ua.match(/Windows NT (\d+\.\d+)/))) {
+            return match[1];
+        }
+        if ((match = ua.match(/Mac OS X (\d+[._]\d+)/))) {
+            return match[1].replace('_', '.');
+        }
+        if ((match = ua.match(/Android (\d+\.\d+)/))) {
+            return match[1];
+        }
+        if ((match = ua.match(/iPhone OS (\d+_\d+)/))) {
+            return match[1].replace('_', '.');
+        }
+        return 'unknown';
+    }
+    getMobileVendor() {
+        if (typeof navigator === 'undefined')
+            return '';
+        const ua = navigator.userAgent;
+        if (ua.includes('iPhone') || ua.includes('iPad'))
+            return 'Apple';
+        if (ua.includes('Samsung'))
+            return 'Samsung';
+        if (ua.includes('Pixel'))
+            return 'Google';
+        if (ua.includes('Huawei'))
+            return 'Huawei';
+        return '';
+    }
+    getMobileModel() {
+        if (typeof navigator === 'undefined')
+            return '';
+        const ua = navigator.userAgent;
+        let match;
+        if ((match = ua.match(/iPhone(\d+),(\d+)/))) {
+            return `iPhone ${match[1]}`;
+        }
+        if ((match = ua.match(/iPad(\d+),(\d+)/))) {
+            return `iPad ${match[1]}`;
+        }
+        if ((match = ua.match(/SM-\w+/))) {
+            return match[0];
+        }
+        if ((match = ua.match(/Pixel \d+/))) {
+            return match[0];
+        }
+        return '';
+    }
+}
+//# sourceMappingURL=filepizza-downloader.js.map