filepizza-client 0.1.0 → 2.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fares Abawi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -18,3 +18,67 @@ The `filepizza-client` API provides bindings to [FilePizza server](https://githu
 ```bash
 npm install filepizza-client
 ```
+
+## Usage
+
+Set up a FilePizza client instance and use it to upload files:
+
+```javascript
+import { FilePizzaUploader } from 'filepizza-client';
+
+const uploader = new FilePizzaUploader({
+  filePizzaServerUrl: 'https://your-filepizza-server.com',
+  // You can optionally specify an additional shared slug where multiple uploaders can connect and share files
+  sharedSlug: 'filepizza-demo'
+});
+
+await uploader.initialize();
+
+uploader.on('progress', (progressInfo) => {
+  console.log(`Upload progress: ${progressInfo.overallProgress * 100}%`);
+});
+
+uploader.setFiles(fileList); // From an input element
+const links = uploader.getShareableLinks();
+console.log(`Shareable links: ${links.join(', ')}`);
+```
+
+Set up a FilePizza client instance and use it to download files:
+
+```javascript
+import { FilePizzaDownloader } from 'filepizza-client';
+
+const downloader = new FilePizzaDownloader({
+  filePizzaServerUrl: 'https://your-filepizza-server.com'
+});
+
+await downloader.initialize();
+
+downloader.on('progress', (progressInfo) => {
+  console.log(`Download progress: ${progressInfo.overallProgress * 100}%`);
+});
+
+await downloader.connect(filePizzaUrl);
+await downloader.startDownload();
+```
+
+## Examples
+
+### Regular Example
+
+Make sure to have the [FilePizza server](https://github.com/TeXlyre/filepizza-server) running locally or specify the server URL in the example code. 
+
+By default, the example uses `https://filepizza.emaily.re` as the demo server URL. This server allows origins from `http://localhost:8081` so you can immediately test the API without requiring to run the server locally. 
+
+*WARNING: The demo server (signaling and TURN as fallback) is not intended for production use and may be subject to rate limits or downtime. For production use, consider setting up your own [FilePizza server](https://github.com/TeXlyre/filepizza-server?tab=readme-ov-file#deployment-with-cloudflare-tunnel).*
+
+To run the vite-bundled example locally, clone the repository and run:
+
+```bash
+npm install
+npm run build:example
+npm run example
+```
+
+Then open `http://localhost:8081` in your browser.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filepizza-client",
-  "version": "0.1.0",
+  "version": "2.0.0-alpha.0",
   "description": "Client API for FilePizza, a free peer-to-peer file transfer service.",
   "author": "Fares Abawi <fares@abawi.me> (https://abawi.me)",
   "license": "MIT",
@@ -11,9 +11,6 @@
   "homepage": "https://texlyre.github.io/filepizza-client/",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "tsc",
     "test": "jest",
@@ -28,7 +25,7 @@
     "web-streams-polyfill": "^3.2.1"
   },
   "peerDependencies": {
-    "next": "^13.0.0",
+    "next": "^14.2.28",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "peerjs": "^1.5.1"
@@ -49,5 +46,20 @@
     "@vitejs/plugin-react": "^4.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
-  }
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "filepizza",
+    "filepizza-server",
+    "filepizza-2.0",
+    "webrtc",
+    "p2p",
+    "peer-to-peer",
+    "file-transfer"
+  ]
 }

package/src/download-helper.ts

@@ -0,0 +1,84 @@
+// src/utils/download-helper.ts
+export class DownloadHelper {
+  private static isNewChromiumBased() {
+    return 'showSaveFilePicker' in window;
+  }
+
+  static async downloadFile(fileName: string, data: Blob | Uint8Array): Promise<void> {
+    const blob = data instanceof Blob ? data : new Blob([data]);
+
+    if (this.isNewChromiumBased()) {
+      await this.downloadWithFileSystemAccessAPI(fileName, blob);
+    } else {
+      this.downloadWithBlobUrl(fileName, blob);
+    }
+  }
+
+  private static async downloadWithFileSystemAccessAPI(fileName: string, blob: Blob): Promise<void> {
+    try {
+      // @ts-ignore - TypeScript may not recognize showSaveFilePicker
+      const fileHandle = await window.showSaveFilePicker({
+        suggestedName: fileName,
+        types: [{
+          description: 'Files',
+          accept: { '*/*': ['.bin'] },
+        }],
+      });
+
+      const writable = await fileHandle.createWritable();
+      await writable.write(blob);
+      await writable.close();
+    } catch (error) {
+      console.error('Error downloading with File System Access API:', error);
+
+      // Fall back to blob URL method if the user cancels or there's an error
+      if (error.name !== 'AbortError') {
+        this.downloadWithBlobUrl(fileName, blob);
+      }
+    }
+  }
+
+  private static downloadWithBlobUrl(fileName: string, blob: Blob): void {
+    const url = URL.createObjectURL(blob);
+
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = fileName;
+    a.style.display = 'none';
+
+    document.body.appendChild(a);
+    a.click();
+
+    setTimeout(() => {
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    }, 100);
+  }
+
+  static async streamToUint8Array(stream: ReadableStream<Uint8Array>): Promise<Uint8Array> {
+    const reader = stream.getReader();
+    const chunks: Uint8Array[] = [];
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    // Combine chunks
+    const totalLength = chunks.reduce((total, chunk) => total + chunk.length, 0);
+    const combinedChunks = new Uint8Array(totalLength);
+
+    let offset = 0;
+    for (const chunk of chunks) {
+      combinedChunks.set(chunk, offset);
+      offset += chunk.length;
+    }
+
+    return combinedChunks;
+  }
+}

package/src/event-emitter.ts

@@ -0,0 +1,71 @@
+// src/utils/event-emitter.ts
+import { EventEmitter as EventEmitterInterface } from './types'
+
+export class EventEmitter implements EventEmitterInterface {
+  private events: Record<string, Array<(...args: any[]) => void>> = {}
+
+  /**
+   * Register an event listener
+   */
+  on(event: string, listener: (...args: any[]) => void): this {
+    if (!this.events[event]) {
+      this.events[event] = []
+    }
+    this.events[event].push(listener)
+    return this
+  }
+
+  /**
+   * Remove an event listener
+   */
+  off(event: string, listener: (...args: any[]) => void): this {
+    if (this.events[event]) {
+      this.events[event] = this.events[event].filter(l => l !== listener)
+    }
+    return this
+  }
+
+  /**
+   * Emit an event
+   */
+  emit(event: string, ...args: any[]): boolean {
+    if (!this.events[event]) {
+      return false
+    }
+
+    this.events[event].forEach(listener => {
+      try {
+        listener(...args)
+      } catch (error) {
+        console.error(`Error in event listener for ${event}:`, error)
+      }
+    })
+
+    return true
+  }
+
+  /**
+   * Register a one-time event listener
+   */
+  once(event: string, listener: (...args: any[]) => void): this {
+    const onceListener = (...args: any[]) => {
+      this.off(event, onceListener)
+      listener(...args)
+    }
+
+    return this.on(event, onceListener)
+  }
+
+  /**
+   * Remove all listeners for an event
+   */
+  removeAllListeners(event?: string): this {
+    if (event) {
+      delete this.events[event]
+    } else {
+      this.events = {}
+    }
+
+    return this
+  }
+}