@xtr-dev/rondevu-client 0.8.3 → 0.9.2

package/dist/discovery.js

@@ -1,164 +0,0 @@
-import RondevuPeer from './peer/index.js';
-import { RondevuOffers } from './offers.js';
-/**
- * Rondevu Discovery API
- * Handles service discovery and connections
- */
-export class RondevuDiscovery {
-    constructor(baseUrl, credentials) {
-        this.baseUrl = baseUrl;
-        this.credentials = credentials;
-        this.offersApi = new RondevuOffers(baseUrl, credentials);
-    }
-    /**
-     * Lists all services for a username
-     * Returns UUIDs only for private services, full details for public
-     */
-    async listServices(username) {
-        const response = await fetch(`${this.baseUrl}/usernames/${username}/services`);
-        if (!response.ok) {
-            throw new Error('Failed to list services');
-        }
-        const data = await response.json();
-        return {
-            username: data.username,
-            services: data.services
-        };
-    }
-    /**
-     * Queries a service by FQN
-     * Returns UUID if service exists and is allowed
-     */
-    async queryService(username, serviceFqn) {
-        const response = await fetch(`${this.baseUrl}/index/${username}/query`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ serviceFqn })
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(error.error || 'Service not found');
-        }
-        const data = await response.json();
-        return {
-            uuid: data.uuid,
-            allowed: data.allowed
-        };
-    }
-    /**
-     * Gets service details by UUID
-     */
-    async getServiceDetails(uuid) {
-        const response = await fetch(`${this.baseUrl}/services/${uuid}`);
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(error.error || 'Service not found');
-        }
-        const data = await response.json();
-        return {
-            serviceId: data.serviceId,
-            username: data.username,
-            serviceFqn: data.serviceFqn,
-            offerId: data.offerId,
-            sdp: data.sdp,
-            isPublic: data.isPublic,
-            metadata: data.metadata,
-            createdAt: data.createdAt,
-            expiresAt: data.expiresAt
-        };
-    }
-    /**
-     * Connects to a service by UUID
-     */
-    async connectToService(uuid, options) {
-        // Get service details
-        const service = await this.getServiceDetails(uuid);
-        // Create peer with the offer
-        const peer = new RondevuPeer(this.offersApi, options?.rtcConfig || {
-            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-        });
-        // Set up event handlers
-        if (options?.onConnected) {
-            peer.on('connected', options.onConnected);
-        }
-        if (options?.onData) {
-            peer.on('datachannel', (channel) => {
-                channel.onmessage = (e) => options.onData(e.data);
-            });
-        }
-        // Answer the offer
-        await peer.answer(service.offerId, service.sdp, {
-            topics: [], // V2 doesn't use topics
-            rtcConfig: options?.rtcConfig
-        });
-        return peer;
-    }
-    /**
-     * Convenience method: Query and connect in one call
-     * Returns both peer and data channel
-     */
-    async connect(username, serviceFqn, options) {
-        // Query service
-        const query = await this.queryService(username, serviceFqn);
-        if (!query.allowed) {
-            throw new Error('Service access denied');
-        }
-        // Get service details
-        const service = await this.getServiceDetails(query.uuid);
-        // Create peer
-        const peer = new RondevuPeer(this.offersApi, options?.rtcConfig || {
-            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-        });
-        // Answer the offer
-        await peer.answer(service.offerId, service.sdp, {
-            topics: [], // V2 doesn't use topics
-            rtcConfig: options?.rtcConfig
-        });
-        // Wait for data channel
-        const channel = await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('Timeout waiting for data channel'));
-            }, 30000);
-            peer.on('datachannel', (ch) => {
-                clearTimeout(timeout);
-                resolve(ch);
-            });
-            peer.on('failed', (error) => {
-                clearTimeout(timeout);
-                reject(error);
-            });
-        });
-        return { peer, channel };
-    }
-    /**
-     * Convenience method: Connect to service by UUID with channel
-     */
-    async connectByUuid(uuid, options) {
-        // Get service details
-        const service = await this.getServiceDetails(uuid);
-        // Create peer
-        const peer = new RondevuPeer(this.offersApi, options?.rtcConfig || {
-            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-        });
-        // Answer the offer
-        await peer.answer(service.offerId, service.sdp, {
-            topics: [], // V2 doesn't use topics
-            rtcConfig: options?.rtcConfig
-        });
-        // Wait for data channel
-        const channel = await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('Timeout waiting for data channel'));
-            }, 30000);
-            peer.on('datachannel', (ch) => {
-                clearTimeout(timeout);
-                resolve(ch);
-            });
-            peer.on('failed', (error) => {
-                clearTimeout(timeout);
-                reject(error);
-            });
-        });
-        return { peer, channel };
-    }
-}

