@xtr-dev/rondevu-client 0.3.5 → 0.4.0

package/dist/connection.d.ts

@@ -1,82 +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 hasConnected;
-    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;
+    /**
+     * Create an offer and advertise on topics
+     */
+    createOffer(options: ConnectionOptions): Promise<string>;
+    /**
+     * Answer an existing offer
+     */
+    answer(offerId: string, offerSdp: string): Promise<void>;
     /**
-     * Poll the signaling server for remote data
+     * Start polling for answers (offerer only)
      */
-    private poll;
+    private startAnswerPolling;
     /**
-     * Handle remotely created data channel
+     * Start polling for ICE candidates
      */
-    private handleRemoteDataChannel;
+    private startIcePolling;
     /**
-     * Get or create a data channel
+     * Stop answer polling
      */
-    dataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
+    private stopAnswerPolling;
     /**
-     * Add a local media stream to the connection
+     * Stop ICE polling
      */
-    addStream(stream: MediaStream): void;
+    private stopIcePolling;
+    /**
+     * Stop all polling
+     */
+    private stopPolling;
     /**
-     * Get the underlying RTCPeerConnection for advanced usage
+     * Add event listener
      */
-    getPeerConnection(): RTCPeerConnection;
+    on<K extends keyof RondevuConnectionEvents>(event: K, listener: RondevuConnectionEvents[K]): void;
     /**
-     * Start connection timeout
+     * Remove event listener
      */
-    private startConnectionTimeout;
+    off<K extends keyof RondevuConnectionEvents>(event: K, listener: RondevuConnectionEvents[K]): void;
     /**
-     * Clear connection timeout
+     * Emit event
      */
-    private clearConnectionTimeout;
+    private emit;
     /**
-     * Leave the session by deleting the offer on the server and closing the connection
-     * This ends the session for all connected peers
+     * Add a media track to the connection
      */
-    leave(): Promise<void>;
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
     /**
-     * Close the connection and cleanup resources
+     * Close the connection and clean up
      */
     close(): void;
 }