@xtr-dev/rondevu-client 0.0.1 → 0.0.3

package/dist/rondevu.js

@@ -0,0 +1,204 @@
+import { RondevuClient } from './client';
+import { RondevuConnection } from './connection';
+/**
+ * Main Rondevu WebRTC client with automatic connection management
+ */
+export class Rondevu {
+    /**
+     * Creates a new Rondevu client instance
+     * @param options - Client configuration options
+     */
+    constructor(options) {
+        this.client = new RondevuClient({
+            baseUrl: options.baseUrl,
+            origin: options.origin,
+            fetch: options.fetch,
+        });
+        // Auto-generate peer ID if not provided
+        this.peerId = options.peerId || this.generatePeerId();
+        this.rtcConfig = options.rtcConfig;
+        this.pollingInterval = options.pollingInterval || 1000;
+        this.connectionTimeout = options.connectionTimeout || 30000;
+    }
+    /**
+     * Generate a unique peer ID
+     */
+    generatePeerId() {
+        return `rdv_${Math.random().toString(36).substring(2, 14)}`;
+    }
+    /**
+     * Update the peer ID (useful when user identity changes)
+     */
+    updatePeerId(newPeerId) {
+        this.peerId = newPeerId;
+    }
+    /**
+     * Create a new connection (offerer role)
+     * @param id - Connection identifier
+     * @param topic - Topic name for grouping connections
+     * @returns Promise that resolves to RondevuConnection
+     */
+    async create(id, topic) {
+        // Create peer connection
+        const pc = new RTCPeerConnection(this.rtcConfig);
+        // Create initial data channel for negotiation (required for offer creation)
+        pc.createDataChannel('_negotiation');
+        // Generate offer
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        // Wait for ICE gathering to complete
+        await this.waitForIceGathering(pc);
+        // Create session on server with custom code
+        await this.client.createOffer(topic, {
+            peerId: this.peerId,
+            offer: pc.localDescription.sdp,
+            code: id,
+        });
+        // Create connection object
+        const connectionParams = {
+            id,
+            topic,
+            role: 'offerer',
+            pc,
+            localPeerId: this.peerId,
+            remotePeerId: '', // Will be populated when answer is received
+            pollingInterval: this.pollingInterval,
+            connectionTimeout: this.connectionTimeout,
+        };
+        const connection = new RondevuConnection(connectionParams, this.client);
+        // Start polling for answer
+        connection.startPolling();
+        return connection;
+    }
+    /**
+     * Connect to an existing connection by ID (answerer role)
+     * @param id - Connection identifier
+     * @returns Promise that resolves to RondevuConnection
+     */
+    async connect(id) {
+        // Poll server to get session by ID
+        const sessionData = await this.findSessionById(id);
+        if (!sessionData) {
+            throw new Error(`Connection ${id} not found or expired`);
+        }
+        // Create peer connection
+        const pc = new RTCPeerConnection(this.rtcConfig);
+        // Set remote offer
+        await pc.setRemoteDescription({
+            type: 'offer',
+            sdp: sessionData.offer,
+        });
+        // Generate answer
+        const answer = await pc.createAnswer();
+        await pc.setLocalDescription(answer);
+        // Wait for ICE gathering
+        await this.waitForIceGathering(pc);
+        // Send answer to server
+        await this.client.sendAnswer({
+            code: id,
+            answer: pc.localDescription.sdp,
+            side: 'answerer',
+        });
+        // Create connection object
+        const connectionParams = {
+            id,
+            topic: sessionData.topic || 'unknown',
+            role: 'answerer',
+            pc,
+            localPeerId: this.peerId,
+            remotePeerId: sessionData.peerId,
+            pollingInterval: this.pollingInterval,
+            connectionTimeout: this.connectionTimeout,
+        };
+        const connection = new RondevuConnection(connectionParams, this.client);
+        // Start polling for ICE candidates
+        connection.startPolling();
+        return connection;
+    }
+    /**
+     * Join a topic and discover available peers (answerer role)
+     * @param topic - Topic name
+     * @param options - Optional join options for filtering and selection
+     * @returns Promise that resolves to RondevuConnection
+     */
+    async join(topic, options) {
+        // List sessions in topic
+        const { sessions } = await this.client.listSessions(topic);
+        // Filter out self (sessions with our peer ID)
+        let availableSessions = sessions.filter(session => session.peerId !== this.peerId);
+        // Apply custom filter if provided
+        if (options?.filter) {
+            availableSessions = availableSessions.filter(options.filter);
+        }
+        if (availableSessions.length === 0) {
+            throw new Error(`No available peers in topic: ${topic}`);
+        }
+        // Select session based on strategy
+        const selectedSession = this.selectSession(availableSessions, options?.select || 'first');
+        // Connect to selected session
+        return this.connect(selectedSession.code);
+    }
+    /**
+     * Select a session based on strategy
+     */
+    selectSession(sessions, strategy) {
+        switch (strategy) {
+            case 'first':
+                return sessions[0];
+            case 'newest':
+                return sessions.reduce((newest, session) => session.createdAt > newest.createdAt ? session : newest);
+            case 'oldest':
+                return sessions.reduce((oldest, session) => session.createdAt < oldest.createdAt ? session : oldest);
+            case 'random':
+                return sessions[Math.floor(Math.random() * sessions.length)];
+            default:
+                return sessions[0];
+        }
+    }
+    /**
+     * Wait for ICE gathering to complete
+     */
+    async waitForIceGathering(pc) {
+        if (pc.iceGatheringState === 'complete') {
+            return;
+        }
+        return new Promise((resolve) => {
+            const checkState = () => {
+                if (pc.iceGatheringState === 'complete') {
+                    pc.removeEventListener('icegatheringstatechange', checkState);
+                    resolve();
+                }
+            };
+            pc.addEventListener('icegatheringstatechange', checkState);
+            // Also set a timeout in case gathering takes too long
+            setTimeout(() => {
+                pc.removeEventListener('icegatheringstatechange', checkState);
+                resolve();
+            }, 5000);
+        });
+    }
+    /**
+     * Find a session by connection ID
+     * This requires polling since we don't know which topic it's in
+     */
+    async findSessionById(id) {
+        try {
+            // Try to poll for the session directly
+            // The poll endpoint should return the session data
+            const response = await this.client.poll(id, 'answerer');
+            const answererResponse = response;
+            if (answererResponse.offer) {
+                return {
+                    code: id,
+                    peerId: '', // Will be populated from session data
+                    offer: answererResponse.offer,
+                    topic: undefined,
+                };
+            }
+            return null;
+        }
+        catch (err) {
+            throw new Error(`Failed to find session ${id}: ${err.message}`);
+        }
+    }
+}

