@xtr-dev/rondevu-client 0.8.3 → 0.9.2

package/dist/client.js

@@ -1,171 +0,0 @@
-/**
- * HTTP API client for Rondevu peer signaling server
- */
-export class RondevuAPI {
-    /**
-     * Creates a new Rondevu API client instance
-     * @param options - Client configuration options
-     */
-    constructor(options) {
-        this.baseUrl = options.baseUrl.replace(/\/$/, ''); // Remove trailing slash
-        this.fetchImpl = options.fetch || globalThis.fetch.bind(globalThis);
-    }
-    /**
-     * Makes an HTTP request to the Rondevu server
-     */
-    async request(endpoint, options = {}) {
-        const url = `${this.baseUrl}${endpoint}`;
-        const headers = {
-            ...options.headers,
-        };
-        if (options.body) {
-            headers['Content-Type'] = 'application/json';
-        }
-        const response = await this.fetchImpl(url, {
-            ...options,
-            headers,
-        });
-        const data = await response.json();
-        if (!response.ok) {
-            const error = data;
-            throw new Error(error.error || `HTTP ${response.status}: ${response.statusText}`);
-        }
-        return data;
-    }
-    /**
-     * Gets server version information
-     *
-     * @returns Server version
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { version } = await api.getVersion();
-     * console.log('Server version:', version);
-     * ```
-     */
-    async getVersion() {
-        return this.request('/', {
-            method: 'GET',
-        });
-    }
-    /**
-     * Creates a new offer
-     *
-     * @param request - Offer details including peer ID, signaling data, and optional custom code
-     * @returns Unique offer code (UUID or custom code)
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { code } = await api.createOffer({
-     *   peerId: 'peer-123',
-     *   offer: signalingData,
-     *   code: 'my-custom-code' // optional
-     * });
-     * console.log('Offer code:', code);
-     * ```
-     */
-    async createOffer(request) {
-        return this.request('/offer', {
-            method: 'POST',
-            body: JSON.stringify(request),
-        });
-    }
-    /**
-     * Sends an answer or candidate to an existing offer
-     *
-     * @param request - Answer details including offer code and signaling data
-     * @returns Success confirmation
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     *
-     * // Send answer
-     * await api.sendAnswer({
-     *   code: offerCode,
-     *   answer: answerData,
-     *   side: 'answerer'
-     * });
-     *
-     * // Send candidate
-     * await api.sendAnswer({
-     *   code: offerCode,
-     *   candidate: candidateData,
-     *   side: 'offerer'
-     * });
-     * ```
-     */
-    async sendAnswer(request) {
-        return this.request('/answer', {
-            method: 'POST',
-            body: JSON.stringify(request),
-        });
-    }
-    /**
-     * Polls for offer data from the other peer
-     *
-     * @param code - Offer code
-     * @param side - Which side is polling ('offerer' or 'answerer')
-     * @returns Offer data including offers, answers, and candidates
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     *
-     * // Offerer polls for answer
-     * const offererData = await api.poll(offerCode, 'offerer');
-     * if (offererData.answer) {
-     *   console.log('Received answer:', offererData.answer);
-     * }
-     *
-     * // Answerer polls for offer
-     * const answererData = await api.poll(offerCode, 'answerer');
-     * console.log('Received offer:', answererData.offer);
-     * ```
-     */
-    async poll(code, side) {
-        const request = { code, side };
-        return this.request('/poll', {
-            method: 'POST',
-            body: JSON.stringify(request),
-        });
-    }
-    /**
-     * Checks server health and version
-     *
-     * @returns Health status, timestamp, and version
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const health = await api.health();
-     * console.log('Server status:', health.status);
-     * console.log('Server version:', health.version);
-     * ```
-     */
-    async health() {
-        return this.request('/health', {
-            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,127 +0,0 @@
-import { RondevuOffers } from './offers.js';
-/**
- * Events emitted by RondevuConnection
- */
-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 offersApi;
-    private offerId?;
-    private role?;
-    private icePollingInterval?;
-    private answerPollingInterval?;
-    private lastIceTimestamp;
-    private eventListeners;
-    private dataChannel?;
-    private pendingIceCandidates;
-    /**
-     * Current connection state
-     */
-    get connectionState(): RTCPeerConnectionState;
-    /**
-     * The offer ID for this connection
-     */
-    get id(): string | undefined;
-    /**
-     * Get the primary data channel (if created)
-     */
-    get channel(): RTCDataChannel | undefined;
-    constructor(offersApi: RondevuOffers, rtcConfig?: RTCConfiguration);
-    /**
-     * Set up peer connection event handlers
-     */
-    private setupPeerConnection;
-    /**
-     * Flush buffered ICE candidates (trickle ICE support)
-     */
-    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>;
-    /**
-     * Start polling for answers (offerer only)
-     */
-    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 event listener
-     */
-    on<K extends keyof RondevuConnectionEvents>(event: K, listener: RondevuConnectionEvents[K]): void;
-    /**
-     * Remove event listener
-     */
-    off<K extends keyof RondevuConnectionEvents>(event: K, listener: RondevuConnectionEvents[K]): void;
-    /**
-     * Emit event
-     */
-    private emit;
-    /**
-     * Add a media track to the connection
-     */
-    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
-    /**
-     * Close the connection and clean up
-     */
-    close(): void;
-}

package/dist/connection.js

@@ -1,295 +0,0 @@
-/**
- * High-level WebRTC connection manager for Rondevu
- * Handles offer/answer exchange, ICE candidates, and connection lifecycle
- */
-export class RondevuConnection {
-    /**
-     * Current connection state
-     */
-    get connectionState() {
-        return this.pc.connectionState;
-    }
-    /**
-     * The offer ID for this connection
-     */
-    get id() {
-        return this.offerId;
-    }
-    /**
-     * Get the primary data channel (if created)
-     */
-    get channel() {
-        return this.dataChannel;
-    }
-    constructor(offersApi, rtcConfig = {
-        iceServers: [
-            { urls: 'stun:stun.l.google.com:19302' },
-            { urls: 'stun:stun1.l.google.com:19302' }
-        ]
-    }) {
-        this.rtcConfig = rtcConfig;
-        this.lastIceTimestamp = 0; // Start at 0 to get all candidates on first poll
-        this.eventListeners = new Map();
-        this.pendingIceCandidates = []; // Store candidates as plain objects
-        this.offersApi = offersApi;
-        this.pc = new RTCPeerConnection(rtcConfig);
-        this.setupPeerConnection();
-    }
-    /**
-     * Set up peer connection event handlers
-     */
-    setupPeerConnection() {
-        this.pc.onicecandidate = async (event) => {
-            if (event.candidate) {
-                // Serialize the entire candidate object to plain JSON
-                const candidateData = event.candidate.toJSON();
-                // Skip end-of-candidates signal (empty candidate string)
-                // Some browsers send this as a candidate object with empty/null properties
-                if (!candidateData.candidate || candidateData.candidate === '') {
-                    return;
-                }
-                if (this.offerId) {
-                    // offerId is set, send immediately (trickle ICE)
-                    try {
-                        await this.offersApi.addIceCandidates(this.offerId, [candidateData]);
-                    }
-                    catch (err) {
-                        console.error('Error sending ICE candidate:', err);
-                    }
-                }
-                else {
-                    // offerId not set yet, buffer the candidate
-                    this.pendingIceCandidates.push(candidateData);
-                }
-            }
-        };
-        this.pc.onconnectionstatechange = () => {
-            switch (this.pc.connectionState) {
-                case 'connecting':
-                    this.emit('connecting');
-                    break;
-                case 'connected':
-                    this.emit('connected');
-                    // Stop polling once connected - we have all the ICE candidates we need
-                    this.stopPolling();
-                    break;
-                case 'disconnected':
-                case 'failed':
-                case 'closed':
-                    this.emit('disconnected');
-                    this.stopPolling();
-                    break;
-            }
-        };
-        this.pc.ondatachannel = (event) => {
-            this.dataChannel = event.channel;
-            this.emit('datachannel', event.channel);
-        };
-        this.pc.ontrack = (event) => {
-            this.emit('track', event);
-        };
-        this.pc.onicecandidateerror = (event) => {
-            console.error('ICE candidate error:', event);
-        };
-    }
-    /**
-     * Flush buffered ICE candidates (trickle ICE support)
-     */
-    async flushPendingIceCandidates() {
-        if (this.pendingIceCandidates.length > 0 && this.offerId) {
-            try {
-                await this.offersApi.addIceCandidates(this.offerId, this.pendingIceCandidates);
-                this.pendingIceCandidates = [];
-            }
-            catch (err) {
-                console.error('Error flushing pending ICE candidates:', err);
-            }
-        }
-    }
-    /**
-     * Create an offer and advertise on topics
-     */
-    async createOffer(options) {
-        this.role = 'offerer';
-        // Create data channel if requested
-        if (options.createDataChannel !== false) {
-            this.dataChannel = this.pc.createDataChannel(options.dataChannelLabel || 'data');
-            this.emit('datachannel', this.dataChannel);
-        }
-        // Create WebRTC offer
-        const offer = await this.pc.createOffer();
-        await this.pc.setLocalDescription(offer);
-        // Create offer on Rondevu server
-        const offers = await this.offersApi.create([{
-                sdp: offer.sdp,
-                topics: options.topics,
-                ttl: options.ttl || 300000
-            }]);
-        this.offerId = offers[0].id;
-        // Flush any ICE candidates that were generated during offer creation
-        await this.flushPendingIceCandidates();
-        // Start polling for answers
-        this.startAnswerPolling();
-        return this.offerId;
-    }
-    /**
-     * Answer an existing offer
-     */
-    async answer(offerId, offerSdp) {
-        this.role = 'answerer';
-        // Set remote description
-        await this.pc.setRemoteDescription({
-            type: 'offer',
-            sdp: offerSdp
-        });
-        // Create answer
-        const answer = await this.pc.createAnswer();
-        await this.pc.setLocalDescription(answer);
-        // Send answer to server FIRST
-        // This registers us as the answerer before ICE candidates arrive
-        await this.offersApi.answer(offerId, answer.sdp);
-        // Now set offerId to enable ICE candidate sending
-        // This prevents a race condition where ICE candidates arrive before answer is registered
-        this.offerId = offerId;
-        // Flush any ICE candidates that were generated during answer creation
-        await this.flushPendingIceCandidates();
-        // Start polling for ICE candidates
-        this.startIcePolling();
-    }
-    /**
-     * Start polling for answers (offerer only)
-     */
-    startAnswerPolling() {
-        if (this.role !== 'offerer' || !this.offerId)
-            return;
-        this.answerPollingInterval = setInterval(async () => {
-            try {
-                const answers = await this.offersApi.getAnswers();
-                const myAnswer = answers.find(a => a.offerId === this.offerId);
-                if (myAnswer) {
-                    // Set remote description
-                    await this.pc.setRemoteDescription({
-                        type: 'answer',
-                        sdp: myAnswer.sdp
-                    });
-                    // Stop answer polling, start ICE polling
-                    this.stopAnswerPolling();
-                    this.startIcePolling();
-                }
-            }
-            catch (err) {
-                console.error('Error polling for answers:', err);
-                // Stop polling if offer expired/not found
-                if (err instanceof Error && err.message.includes('not found')) {
-                    this.stopPolling();
-                }
-            }
-        }, 2000);
-    }
-    /**
-     * Start polling for ICE candidates
-     */
-    startIcePolling() {
-        if (!this.offerId)
-            return;
-        this.icePollingInterval = setInterval(async () => {
-            if (!this.offerId)
-                return;
-            try {
-                const candidates = await this.offersApi.getIceCandidates(this.offerId, this.lastIceTimestamp);
-                for (const cand of candidates) {
-                    // Server already filters candidates by role, so all candidates here are from remote peer
-                    try {
-                        // Skip invalid or empty candidates
-                        if (!cand.candidate || !cand.candidate.candidate || cand.candidate.candidate === '') {
-                            this.lastIceTimestamp = cand.createdAt;
-                            continue;
-                        }
-                        await this.pc.addIceCandidate(new RTCIceCandidate(cand.candidate));
-                        this.lastIceTimestamp = cand.createdAt;
-                    }
-                    catch (err) {
-                        // Log but don't fail on individual candidate errors
-                        console.warn('Failed to add ICE candidate:', err, cand);
-                        this.lastIceTimestamp = cand.createdAt;
-                    }
-                }
-            }
-            catch (err) {
-                console.error('Error polling for ICE candidates:', err);
-                // Stop polling if offer expired/not found
-                if (err instanceof Error && err.message.includes('not found')) {
-                    this.stopPolling();
-                }
-            }
-        }, 1000);
-    }
-    /**
-     * Stop answer polling
-     */
-    stopAnswerPolling() {
-        if (this.answerPollingInterval) {
-            clearInterval(this.answerPollingInterval);
-            this.answerPollingInterval = undefined;
-        }
-    }
-    /**
-     * Stop ICE polling
-     */
-    stopIcePolling() {
-        if (this.icePollingInterval) {
-            clearInterval(this.icePollingInterval);
-            this.icePollingInterval = undefined;
-        }
-    }
-    /**
-     * Stop all polling
-     */
-    stopPolling() {
-        this.stopAnswerPolling();
-        this.stopIcePolling();
-    }
-    /**
-     * Add event listener
-     */
-    on(event, listener) {
-        if (!this.eventListeners.has(event)) {
-            this.eventListeners.set(event, new Set());
-        }
-        this.eventListeners.get(event).add(listener);
-    }
-    /**
-     * Remove event listener
-     */
-    off(event, listener) {
-        const listeners = this.eventListeners.get(event);
-        if (listeners) {
-            listeners.delete(listener);
-        }
-    }
-    /**
-     * Emit event
-     */
-    emit(event, ...args) {
-        const listeners = this.eventListeners.get(event);
-        if (listeners) {
-            listeners.forEach(listener => {
-                listener(...args);
-            });
-        }
-    }
-    /**
-     * Add a media track to the connection
-     */
-    addTrack(track, ...streams) {
-        return this.pc.addTrack(track, ...streams);
-    }
-    /**
-     * Close the connection and clean up
-     */
-    close() {
-        this.stopPolling();
-        this.pc.close();
-        this.eventListeners.clear();
-    }
-}

package/dist/discovery.d.ts

@@ -1,93 +0,0 @@
-import RondevuPeer from './peer/index.js';
-/**
- * Service info from discovery
- */
-export interface ServiceInfo {
-    uuid: string;
-    isPublic: boolean;
-    serviceFqn?: string;
-    metadata?: Record<string, any>;
-}
-/**
- * Service list result
- */
-export interface ServiceListResult {
-    username: string;
-    services: ServiceInfo[];
-}
-/**
- * Service query result
- */
-export interface ServiceQueryResult {
-    uuid: string;
-    allowed: boolean;
-}
-/**
- * Service details
- */
-export interface ServiceDetails {
-    serviceId: string;
-    username: string;
-    serviceFqn: string;
-    offerId: string;
-    sdp: string;
-    isPublic: boolean;
-    metadata?: Record<string, any>;
-    createdAt: number;
-    expiresAt: number;
-}
-/**
- * Connect result
- */
-export interface ConnectResult {
-    peer: RondevuPeer;
-    channel: RTCDataChannel;
-}
-/**
- * Rondevu Discovery API
- * Handles service discovery and connections
- */
-export declare class RondevuDiscovery {
-    private baseUrl;
-    private credentials;
-    private offersApi;
-    constructor(baseUrl: string, credentials: {
-        peerId: string;
-        secret: string;
-    });
-    /**
-     * Lists all services for a username
-     * Returns UUIDs only for private services, full details for public
-     */
-    listServices(username: string): Promise<ServiceListResult>;
-    /**
-     * Queries a service by FQN
-     * Returns UUID if service exists and is allowed
-     */
-    queryService(username: string, serviceFqn: string): Promise<ServiceQueryResult>;
-    /**
-     * Gets service details by UUID
-     */
-    getServiceDetails(uuid: string): Promise<ServiceDetails>;
-    /**
-     * Connects to a service by UUID
-     */
-    connectToService(uuid: string, options?: {
-        rtcConfig?: RTCConfiguration;
-        onConnected?: () => void;
-        onData?: (data: any) => void;
-    }): Promise<RondevuPeer>;
-    /**
-     * Convenience method: Query and connect in one call
-     * Returns both peer and data channel
-     */
-    connect(username: string, serviceFqn: string, options?: {
-        rtcConfig?: RTCConfiguration;
-    }): Promise<ConnectResult>;
-    /**
-     * Convenience method: Connect to service by UUID with channel
-     */
-    connectByUuid(uuid: string, options?: {
-        rtcConfig?: RTCConfiguration;
-    }): Promise<ConnectResult>;
-}