@xtr-dev/rondevu-client 0.9.1 → 0.10.0

package/dist/peer/failed-state.d.ts

@@ -1,10 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Failed state - connection attempt failed
- */
-export declare class FailedState extends PeerState {
-    private error;
-    constructor(peer: any, error: Error);
-    get name(): string;
-    cleanup(): void;
-}

package/dist/peer/failed-state.js

@@ -1,16 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Failed state - connection attempt failed
- */
-export class FailedState extends PeerState {
-    constructor(peer, error) {
-        super(peer);
-        this.error = error;
-        peer.emitEvent('failed', error);
-    }
-    get name() { return 'failed'; }
-    cleanup() {
-        // Connection is failed, clean up resources
-        this.peer.pc.close();
-    }
-}

package/dist/peer/idle-state.d.ts

@@ -1,7 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-export declare class IdleState extends PeerState {
-    get name(): string;
-    createOffer(options: PeerOptions): Promise<string>;
-    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
-}

package/dist/peer/idle-state.js

@@ -1,14 +0,0 @@
-import { PeerState } from './state.js';
-export class IdleState extends PeerState {
-    get name() { return 'idle'; }
-    async createOffer(options) {
-        const { CreatingOfferState } = await import('./creating-offer-state.js');
-        this.peer.setState(new CreatingOfferState(this.peer, options));
-        return this.peer.state.createOffer(options);
-    }
-    async answer(offerId, offerSdp, options) {
-        const { AnsweringState } = await import('./answering-state.js');
-        this.peer.setState(new AnsweringState(this.peer));
-        return this.peer.state.answer(offerId, offerSdp, options);
-    }
-}

package/dist/peer/index.d.ts

@@ -1,71 +0,0 @@
-import { RondevuOffers } from '../offers.js';
-import { EventEmitter } from '../event-emitter.js';
-import type { PeerOptions, PeerEvents } from './types.js';
-import { PeerState } from './state.js';
-export type { PeerTimeouts, PeerOptions, PeerEvents } from './types.js';
-/**
- * High-level WebRTC peer connection manager with state-based lifecycle
- * Handles offer/answer exchange, ICE candidates, timeouts, and error recovery
- */
-export default class RondevuPeer extends EventEmitter<PeerEvents> {
-    pc: RTCPeerConnection;
-    offersApi: RondevuOffers;
-    offerId?: string;
-    role?: 'offerer' | 'answerer';
-    RTCPeerConnection: typeof RTCPeerConnection;
-    RTCSessionDescription: typeof RTCSessionDescription;
-    RTCIceCandidate: typeof RTCIceCandidate;
-    private _state;
-    private connectionStateChangeHandler?;
-    private dataChannelHandler?;
-    private trackHandler?;
-    private iceCandidateErrorHandler?;
-    /**
-     * Current connection state name
-     */
-    get stateName(): string;
-    /**
-     * Current state object (internal use)
-     */
-    get state(): PeerState;
-    /**
-     * RTCPeerConnection state
-     */
-    get connectionState(): RTCPeerConnectionState;
-    constructor(offersApi: RondevuOffers, rtcConfig?: RTCConfiguration, existingPeerConnection?: RTCPeerConnection, rtcPeerConnection?: typeof RTCPeerConnection, rtcSessionDescription?: typeof RTCSessionDescription, rtcIceCandidate?: typeof RTCIceCandidate);
-    /**
-     * Set up peer connection event handlers
-     */
-    private setupPeerConnection;
-    /**
-     * Set new state and emit state change event
-     */
-    setState(newState: PeerState): void;
-    /**
-     * Emit event (exposed for PeerState classes)
-     * @internal
-     */
-    emitEvent<K extends keyof PeerEvents>(event: K, ...args: Parameters<PeerEvents[K]>): void;
-    /**
-     * Create an offer and advertise on topics
-     */
-    createOffer(options: PeerOptions): Promise<string>;
-    /**
-     * Answer an existing offer
-     */
-    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
-    /**
-     * Add a media track to the connection
-     */
-    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
-    /**
-     * Create a data channel for sending and receiving arbitrary data
-     * This should typically be called by the offerer before creating the offer
-     * The answerer will receive the channel via the 'datachannel' event
-     */
-    createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel;
-    /**
-     * Close the connection and clean up
-     */
-    close(): Promise<void>;
-}

package/dist/peer/index.js

