filepizza-client 2.0.1 → 2.1.1

package/src/peerjs.ts

@@ -0,0 +1,147 @@
+// src/peerjs.ts
+import Peer, { PeerOptions } from 'peerjs'
+import { PeerJSSignalingServer } from './types'
+
+const DEFAULT_ICE_SERVERS: RTCIceServer[] = [
+    { urls: 'stun:stun.l.google.com:19302' },
+]
+
+export type PeerJSConfigOptions = {
+    filePizzaServerUrl: string
+    iceServers?: RTCIceServer[]
+    peerJSSignalingServer?: PeerJSSignalingServer
+    discoverPeerJSSignalingServer?: boolean
+}
+
+type IceEndpointResponse = {
+    host?: string
+    path?: string
+    port?: number
+    secure?: boolean
+    servers?: string[]
+    iceServers?: RTCIceServer[]
+}
+
+function normalizeBaseUrl(url: string): string {
+    return url.replace(/\/+$/, '')
+}
+
+function parsePeerJSServerUrl(serverUrlString: string): PeerJSSignalingServer {
+    const serverUrl = new URL(serverUrlString)
+    const secure = serverUrl.protocol === 'https:'
+    return {
+        host: serverUrl.hostname,
+        port: serverUrl.port
+            ? Number.parseInt(serverUrl.port, 10)
+            : secure
+                ? 443
+                : 80,
+        path: serverUrl.pathname,
+        secure,
+    }
+}
+
+const iceCache = new Map<string, Promise<IceEndpointResponse>>()
+
+function fetchIceEndpoint(
+    filePizzaServerUrl: string,
+): Promise<IceEndpointResponse> {
+    const baseUrl = normalizeBaseUrl(filePizzaServerUrl)
+    const cached = iceCache.get(baseUrl)
+    if (cached) {
+        return cached
+    }
+
+    const promise = (async () => {
+        const response = await fetch(`${baseUrl}/api/ice`, { method: 'POST' })
+        if (!response.ok) {
+            throw new Error(`Failed to fetch /api/ice: ${response.status}`)
+        }
+        return (await response.json()) as IceEndpointResponse
+    })()
+
+    promise.catch(() => iceCache.delete(baseUrl))
+    iceCache.set(baseUrl, promise)
+    return promise
+}
+
+export async function getIceServers(
+    filePizzaServerUrl: string,
+): Promise<RTCIceServer[]> {
+    try {
+        const data = await fetchIceEndpoint(filePizzaServerUrl)
+        return data.iceServers || DEFAULT_ICE_SERVERS
+    } catch (error) {
+        console.error('Error getting ICE servers:', error)
+        return DEFAULT_ICE_SERVERS
+    }
+}
+
+export async function discoverPeerJSSignalingServer(
+    filePizzaServerUrl: string,
+): Promise<PeerJSSignalingServer | undefined> {
+    try {
+        const data = await fetchIceEndpoint(filePizzaServerUrl)
+
+        if (data.host) {
+            return {
+                host: data.host,
+                path: data.path,
+                port: data.port,
+                secure: data.secure,
+            }
+        }
+
+        const firstServer = data.servers?.[0]
+        if (!firstServer) {
+            return undefined
+        }
+        return parsePeerJSServerUrl(firstServer)
+    } catch (error) {
+        console.error('Error discovering PeerJS signaling server:', error)
+        return undefined
+    }
+}
+
+export async function buildPeerOptions({
+    filePizzaServerUrl,
+    iceServers,
+    peerJSSignalingServer,
+    discoverPeerJSSignalingServer: shouldDiscover = true,
+}: PeerJSConfigOptions): Promise<PeerOptions> {
+    const resolvedIceServers =
+        iceServers || (await getIceServers(filePizzaServerUrl))
+
+    const discoveredPeerJSSignalingServer =
+        peerJSSignalingServer || shouldDiscover
+            ? peerJSSignalingServer ||
+            (await discoverPeerJSSignalingServer(filePizzaServerUrl))
+            : undefined
+
+    return {
+        ...discoveredPeerJSSignalingServer,
+        config: {
+            iceServers: resolvedIceServers,
+        },
+        debug: 2,
+    }
+}
+
+export async function createPeer(options: PeerJSConfigOptions): Promise<Peer> {
+    const peerOptions = await buildPeerOptions(options)
+    const peer = new Peer(peerOptions)
+
+    if (peer.id) {
+        return peer
+    }
+
+    await new Promise<void>((resolve) => {
+        const onOpen = () => {
+            peer.off('open', onOpen)
+            resolve()
+        }
+        peer.on('open', onOpen)
+    })
+
+    return peer
+}

