@xtr-dev/rondevu-client 0.3.4 → 0.4.0

package/dist/client.js

@@ -150,4 +150,22 @@ export class RondevuAPI {
             method: 'GET',
         });
     }
+    /**
+     * Ends a session by deleting the offer from the server
+     *
+     * @param code - The offer code
+     * @returns Success confirmation
+     *
+     * @example
+     * ```typescript
+     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
+     * await api.leave('my-offer-code');
+     * ```
+     */
+    async leave(code) {
+        return this.request('/leave', {
+            method: 'POST',
+            body: JSON.stringify({ code }),
+        });
+    }
 }

package/dist/connection.d.ts

@@ -1,76 +1,127 @@
-import { EventEmitter } from './event-emitter.js';
-import { RondevuAPI } from './client.js';
-import { RondevuConnectionParams } from './types.js';
+import { RondevuOffers } from './offers.js';
 /**
- * Represents a WebRTC connection with automatic signaling and ICE exchange
+ * Events emitted by RondevuConnection
  */
-export declare class RondevuConnection extends EventEmitter {
-    readonly id: string;
-    readonly role: 'offerer' | 'answerer';
-    readonly remotePeerId: string;
+export interface RondevuConnectionEvents {
+    'connecting': () => void;
+    'connected': () => void;
+    'disconnected': () => void;
+    'error': (error: Error) => void;
+    'datachannel': (channel: RTCDataChannel) => void;
+    'track': (event: RTCTrackEvent) => void;
+}
+/**
+ * Options for creating a WebRTC connection
+ */
+export interface ConnectionOptions {
+    /**
+     * RTCConfiguration for the peer connection
+     * @default { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] }
+     */
+    rtcConfig?: RTCConfiguration;
+    /**
+     * Topics to advertise this connection under
+     */
+    topics: string[];
+    /**
+     * How long the offer should live (milliseconds)
+     * @default 300000 (5 minutes)
+     */
+    ttl?: number;
+    /**
+     * Whether to create a data channel automatically (for offerer)
+     * @default true
+     */
+    createDataChannel?: boolean;
+    /**
+     * Label for the automatically created data channel
+     * @default 'data'
+     */
+    dataChannelLabel?: string;
+}
+/**
+ * High-level WebRTC connection manager for Rondevu
+ * Handles offer/answer exchange, ICE candidates, and connection lifecycle
+ */
+export declare class RondevuConnection {
+    private rtcConfig;
     private pc;
-    private client;
-    private localPeerId;
-    private dataChannels;
-    private pollingInterval?;
-    private pollingIntervalMs;
-    private connectionTimeoutMs;
-    private connectionTimer?;
-    private isPolling;
-    private isClosed;
-    private wrtc?;
-    private RTCIceCandidate;
-    constructor(params: RondevuConnectionParams, client: RondevuAPI);
+    private offersApi;
+    private offerId?;
+    private role?;
+    private icePollingInterval?;
+    private answerPollingInterval?;
+    private lastIceTimestamp;
+    private eventListeners;
+    private dataChannel?;
+    private pendingIceCandidates;
     /**
-     * Setup RTCPeerConnection event handlers
+     * Current connection state
      */
-    private setupEventHandlers;
+    get connectionState(): RTCPeerConnectionState;
     /**
-     * Handle RTCPeerConnection state changes
+     * The offer ID for this connection
      */
-    private handleConnectionStateChange;
+    get id(): string | undefined;
     /**
-     * Send an ICE candidate to the remote peer via signaling server
+     * Get the primary data channel (if created)
      */
-    private sendIceCandidate;
+    get channel(): RTCDataChannel | undefined;
+    constructor(offersApi: RondevuOffers, rtcConfig?: RTCConfiguration);
     /**
-     * Start polling for remote session data (answer/candidates)
+     * Set up peer connection event handlers
      */
-    startPolling(): void;
+    private setupPeerConnection;
     /**
-     * Stop polling
+     * Flush buffered ICE candidates (trickle ICE support)
      */
-    private stopPolling;
+    private flushPendingIceCandidates;
     /**
-     * Poll the signaling server for remote data
+     * Create an offer and advertise on topics
      */
-    private poll;
+    createOffer(options: ConnectionOptions): Promise<string>;
     /**
-     * Handle remotely created data channel
+     * Answer an existing offer
      */
-    private handleRemoteDataChannel;
+    answer(offerId: string, offerSdp: string): Promise<void>;
     /**
-     * Get or create a data channel
+     * Start polling for answers (offerer only)
      */
-    dataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
+    private startAnswerPolling;
+    /**
+     * Start polling for ICE candidates
+     */
+    private startIcePolling;
+    /**
+     * Stop answer polling
+     */
+    private stopAnswerPolling;
+    /**
+     * Stop ICE polling
+     */
+    private stopIcePolling;
+    /**
+     * Stop all polling
+     */
+    private stopPolling;
     /**
-     * Add a local media stream to the connection
+     * Add event listener
      */
-    addStream(stream: MediaStream): void;
+    on<K extends keyof RondevuConnectionEvents>(event: K, listener: RondevuConnectionEvents[K]): void;
     /**
-     * Get the underlying RTCPeerConnection for advanced usage
+     * Remove event listener
      */
-    getPeerConnection(): RTCPeerConnection;
+    off<K extends keyof RondevuConnectionEvents>(event: K, listener: RondevuConnectionEvents[K]): void;
     /**
-     * Start connection timeout
+     * Emit event
      */
-    private startConnectionTimeout;
+    private emit;
     /**
-     * Clear connection timeout
+     * Add a media track to the connection
      */
-    private clearConnectionTimeout;
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
     /**
-     * Close the connection and cleanup resources
+     * Close the connection and clean up
      */
     close(): void;
 }