@@ -1,176 +0,0 @@
-import { EventEmitter } from '../event-emitter.js';
-import { IdleState } from './idle-state.js';
-import { ConnectedState } from './connected-state.js';
-import { FailedState } from './failed-state.js';
-import { ClosedState } from './closed-state.js';
-/**
- * High-level WebRTC peer connection manager with state-based lifecycle
- * Handles offer/answer exchange, ICE candidates, timeouts, and error recovery
- */
-export default class RondevuPeer extends EventEmitter {
-    /**
-     * Current connection state name
-     */
-    get stateName() {
-        return this._state.name;
-    }
-    /**
-     * Current state object (internal use)
-     */
-    get state() {
-        return this._state;
-    }
-    /**
-     * RTCPeerConnection state
-     */
-    get connectionState() {
-        return this.pc.connectionState;
-    }
-    constructor(offersApi, rtcConfig = {
-        iceServers: [
-            { urls: 'stun:stun.l.google.com:19302' },
-            { urls: 'stun:stun1.l.google.com:19302' }
-        ]
-    }, existingPeerConnection, rtcPeerConnection, rtcSessionDescription, rtcIceCandidate) {
-        super();
-        this.offersApi = offersApi;
-        // Use provided polyfills or fall back to globals
-        this.RTCPeerConnection = rtcPeerConnection || (typeof globalThis.RTCPeerConnection !== 'undefined'
-            ? globalThis.RTCPeerConnection
-            : (() => {
-                throw new Error('RTCPeerConnection is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
-            }));
-        this.RTCSessionDescription = rtcSessionDescription || (typeof globalThis.RTCSessionDescription !== 'undefined'
-            ? globalThis.RTCSessionDescription
-            : (() => {
-                throw new Error('RTCSessionDescription is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
-            }));
-        this.RTCIceCandidate = rtcIceCandidate || (typeof globalThis.RTCIceCandidate !== 'undefined'
-            ? globalThis.RTCIceCandidate
-            : (() => {
-                throw new Error('RTCIceCandidate is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
-            }));
-        // Use existing peer connection if provided, otherwise create new one
-        this.pc = existingPeerConnection || new this.RTCPeerConnection(rtcConfig);
-        this._state = new IdleState(this);
-        this.setupPeerConnection();
-    }
-    /**
-     * Set up peer connection event handlers
-     */
-    setupPeerConnection() {
-        this.connectionStateChangeHandler = () => {
-            console.log(`🔌 Connection state changed: ${this.pc.connectionState}`);
-            switch (this.pc.connectionState) {
-                case 'connected':
-                    console.log('✅ WebRTC connection established');
-                    this.setState(new ConnectedState(this));
-                    this.emitEvent('connected');
-                    break;
-                case 'disconnected':
-                    console.log('⚠️ WebRTC connection disconnected');
-                    this.emitEvent('disconnected');
-                    break;
-                case 'failed':
-                    console.log('❌ WebRTC connection failed');
-                    this.setState(new FailedState(this, new Error('Connection failed')));
-                    break;
-                case 'closed':
-                    console.log('🔒 WebRTC connection closed');
-                    this.setState(new ClosedState(this));
-                    this.emitEvent('disconnected');
-                    break;
-            }
-        };
-        this.pc.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
-        // Add ICE connection state logging
-        const iceConnectionStateHandler = () => {
-            console.log(`🧊 ICE connection state: ${this.pc.iceConnectionState}`);
-        };
-        this.pc.addEventListener('iceconnectionstatechange', iceConnectionStateHandler);
-        // Add ICE gathering state logging
-        const iceGatheringStateHandler = () => {
-            console.log(`🔍 ICE gathering state: ${this.pc.iceGatheringState}`);
-        };
-        this.pc.addEventListener('icegatheringstatechange', iceGatheringStateHandler);
-        this.dataChannelHandler = (event) => {
-            this.emitEvent('datachannel', event.channel);
-        };
-        this.pc.addEventListener('datachannel', this.dataChannelHandler);
-        this.trackHandler = (event) => {
-            this.emitEvent('track', event);
-        };
-        this.pc.addEventListener('track', this.trackHandler);
-        this.iceCandidateErrorHandler = (event) => {
-            const iceError = event;
-            console.error(`❌ ICE candidate error: ${iceError.errorText || 'Unknown error'}`, {
-                errorCode: iceError.errorCode,
-                url: iceError.url,
-                address: iceError.address,
-                port: iceError.port
-            });
-        };
-        this.pc.addEventListener('icecandidateerror', this.iceCandidateErrorHandler);
-    }
-    /**
-     * Set new state and emit state change event
-     */
-    setState(newState) {
-        this._state.cleanup();
-        this._state = newState;
-        this.emitEvent('state', newState.name);
-    }
-    /**
-     * Emit event (exposed for PeerState classes)
-     * @internal
-     */
-    emitEvent(event, ...args) {
-        this.emit(event, ...args);
-    }
-    /**
-     * Create an offer and advertise on topics
-     */
-    async createOffer(options) {
-        return this._state.createOffer(options);
-    }
-    /**
-     * Answer an existing offer
-     */
-    async answer(offerId, offerSdp, options) {
-        return this._state.answer(offerId, offerSdp, options);
-    }
-    /**
-     * Add a media track to the connection
-     */
-    addTrack(track, ...streams) {
-        return this.pc.addTrack(track, ...streams);
-    }
-    /**
-     * Create a data channel for sending and receiving arbitrary data
-     * This should typically be called by the offerer before creating the offer
-     * The answerer will receive the channel via the 'datachannel' event
-     */
-    createDataChannel(label, options) {
-        return this.pc.createDataChannel(label, options);
-    }
-    /**
-     * Close the connection and clean up
-     */
-    async close() {
-        // Remove RTCPeerConnection event listeners
-        if (this.connectionStateChangeHandler) {
-            this.pc.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
-        }
-        if (this.dataChannelHandler) {
-            this.pc.removeEventListener('datachannel', this.dataChannelHandler);
-        }
-        if (this.trackHandler) {
-            this.pc.removeEventListener('track', this.trackHandler);
-        }
-        if (this.iceCandidateErrorHandler) {
-            this.pc.removeEventListener('icecandidateerror', this.iceCandidateErrorHandler);
-        }
-        await this._state.close();
-        this.removeAllListeners();
-    }
-}

package/dist/peer/state.d.ts

@@ -1,23 +0,0 @@
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-/**
- * Base class for peer connection states
- * Implements the State pattern for managing WebRTC connection lifecycle
- */
-export declare abstract class PeerState {
-    protected peer: RondevuPeer;
-    protected iceCandidateHandler?: (event: RTCPeerConnectionIceEvent) => void;
-    constructor(peer: RondevuPeer);
-    abstract get name(): string;
-    createOffer(options: PeerOptions): Promise<string>;
-    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
-    handleAnswer(sdp: string): Promise<void>;
-    handleIceCandidate(candidate: any): Promise<void>;
-    /**
-     * Setup trickle ICE candidate handler
-     * Sends local ICE candidates to server as they are discovered
-     */
-    protected setupIceCandidateHandler(): void;
-    cleanup(): void;
-    close(): Promise<void>;
-}

package/dist/peer/state.js

@@ -1,63 +0,0 @@
-/**
- * Base class for peer connection states
- * Implements the State pattern for managing WebRTC connection lifecycle
- */
-export class PeerState {
-    constructor(peer) {
-        this.peer = peer;
-    }
-    async createOffer(options) {
-        throw new Error(`Cannot create offer in ${this.name} state`);
-    }
-    async answer(offerId, offerSdp, options) {
-        throw new Error(`Cannot answer in ${this.name} state`);
-    }
-    async handleAnswer(sdp) {
-        throw new Error(`Cannot handle answer in ${this.name} state`);
-    }
-    async handleIceCandidate(candidate) {
-        // ICE candidates can arrive in multiple states, so default is to add them
-        if (this.peer.pc.remoteDescription) {
-            await this.peer.pc.addIceCandidate(new this.peer.RTCIceCandidate(candidate));
-        }
-    }
-    /**
-     * Setup trickle ICE candidate handler
-     * Sends local ICE candidates to server as they are discovered
-     */
-    setupIceCandidateHandler() {
-        this.iceCandidateHandler = async (event) => {
-            if (event.candidate && this.peer.offerId) {
-                const candidateData = event.candidate.toJSON();
-                if (candidateData.candidate && candidateData.candidate !== '') {
-                    const type = candidateData.candidate.includes('typ host') ? 'host' :
-                        candidateData.candidate.includes('typ srflx') ? 'srflx' :
-                            candidateData.candidate.includes('typ relay') ? 'relay' : 'unknown';
-                    console.log(`🧊 Generated ${type} ICE candidate:`, candidateData.candidate);
-                    try {
-                        await this.peer.offersApi.addIceCandidates(this.peer.offerId, [candidateData]);
-                        console.log(`✅ Sent ${type} ICE candidate to server`);
-                    }
-                    catch (err) {
-                        console.error(`❌ Error sending ${type} ICE candidate:`, err);
-                    }
-                }
-            }
-            else if (!event.candidate) {
-                console.log('🧊 ICE gathering complete (null candidate)');
-            }
-        };
-        this.peer.pc.addEventListener('icecandidate', this.iceCandidateHandler);
-    }
-    cleanup() {
-        // Clean up ICE candidate handler if it exists
-        if (this.iceCandidateHandler) {
-            this.peer.pc.removeEventListener('icecandidate', this.iceCandidateHandler);
-        }
-    }
-    async close() {
-        this.cleanup();
-        const { ClosedState } = await import('./closed-state.js');
-        this.peer.setState(new ClosedState(this.peer));
-    }
-}

package/dist/peer/types.d.ts

@@ -1,43 +0,0 @@
-/**
- * Timeout configurations for different connection phases
- */
-export interface PeerTimeouts {
-    /** Timeout for ICE gathering (default: 10000ms) */
-    iceGathering?: number;
-    /** Timeout for waiting for answer (default: 30000ms) */
-    waitingForAnswer?: number;
-    /** Timeout for creating answer (default: 10000ms) */
-    creatingAnswer?: number;
-    /** Timeout for ICE connection (default: 30000ms) */
-    iceConnection?: number;
-}
-/**
- * Options for creating a peer connection
- */
-export interface PeerOptions {
-    /** RTCConfiguration for the peer connection */
-    rtcConfig?: RTCConfiguration;
-    /** Topics to advertise this connection under */
-    topics: string[];
-    /** How long the offer should live (milliseconds) */
-    ttl?: number;
-    /** Optional secret to protect the offer (max 128 characters) */
-    secret?: string;
-    /** Whether to create a data channel automatically (for offerer) */
-    createDataChannel?: boolean;
-    /** Label for the automatically created data channel */
-    dataChannelLabel?: string;
-    /** Timeout configurations */
-    timeouts?: PeerTimeouts;
-}
-/**
- * Events emitted by RondevuPeer
- */
-export interface PeerEvents extends Record<string, (...args: any[]) => void> {
-    'state': (state: string) => void;
-    'connected': () => void;
-    'disconnected': () => void;
-    'failed': (error: Error) => void;
-    'datachannel': (channel: RTCDataChannel) => void;
-    'track': (event: RTCTrackEvent) => void;
-}

package/dist/peer/types.js

@@ -1 +0,0 @@
-export {};

package/dist/peer/waiting-for-answer-state.d.ts

@@ -1,17 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-/**
- * Waiting for answer from another peer
- */
-export declare class WaitingForAnswerState extends PeerState {
-    private offerId;
-    private options;
-    private pollingInterval?;
-    private timeout?;
-    constructor(peer: RondevuPeer, offerId: string, options: PeerOptions);
-    get name(): string;
-    private startPolling;
-    handleAnswer(sdp: string): Promise<void>;
-    cleanup(): void;
-}

package/dist/peer/waiting-for-answer-state.js

@@ -1,60 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Waiting for answer from another peer
- */
-export class WaitingForAnswerState extends PeerState {
-    constructor(peer, offerId, options) {
-        super(peer);
-        this.offerId = offerId;
-        this.options = options;
-        this.startPolling();
-    }
-    get name() { return 'waiting-for-answer'; }
-    startPolling() {
-        const answerTimeout = this.options.timeouts?.waitingForAnswer || 30000;
-        this.timeout = setTimeout(async () => {
-            this.cleanup();
-            const { FailedState } = await import('./failed-state.js');
-            this.peer.setState(new FailedState(this.peer, new Error('Timeout waiting for answer')));
-        }, answerTimeout);
-        this.pollingInterval = setInterval(async () => {
-            try {
-                const answers = await this.peer.offersApi.getAnswers();
-                const myAnswer = answers.find((a) => a.offerId === this.offerId);
-                if (myAnswer) {
-                    this.cleanup();
-                    await this.handleAnswer(myAnswer.sdp);
-                }
-            }
-            catch (err) {
-                console.error('Error polling for answers:', err);
-                if (err instanceof Error && err.message.includes('not found')) {
-                    this.cleanup();
-                    const { FailedState } = await import('./failed-state.js');
-                    this.peer.setState(new FailedState(this.peer, new Error('Offer expired or not found')));
-                }
-            }
-        }, 2000);
-    }
-    async handleAnswer(sdp) {
-        try {
-            await this.peer.pc.setRemoteDescription({
-                type: 'answer',
-                sdp
-            });
-            // Transition to exchanging ICE
-            const { ExchangingIceState } = await import('./exchanging-ice-state.js');
-            this.peer.setState(new ExchangingIceState(this.peer, this.offerId, this.options));
-        }
-        catch (error) {
-            const { FailedState } = await import('./failed-state.js');
-            this.peer.setState(new FailedState(this.peer, error));
-        }
-    }
-    cleanup() {
-        if (this.pollingInterval)
-            clearInterval(this.pollingInterval);
-        if (this.timeout)
-            clearTimeout(this.timeout);
-    }
-}