package/src/types.ts

@@ -1,10 +1,17 @@
-// src/core/types.ts
+// src/types.ts
+import type { PeerOptions } from 'peerjs'
+
 export interface EventEmitter {
-  on(event: string, listener: (...args: any[]) => void): this;
-  off(event: string, listener: (...args: any[]) => void): this;
-  emit(event: string, ...args: any[]): boolean;
+  on(event: string, listener: (...args: any[]) => void): this
+  off(event: string, listener: (...args: any[]) => void): this
+  emit(event: string, ...args: any[]): boolean
 }
 
+export type PeerJSSignalingServer = Pick<
+  PeerOptions,
+  'host' | 'port' | 'path' | 'secure' | 'key' | 'token' | 'pingInterval'
+>
+
 /**
  * Connection status
  */
@@ -18,66 +25,68 @@ export enum ConnectionStatus {
   Authenticating = 'AUTHENTICATING',
   InvalidPassword = 'INVALID_PASSWORD',
   Closed = 'CLOSED',
-  Error = 'ERROR'
+  Error = 'ERROR',
 }
 
 /**
  * File information
  */
 export interface FileInfo {
-  fileName: string;
-  size: number;
-  type: string;
+  fileName: string
+  size: number
+  type: string
 }
 
 /**
  * Interface for a completed file ready to download
  */
 export interface CompletedFile extends FileInfo {
-  data: Uint8Array;
-  downloadUrl?: string;
+  data: Uint8Array
+  downloadUrl?: string
 }
 
 /**
  * Progress information
  */
 export interface ProgressInfo {
-  fileIndex: number;
-  fileName: string;
-  totalFiles: number;
-  currentFileProgress: number;
-  overallProgress: number;
-  bytesTransferred: number;
-  totalBytes: number;
+  fileIndex: number
+  fileName: string
+  totalFiles: number
+  currentFileProgress: number
+  overallProgress: number
+  bytesTransferred: number
+  totalBytes: number
 }
 
 /**
  * Connection information
  */
 export interface ConnectionInfo {
-  id: string;
-  status: ConnectionStatus;
-  browserName?: string;
-  browserVersion?: string;
-  osName?: string;
-  osVersion?: string;
-  mobileVendor?: string;
-  mobileModel?: string;
+  id: string
+  status: ConnectionStatus
+  browserName?: string
+  browserVersion?: string
+  osName?: string
+  osVersion?: string
+  mobileVendor?: string
+  mobileModel?: string
 }
 
 /**
- * Message types for peer-to-peer communication
+ * Message types for peer-to-peer communication.
+ *
+ * This mirrors the server frontend protocol in filepizza-server/src/messages.ts.
  */
 export enum MessageType {
   RequestInfo = 'RequestInfo',
   Info = 'Info',
   Start = 'Start',
   Chunk = 'Chunk',
+  ChunkAck = 'ChunkAck',
   Pause = 'Pause',
-  Resume = 'Resume',
   Done = 'Done',
   Error = 'Error',
   PasswordRequired = 'PasswordRequired',
   UsePassword = 'UsePassword',
   Report = 'Report',
-}
+}