@xtr-dev/rondevu-client 0.0.1 → 0.0.3

package/dist/client.d.ts

@@ -40,22 +40,22 @@ export declare class RondevuClient {
      * ```typescript
      * const client = new RondevuClient({ baseUrl: 'https://example.com' });
      * const { sessions } = await client.listSessions('my-room');
-     * const otherPeers = sessions.filter(s => s.info !== myPeerId);
+     * const otherPeers = sessions.filter(s => s.peerId !== myPeerId);
      * ```
      */
     listSessions(topic: string): Promise<ListSessionsResponse>;
     /**
      * Announces peer availability and creates a new session
      *
-     * @param topic - Topic identifier for grouping peers (max 256 characters)
-     * @param request - Offer details including peer info and signaling data
+     * @param topic - Topic identifier for grouping peers (max 1024 characters)
+     * @param request - Offer details including peer ID and signaling data
      * @returns Unique session code (UUID)
      *
      * @example
      * ```typescript
      * const client = new RondevuClient({ baseUrl: 'https://example.com' });
      * const { code } = await client.createOffer('my-room', {
-     *   info: 'peer-123',
+     *   peerId: 'peer-123',
      *   offer: signalingData
      * });
      * console.log('Session code:', code);

package/dist/client.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RondevuClient = void 0;
 /**
  * HTTP client for Rondevu peer signaling and discovery server
  */
-class RondevuClient {
+export class RondevuClient {
     /**
      * Creates a new Rondevu client instance
      * @param options - Client configuration options
@@ -12,7 +9,7 @@ class RondevuClient {
     constructor(options) {
         this.baseUrl = options.baseUrl.replace(/\/$/, ''); // Remove trailing slash
         this.origin = options.origin || new URL(this.baseUrl).origin;
-        this.fetchImpl = options.fetch || fetch;
+        this.fetchImpl = options.fetch || globalThis.fetch.bind(globalThis);
     }
     /**
      * Makes an HTTP request to the Rondevu server
@@ -70,7 +67,7 @@ class RondevuClient {
      * ```typescript
      * const client = new RondevuClient({ baseUrl: 'https://example.com' });
      * const { sessions } = await client.listSessions('my-room');
-     * const otherPeers = sessions.filter(s => s.info !== myPeerId);
+     * const otherPeers = sessions.filter(s => s.peerId !== myPeerId);
      * ```
      */
     async listSessions(topic) {
@@ -81,15 +78,15 @@ class RondevuClient {
     /**
      * Announces peer availability and creates a new session
      *
-     * @param topic - Topic identifier for grouping peers (max 256 characters)
-     * @param request - Offer details including peer info and signaling data
+     * @param topic - Topic identifier for grouping peers (max 1024 characters)
+     * @param request - Offer details including peer ID and signaling data
      * @returns Unique session code (UUID)
      *
      * @example
      * ```typescript
      * const client = new RondevuClient({ baseUrl: 'https://example.com' });
      * const { code } = await client.createOffer('my-room', {
-     *   info: 'peer-123',
+     *   peerId: 'peer-123',
      *   offer: signalingData
      * });
      * console.log('Session code:', code);
@@ -179,4 +176,3 @@ class RondevuClient {
         });
     }
 }
-exports.RondevuClient = RondevuClient;

package/dist/connection.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from './event-emitter';
+import { RondevuClient } from './client';
+import { RondevuConnectionParams } from './types';
+/**
+ * Represents a WebRTC connection with automatic signaling and ICE exchange
+ */
+export declare class RondevuConnection extends EventEmitter {
+    readonly id: string;
+    readonly topic: string;
+    readonly role: 'offerer' | 'answerer';
+    readonly remotePeerId: string;
+    private pc;
+    private client;
+    private localPeerId;
+    private dataChannels;
+    private pollingInterval?;
+    private pollingIntervalMs;
+    private connectionTimeoutMs;
+    private connectionTimer?;
+    private isPolling;
+    private isClosed;
+    constructor(params: RondevuConnectionParams, client: RondevuClient);
+    /**
+     * Setup RTCPeerConnection event handlers
+     */
+    private setupEventHandlers;
+    /**
+     * Handle RTCPeerConnection state changes
+     */
+    private handleConnectionStateChange;
+    /**
+     * Send an ICE candidate to the remote peer via signaling server
+     */
+    private sendIceCandidate;
+    /**
+     * Start polling for remote session data (answer/candidates)
+     */
+    startPolling(): void;
+    /**
+     * Stop polling
+     */
+    private stopPolling;
+    /**
+     * Poll the signaling server for remote data
+     */
+    private poll;
+    /**
+     * Handle remotely created data channel
+     */
+    private handleRemoteDataChannel;
+    /**
+     * Get or create a data channel
+     */
+    dataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
+    /**
+     * Add a local media stream to the connection
+     */
+    addStream(stream: MediaStream): void;
+    /**
+     * Get the underlying RTCPeerConnection for advanced usage
+     */
+    getPeerConnection(): RTCPeerConnection;
+    /**
+     * Start connection timeout
+     */
+    private startConnectionTimeout;
+    /**
+     * Clear connection timeout
+     */
+    private clearConnectionTimeout;
+    /**
+     * Close the connection and cleanup resources
+     */
+    close(): void;
+}

package/dist/connection.js

@@ -0,0 +1,260 @@
+import { EventEmitter } from './event-emitter';
+/**
+ * Represents a WebRTC connection with automatic signaling and ICE exchange
+ */
+export class RondevuConnection extends EventEmitter {
+    constructor(params, client) {
+        super();
+        this.isPolling = false;
+        this.isClosed = false;
+        this.id = params.id;
+        this.topic = params.topic;
+        this.role = params.role;
+        this.pc = params.pc;
+        this.localPeerId = params.localPeerId;
+        this.remotePeerId = params.remotePeerId;
+        this.client = client;
+        this.dataChannels = new Map();
+        this.pollingIntervalMs = params.pollingInterval;
+        this.connectionTimeoutMs = params.connectionTimeout;
+        this.setupEventHandlers();
+        this.startConnectionTimeout();
+    }
+    /**
+     * Setup RTCPeerConnection event handlers
+     */
+    setupEventHandlers() {
+        // ICE candidate gathering
+        this.pc.onicecandidate = (event) => {
+            if (event.candidate && !this.isClosed) {
+                this.sendIceCandidate(event.candidate).catch((err) => {
+                    this.emit('error', new Error(`Failed to send ICE candidate: ${err.message}`));
+                });
+            }
+        };
+        // Connection state changes
+        this.pc.onconnectionstatechange = () => {
+            this.handleConnectionStateChange();
+        };
+        // Remote data channels
+        this.pc.ondatachannel = (event) => {
+            this.handleRemoteDataChannel(event.channel);
+        };
+        // Remote media streams
+        this.pc.ontrack = (event) => {
+            if (event.streams && event.streams[0]) {
+                this.emit('stream', event.streams[0]);
+            }
+        };
+        // ICE connection state changes
+        this.pc.oniceconnectionstatechange = () => {
+            const state = this.pc.iceConnectionState;
+            if (state === 'failed' || state === 'closed') {
+                this.emit('error', new Error(`ICE connection ${state}`));
+                if (state === 'failed') {
+                    this.close();
+                }
+            }
+        };
+    }
+    /**
+     * Handle RTCPeerConnection state changes
+     */
+    handleConnectionStateChange() {
+        const state = this.pc.connectionState;
+        switch (state) {
+            case 'connected':
+                this.clearConnectionTimeout();
+                this.stopPolling();
+                this.emit('connect');
+                break;
+            case 'disconnected':
+                this.emit('disconnect');
+                break;
+            case 'failed':
+                this.emit('error', new Error('Connection failed'));
+                this.close();
+                break;
+            case 'closed':
+                this.emit('disconnect');
+                break;
+        }
+    }
+    /**
+     * Send an ICE candidate to the remote peer via signaling server
+     */
+    async sendIceCandidate(candidate) {
+        try {
+            await this.client.sendAnswer({
+                code: this.id,
+                candidate: JSON.stringify(candidate.toJSON()),
+                side: this.role,
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to send ICE candidate: ${err.message}`);
+        }
+    }
+    /**
+     * Start polling for remote session data (answer/candidates)
+     */
+    startPolling() {
+        if (this.isPolling || this.isClosed) {
+            return;
+        }
+        this.isPolling = true;
+        // Poll immediately
+        this.poll().catch((err) => {
+            this.emit('error', new Error(`Poll error: ${err.message}`));
+        });
+        // Set up interval polling
+        this.pollingInterval = setInterval(() => {
+            this.poll().catch((err) => {
+                this.emit('error', new Error(`Poll error: ${err.message}`));
+            });
+        }, this.pollingIntervalMs);
+    }
+    /**
+     * Stop polling
+     */
+    stopPolling() {
+        this.isPolling = false;
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    /**
+     * Poll the signaling server for remote data
+     */
+    async poll() {
+        if (this.isClosed) {
+            this.stopPolling();
+            return;
+        }
+        try {
+            const response = await this.client.poll(this.id, this.role);
+            if (this.role === 'offerer') {
+                const offererResponse = response;
+                // Apply answer if received and not yet applied
+                if (offererResponse.answer && !this.pc.currentRemoteDescription) {
+                    await this.pc.setRemoteDescription({
+                        type: 'answer',
+                        sdp: offererResponse.answer,
+                    });
+                }
+                // Apply ICE candidates
+                if (offererResponse.answerCandidates && offererResponse.answerCandidates.length > 0) {
+                    for (const candidateStr of offererResponse.answerCandidates) {
+                        try {
+                            const candidate = JSON.parse(candidateStr);
+                            await this.pc.addIceCandidate(new RTCIceCandidate(candidate));
+                        }
+                        catch (err) {
+                            console.warn('Failed to add ICE candidate:', err);
+                        }
+                    }
+                }
+            }
+            else {
+                // Answerer role
+                const answererResponse = response;
+                // Apply ICE candidates from offerer
+                if (answererResponse.offerCandidates && answererResponse.offerCandidates.length > 0) {
+                    for (const candidateStr of answererResponse.offerCandidates) {
+                        try {
+                            const candidate = JSON.parse(candidateStr);
+                            await this.pc.addIceCandidate(new RTCIceCandidate(candidate));
+                        }
+                        catch (err) {
+                            console.warn('Failed to add ICE candidate:', err);
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Session not found or expired
+            if (err.message.includes('404') || err.message.includes('not found')) {
+                this.emit('error', new Error('Session not found or expired'));
+                this.close();
+            }
+            throw err;
+        }
+    }
+    /**
+     * Handle remotely created data channel
+     */
+    handleRemoteDataChannel(channel) {
+        this.dataChannels.set(channel.label, channel);
+        this.emit('datachannel', channel);
+    }
+    /**
+     * Get or create a data channel
+     */
+    dataChannel(label, options) {
+        let channel = this.dataChannels.get(label);
+        if (!channel) {
+            channel = this.pc.createDataChannel(label, options);
+            this.dataChannels.set(label, channel);
+        }
+        return channel;
+    }
+    /**
+     * Add a local media stream to the connection
+     */
+    addStream(stream) {
+        stream.getTracks().forEach(track => {
+            this.pc.addTrack(track, stream);
+        });
+    }
+    /**
+     * Get the underlying RTCPeerConnection for advanced usage
+     */
+    getPeerConnection() {
+        return this.pc;
+    }
+    /**
+     * Start connection timeout
+     */
+    startConnectionTimeout() {
+        this.connectionTimer = setTimeout(() => {
+            if (this.pc.connectionState !== 'connected') {
+                this.emit('error', new Error('Connection timeout'));
+                this.close();
+            }
+        }, this.connectionTimeoutMs);
+    }
+    /**
+     * Clear connection timeout
+     */
+    clearConnectionTimeout() {
+        if (this.connectionTimer) {
+            clearTimeout(this.connectionTimer);
+            this.connectionTimer = undefined;
+        }
+    }
+    /**
+     * Close the connection and cleanup resources
+     */
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        this.stopPolling();
+        this.clearConnectionTimeout();
+        // Close all data channels
+        this.dataChannels.forEach(dc => {
+            if (dc.readyState === 'open' || dc.readyState === 'connecting') {
+                dc.close();
+            }
+        });
+        this.dataChannels.clear();
+        // Close peer connection
+        if (this.pc.connectionState !== 'closed') {
+            this.pc.close();
+        }
+        this.emit('disconnect');
+    }
+}

package/dist/event-emitter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Simple EventEmitter implementation for browser and Node.js compatibility
+ */
+export declare class EventEmitter {
+    private events;
+    constructor();
+    /**
+     * Register an event listener
+     */
+    on(event: string, listener: Function): this;
+    /**
+     * Register a one-time event listener
+     */
+    once(event: string, listener: Function): this;
+    /**
+     * Remove an event listener
+     */
+    off(event: string, listener: Function): this;
+    /**
+     * Emit an event
+     */
+    emit(event: string, ...args: any[]): boolean;
+    /**
+     * Remove all listeners for an event (or all events if not specified)
+     */
+    removeAllListeners(event?: string): this;
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event: string): number;
+}

package/dist/event-emitter.js

@@ -0,0 +1,78 @@
+/**
+ * Simple EventEmitter implementation for browser and Node.js compatibility
+ */
+export class EventEmitter {
+    constructor() {
+        this.events = new Map();
+    }
+    /**
+     * Register an event listener
+     */
+    on(event, listener) {
+        if (!this.events.has(event)) {
+            this.events.set(event, new Set());
+        }
+        this.events.get(event).add(listener);
+        return this;
+    }
+    /**
+     * Register a one-time event listener
+     */
+    once(event, listener) {
+        const onceWrapper = (...args) => {
+            this.off(event, onceWrapper);
+            listener.apply(this, args);
+        };
+        return this.on(event, onceWrapper);
+    }
+    /**
+     * Remove an event listener
+     */
+    off(event, listener) {
+        const listeners = this.events.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.events.delete(event);
+            }
+        }
+        return this;
+    }
+    /**
+     * Emit an event
+     */
+    emit(event, ...args) {
+        const listeners = this.events.get(event);
+        if (!listeners || listeners.size === 0) {
+            return false;
+        }
+        listeners.forEach(listener => {
+            try {
+                listener.apply(this, args);
+            }
+            catch (err) {
+                console.error(`Error in ${event} event listener:`, err);
+            }
+        });
+        return true;
+    }
+    /**
+     * Remove all listeners for an event (or all events if not specified)
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+        return this;
+    }
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event) {
+        const listeners = this.events.get(event);
+        return listeners ? listeners.size : 0;
+    }
+}

package/dist/index.d.ts

@@ -1,30 +1,8 @@
 /**
- * TypeScript client for Rondevu peer signaling server
- *
- * @example
- * ```typescript
- * import { RondevuClient } from '@xtr-dev/rondevu-client';
- *
- * const client = new RondevuClient({
- *   baseUrl: 'https://rondevu.example.com'
- * });
- *
- * // Create an offer
- * const { code } = await client.createOffer('my-room', {
- *   info: 'peer-123',
- *   offer: signalingData
- * });
- *
- * // Discover peers
- * const { sessions } = await client.listSessions('my-room');
- *
- * // Send answer
- * await client.sendAnswer({
- *   code: sessions[0].code,
- *   answer: answerData,
- *   side: 'answerer'
- * });
- * ```
+ * @xtr-dev/rondevu-client
+ * WebRTC peer signaling and discovery client
  */
+export { Rondevu } from './rondevu';
+export { RondevuConnection } from './connection';
 export { RondevuClient } from './client';
-export * from './types';
+export type { RondevuOptions, JoinOptions, ConnectionRole, RondevuConnectionParams, RondevuConnectionEvents, Side, Session, TopicInfo, Pagination, ListTopicsResponse, ListSessionsResponse, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollRequest, PollOffererResponse, PollAnswererResponse, PollResponse, HealthResponse, ErrorResponse, RondevuClientOptions, } from './types';

package/dist/index.js

@@ -1,48 +1,10 @@
-"use strict";
 /**
- * TypeScript client for Rondevu peer signaling server
- *
- * @example
- * ```typescript
- * import { RondevuClient } from '@xtr-dev/rondevu-client';
- *
- * const client = new RondevuClient({
- *   baseUrl: 'https://rondevu.example.com'
- * });
- *
- * // Create an offer
- * const { code } = await client.createOffer('my-room', {
- *   info: 'peer-123',
- *   offer: signalingData
- * });
- *
- * // Discover peers
- * const { sessions } = await client.listSessions('my-room');
- *
- * // Send answer
- * await client.sendAnswer({
- *   code: sessions[0].code,
- *   answer: answerData,
- *   side: 'answerer'
- * });
- * ```
+ * @xtr-dev/rondevu-client
+ * WebRTC peer signaling and discovery client
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RondevuClient = void 0;
-var client_1 = require("./client");
-Object.defineProperty(exports, "RondevuClient", { enumerable: true, get: function () { return client_1.RondevuClient; } });
-__exportStar(require("./types"), exports);
+// Export main WebRTC client class
+export { Rondevu } from './rondevu';
+// Export connection class
+export { RondevuConnection } from './connection';
+// Export low-level signaling client (for advanced usage)
+export { RondevuClient } from './client';

package/dist/rondevu.d.ts

@@ -0,0 +1,58 @@
+import { RondevuConnection } from './connection';
+import { RondevuOptions, JoinOptions } from './types';
+/**
+ * Main Rondevu WebRTC client with automatic connection management
+ */
+export declare class Rondevu {
+    readonly peerId: string;
+    private client;
+    private rtcConfig?;
+    private pollingInterval;
+    private connectionTimeout;
+    /**
+     * Creates a new Rondevu client instance
+     * @param options - Client configuration options
+     */
+    constructor(options: RondevuOptions);
+    /**
+     * Generate a unique peer ID
+     */
+    private generatePeerId;
+    /**
+     * Update the peer ID (useful when user identity changes)
+     */
+    updatePeerId(newPeerId: string): void;
+    /**
+     * Create a new connection (offerer role)
+     * @param id - Connection identifier
+     * @param topic - Topic name for grouping connections
+     * @returns Promise that resolves to RondevuConnection
+     */
+    create(id: string, topic: string): Promise<RondevuConnection>;
+    /**
+     * Connect to an existing connection by ID (answerer role)
+     * @param id - Connection identifier
+     * @returns Promise that resolves to RondevuConnection
+     */
+    connect(id: string): Promise<RondevuConnection>;
+    /**
+     * 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
+     */
+    join(topic: string, options?: JoinOptions): Promise<RondevuConnection>;
+    /**
+     * Select a session based on strategy
+     */
+    private selectSession;
+    /**
+     * Wait for ICE gathering to complete
+     */
+    private waitForIceGathering;
+    /**
+     * Find a session by connection ID
+     * This requires polling since we don't know which topic it's in
+     */
+    private findSessionById;
+}