package/dist/peer.d.ts

@@ -1,111 +0,0 @@
-import { RondevuOffers } from './offers.js';
-import { EventEmitter } from './event-emitter.js';
-/**
- * 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;
-    /** 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;
-}
-/**
- * Base class for peer connection states
- */
-declare abstract class PeerState {
-    protected peer: RondevuPeer;
-    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>;
-    cleanup(): void;
-    close(): void;
-}
-/**
- * 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';
-    private _state;
-    /**
-     * 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);
-    /**
-     * 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;
-    /**
-     * Close the connection and clean up
-     */
-    close(): void;
-}
-export {};

package/dist/peer.js

@@ -1,392 +0,0 @@
-import { EventEmitter } from './event-emitter.js';
-/**
- * Base class for peer connection states
- */
-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 RTCIceCandidate(candidate));
-        }
-    }
-    cleanup() {
-        // Override in states that need cleanup
-    }
-    close() {
-        this.cleanup();
-        this.peer.setState(new ClosedState(this.peer));
-    }
-}
-/**
- * Initial idle state
- */
-class IdleState extends PeerState {
-    get name() { return 'idle'; }
-    async createOffer(options) {
-        this.peer.setState(new CreatingOfferState(this.peer, options));
-        return this.peer.state.createOffer(options);
-    }
-    async answer(offerId, offerSdp, options) {
-        this.peer.setState(new AnsweringState(this.peer));
-        return this.peer.state.answer(offerId, offerSdp, options);
-    }
-}
-/**
- * Creating offer and sending to server
- */
-class CreatingOfferState extends PeerState {
-    constructor(peer, options) {
-        super(peer);
-        this.options = options;
-    }
-    get name() { return 'creating-offer'; }
-    async createOffer(options) {
-        try {
-            this.peer.role = 'offerer';
-            // Create data channel if requested
-            if (options.createDataChannel !== false) {
-                const channel = this.peer.pc.createDataChannel(options.dataChannelLabel || 'data');
-                this.peer.emitEvent('datachannel', channel);
-            }
-            // Create WebRTC offer
-            const offer = await this.peer.pc.createOffer();
-            await this.peer.pc.setLocalDescription(offer);
-            // Send offer to server immediately (don't wait for ICE)
-            const offers = await this.peer.offersApi.create([{
-                    sdp: offer.sdp,
-                    topics: options.topics,
-                    ttl: options.ttl || 300000
-                }]);
-            const offerId = offers[0].id;
-            this.peer.offerId = offerId;
-            // Enable trickle ICE - send candidates as they arrive
-            this.peer.pc.onicecandidate = async (event) => {
-                if (event.candidate && offerId) {
-                    const candidateData = event.candidate.toJSON();
-                    if (candidateData.candidate && candidateData.candidate !== '') {
-                        try {
-                            await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
-                        }
-                        catch (err) {
-                            console.error('Error sending ICE candidate:', err);
-                        }
-                    }
-                }
-            };
-            // Transition to waiting for answer
-            this.peer.setState(new WaitingForAnswerState(this.peer, offerId, options));
-            return offerId;
-        }
-        catch (error) {
-            this.peer.setState(new FailedState(this.peer, error));
-            throw error;
-        }
-    }
-}
-/**
- * Waiting for answer from another peer
- */
-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(() => {
-            this.cleanup();
-            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();
-                    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
-            this.peer.setState(new ExchangingIceState(this.peer, this.offerId, this.options));
-        }
-        catch (error) {
-            this.peer.setState(new FailedState(this.peer, error));
-        }
-    }
-    cleanup() {
-        if (this.pollingInterval)
-            clearInterval(this.pollingInterval);
-        if (this.timeout)
-            clearTimeout(this.timeout);
-    }
-}
-/**
- * Answering an offer and sending to server
- */
-class AnsweringState extends PeerState {
-    constructor(peer) {
-        super(peer);
-    }
-    get name() { return 'answering'; }
-    async answer(offerId, offerSdp, options) {
-        try {
-            this.peer.role = 'answerer';
-            this.peer.offerId = offerId;
-            // Set remote description
-            await this.peer.pc.setRemoteDescription({
-                type: 'offer',
-                sdp: offerSdp
-            });
-            // Create answer
-            const answer = await this.peer.pc.createAnswer();
-            await this.peer.pc.setLocalDescription(answer);
-            // Send answer to server immediately (don't wait for ICE)
-            await this.peer.offersApi.answer(offerId, answer.sdp);
-            // Enable trickle ICE - send candidates as they arrive
-            this.peer.pc.onicecandidate = async (event) => {
-                if (event.candidate && offerId) {
-                    const candidateData = event.candidate.toJSON();
-                    if (candidateData.candidate && candidateData.candidate !== '') {
-                        try {
-                            await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
-                        }
-                        catch (err) {
-                            console.error('Error sending ICE candidate:', err);
-                        }
-                    }
-                }
-            };
-            // Transition to exchanging ICE
-            this.peer.setState(new ExchangingIceState(this.peer, offerId, options));
-        }
-        catch (error) {
-            this.peer.setState(new FailedState(this.peer, error));
-            throw error;
-        }
-    }
-}
-/**
- * Exchanging ICE candidates and waiting for connection
- */
-class ExchangingIceState extends PeerState {
-    constructor(peer, offerId, options) {
-        super(peer);
-        this.offerId = offerId;
-        this.options = options;
-        this.lastIceTimestamp = 0;
-        this.startPolling();
-    }
-    get name() { return 'exchanging-ice'; }
-    startPolling() {
-        const connectionTimeout = this.options.timeouts?.iceConnection || 30000;
-        this.timeout = setTimeout(() => {
-            this.cleanup();
-            this.peer.setState(new FailedState(this.peer, new Error('ICE connection timeout')));
-        }, connectionTimeout);
-        this.pollingInterval = setInterval(async () => {
-            try {
-                const candidates = await this.peer.offersApi.getIceCandidates(this.offerId, this.lastIceTimestamp);
-                for (const cand of candidates) {
-                    if (cand.candidate && cand.candidate.candidate && cand.candidate.candidate !== '') {
-                        try {
-                            await this.peer.pc.addIceCandidate(new RTCIceCandidate(cand.candidate));
-                            this.lastIceTimestamp = cand.createdAt;
-                        }
-                        catch (err) {
-                            console.warn('Failed to add ICE candidate:', err);
-                            this.lastIceTimestamp = cand.createdAt;
-                        }
-                    }
-                    else {
-                        this.lastIceTimestamp = cand.createdAt;
-                    }
-                }
-            }
-            catch (err) {
-                console.error('Error polling for ICE candidates:', err);
-                if (err instanceof Error && err.message.includes('not found')) {
-                    this.cleanup();
-                    this.peer.setState(new FailedState(this.peer, new Error('Offer expired or not found')));
-                }
-            }
-        }, 1000);
-    }
-    cleanup() {
-        if (this.pollingInterval)
-            clearInterval(this.pollingInterval);
-        if (this.timeout)
-            clearTimeout(this.timeout);
-    }
-}
-/**
- * Successfully connected state
- */
-class ConnectedState extends PeerState {
-    get name() { return 'connected'; }
-    cleanup() {
-        // Keep connection alive, but stop any polling
-        // The peer connection will handle disconnects via onconnectionstatechange
-    }
-}
-/**
- * Failed state
- */
-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();
-    }
-}
-/**
- * Closed state
- */
-class ClosedState extends PeerState {
-    get name() { return 'closed'; }
-    cleanup() {
-        this.peer.pc.close();
-    }
-}
-/**
- * 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' }
-        ]
-    }) {
-        super();
-        this.offersApi = offersApi;
-        this.pc = new RTCPeerConnection(rtcConfig);
-        this._state = new IdleState(this);
-        this.setupPeerConnection();
-    }
-    /**
-     * Set up peer connection event handlers
-     */
-    setupPeerConnection() {
-        this.pc.onconnectionstatechange = () => {
-            switch (this.pc.connectionState) {
-                case 'connected':
-                    this.setState(new ConnectedState(this));
-                    this.emitEvent('connected');
-                    break;
-                case 'disconnected':
-                    this.emitEvent('disconnected');
-                    break;
-                case 'failed':
-                    this.setState(new FailedState(this, new Error('Connection failed')));
-                    break;
-                case 'closed':
-                    this.setState(new ClosedState(this));
-                    this.emitEvent('disconnected');
-                    break;
-            }
-        };
-        this.pc.ondatachannel = (event) => {
-            this.emitEvent('datachannel', event.channel);
-        };
-        this.pc.ontrack = (event) => {
-            this.emitEvent('track', event);
-        };
-        this.pc.onicecandidateerror = (event) => {
-            console.error('ICE candidate error:', event);
-        };
-    }
-    /**
-     * 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);
-    }
-    /**
-     * Close the connection and clean up
-     */
-    close() {
-        this._state.close();
-        this.removeAllListeners();
-    }
-}