package/dist/types.d.ts

@@ -9,7 +9,7 @@ export interface Session {
     /** Unique session identifier (UUID) */
     code: string;
     /** Peer identifier/metadata */
-    info: string;
+    peerId: string;
     /** Signaling data for peer connection */
     offer: string;
     /** Additional signaling data from offerer */
@@ -59,9 +59,11 @@ export interface ListSessionsResponse {
  */
 export interface CreateOfferRequest {
     /** Peer identifier/metadata (max 1024 characters) */
-    info: string;
+    peerId: string;
     /** Signaling data for peer connection */
     offer: string;
+    /** Optional custom connection code (if not provided, server generates UUID) */
+    code?: string;
 }
 /**
  * Response from POST /:topic/offer
@@ -144,3 +146,61 @@ export interface RondevuClientOptions {
     /** Optional fetch implementation (for Node.js environments) */
     fetch?: typeof fetch;
 }
+/**
+ * Configuration options for Rondevu WebRTC client
+ */
+export interface RondevuOptions {
+    /** Base URL of the Rondevu server (e.g., 'https://example.com') */
+    baseUrl: string;
+    /** Peer identifier (optional, auto-generated if not provided) */
+    peerId?: string;
+    /** Origin header value for session isolation (defaults to baseUrl origin) */
+    origin?: string;
+    /** Optional fetch implementation (for Node.js environments) */
+    fetch?: typeof fetch;
+    /** WebRTC configuration (ICE servers, etc.) */
+    rtcConfig?: RTCConfiguration;
+    /** Polling interval in milliseconds (default: 1000) */
+    pollingInterval?: number;
+    /** Connection timeout in milliseconds (default: 30000) */
+    connectionTimeout?: number;
+}
+/**
+ * Options for joining a topic
+ */
+export interface JoinOptions {
+    /** Filter function to select specific sessions */
+    filter?: (session: {
+        code: string;
+        peerId: string;
+    }) => boolean;
+    /** Selection strategy for choosing a session */
+    select?: 'first' | 'newest' | 'oldest' | 'random';
+}
+/**
+ * Connection role - whether this peer is creating or answering
+ */
+export type ConnectionRole = 'offerer' | 'answerer';
+/**
+ * Parameters for creating a RondevuConnection
+ */
+export interface RondevuConnectionParams {
+    id: string;
+    topic: string;
+    role: ConnectionRole;
+    pc: RTCPeerConnection;
+    localPeerId: string;
+    remotePeerId: string;
+    pollingInterval: number;
+    connectionTimeout: number;
+}
+/**
+ * Event map for RondevuConnection events
+ */
+export interface RondevuConnectionEvents {
+    connect: () => void;
+    disconnect: () => void;
+    error: (error: Error) => void;
+    datachannel: (channel: RTCDataChannel) => void;
+    stream: (stream: MediaStream) => void;
+}

package/dist/types.js

@@ -1,2 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+// ============================================================================
+// Signaling Types
+// ============================================================================
+export {};

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "TypeScript client for Rondevu peer signaling and discovery server",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {