@xtr-dev/rondevu-client 0.18.10 → 0.21.1

package/dist/offerer-connection.js

@@ -1,177 +0,0 @@
-/**
- * Offerer-side WebRTC connection with offer creation and answer processing
- */
-import { RondevuConnection } from './connection.js';
-import { ConnectionState } from './connection-events.js';
-/**
- * Offerer connection - manages already-created offers and waits for answers
- */
-export class OffererConnection extends RondevuConnection {
-    constructor(options) {
-        super(undefined, options.config); // rtcConfig not needed, PC already created
-        this.api = options.api;
-        this.serviceFqn = options.serviceFqn;
-        this.offerId = options.offerId;
-        // Use the already-created peer connection and data channel
-        this.pc = options.pc;
-        this.dc = options.dc || null;
-    }
-    /**
-     * Initialize the connection - setup handlers for already-created offer
-     */
-    async initialize() {
-        this.debug('Initializing offerer connection');
-        if (!this.pc)
-            throw new Error('Peer connection not provided');
-        // Setup peer connection event handlers
-        this.pc.onicecandidate = (event) => this.handleIceCandidate(event);
-        this.pc.oniceconnectionstatechange = () => this.handleIceConnectionStateChange();
-        this.pc.onconnectionstatechange = () => this.handleConnectionStateChange();
-        this.pc.onicegatheringstatechange = () => this.handleIceGatheringStateChange();
-        // Setup data channel handlers if we have one
-        if (this.dc) {
-            this.setupDataChannelHandlers(this.dc);
-        }
-        // Start connection timeout
-        this.startConnectionTimeout();
-        // Transition to signaling state (offer already created and published)
-        this.transitionTo(ConnectionState.SIGNALING, 'Offer published, waiting for answer');
-    }
-    /**
-     * Process an answer from the answerer
-     */
-    async processAnswer(sdp, answererId) {
-        if (!this.pc) {
-            this.debug('Cannot process answer: peer connection not initialized');
-            return;
-        }
-        // Generate SDP fingerprint for deduplication
-        const fingerprint = await this.hashSdp(sdp);
-        // Check for duplicate answer
-        if (this.answerProcessed) {
-            if (this.answerSdpFingerprint === fingerprint) {
-                this.debug('Duplicate answer detected (same fingerprint), skipping');
-                this.emit('answer:duplicate', this.offerId);
-                return;
-            }
-            else {
-                throw new Error('Received different answer after already processing one (protocol violation)');
-            }
-        }
-        // Validate state
-        if (this.state !== ConnectionState.SIGNALING && this.state !== ConnectionState.CHECKING) {
-            this.debug(`Cannot process answer in state ${this.state}`);
-            return;
-        }
-        // Mark as processed BEFORE setRemoteDescription to prevent race conditions
-        this.answerProcessed = true;
-        this.answerSdpFingerprint = fingerprint;
-        try {
-            await this.pc.setRemoteDescription({
-                type: 'answer',
-                sdp,
-            });
-            this.debug(`Answer processed successfully from ${answererId}`);
-            this.emit('answer:processed', this.offerId, answererId);
-        }
-        catch (error) {
-            // Reset flags on error so we can try again
-            this.answerProcessed = false;
-            this.answerSdpFingerprint = null;
-            this.debug('Failed to set remote description:', error);
-            throw error;
-        }
-    }
-    /**
-     * Generate a hash fingerprint of SDP for deduplication
-     */
-    async hashSdp(sdp) {
-        // Simple hash using built-in crypto if available
-        if (typeof crypto !== 'undefined' && crypto.subtle) {
-            const encoder = new TextEncoder();
-            const data = encoder.encode(sdp);
-            const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-            const hashArray = Array.from(new Uint8Array(hashBuffer));
-            return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
-        }
-        else {
-            // Fallback: use simple string hash
-            let hash = 0;
-            for (let i = 0; i < sdp.length; i++) {
-                const char = sdp.charCodeAt(i);
-                hash = (hash << 5) - hash + char;
-                hash = hash & hash;
-            }
-            return hash.toString(16);
-        }
-    }
-    /**
-     * Handle local ICE candidate generation
-     */
-    onLocalIceCandidate(candidate) {
-        this.debug('Generated local ICE candidate');
-        // Send ICE candidate to server
-        this.api
-            .addOfferIceCandidates(this.serviceFqn, this.offerId, [
-            {
-                candidate: candidate.candidate,
-                sdpMLineIndex: candidate.sdpMLineIndex,
-                sdpMid: candidate.sdpMid,
-            },
-        ])
-            .catch((error) => {
-            this.debug('Failed to send ICE candidate:', error);
-        });
-    }
-    /**
-     * Poll for remote ICE candidates
-     */
-    pollIceCandidates() {
-        this.api
-            .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastIcePollTime)
-            .then((result) => {
-            if (result.candidates.length > 0) {
-                this.debug(`Received ${result.candidates.length} remote ICE candidates`);
-                for (const iceCandidate of result.candidates) {
-                    if (iceCandidate.candidate && this.pc) {
-                        const candidate = iceCandidate.candidate;
-                        this.pc
-                            .addIceCandidate(new RTCIceCandidate(candidate))
-                            .then(() => {
-                            this.emit('ice:candidate:remote', new RTCIceCandidate(candidate));
-                        })
-                            .catch((error) => {
-                            this.debug('Failed to add ICE candidate:', error);
-                        });
-                    }
-                    // Update last poll time
-                    if (iceCandidate.createdAt > this.lastIcePollTime) {
-                        this.lastIcePollTime = iceCandidate.createdAt;
-                    }
-                }
-            }
-        })
-            .catch((error) => {
-            this.debug('Failed to poll ICE candidates:', error);
-        });
-    }
-    /**
-     * Attempt to reconnect
-     *
-     * Note: For offerer connections, reconnection is handled by the Rondevu instance
-     * creating a new offer via fillOffers(). This method is a no-op.
-     */
-    attemptReconnect() {
-        this.debug('Reconnection not applicable for offerer - new offer will be created by Rondevu instance');
-        // Offerer reconnection is handled externally by Rondevu.fillOffers()
-        // which creates entirely new offers. We don't reconnect the same offer.
-        // Just emit failure and let the parent handle it.
-        this.emit('reconnect:failed', new Error('Offerer reconnection handled by parent'));
-    }
-    /**
-     * Get the offer ID
-     */
-    getOfferId() {
-        return this.offerId;
-    }
-}

package/dist/rondevu-signaler.d.ts

@@ -1,112 +0,0 @@
-import { Signaler, Binnable } from './types.js';
-import { Rondevu } from './rondevu.js';
-export interface PollingConfig {
-    initialInterval?: number;
-    maxInterval?: number;
-    backoffMultiplier?: number;
-    maxRetries?: number;
-    jitter?: boolean;
-}
-/**
- * RondevuSignaler - Handles WebRTC signaling via Rondevu service
- *
- * Manages offer/answer exchange and ICE candidate polling for establishing
- * WebRTC connections through the Rondevu signaling server.
- *
- * Supports configurable polling with exponential backoff and jitter to reduce
- * server load and prevent thundering herd issues.
- *
- * @example
- * ```typescript
- * const signaler = new RondevuSignaler(
- *   rondevuService,
- *   'chat.app@1.0.0',
- *   'peer-username',
- *   { initialInterval: 500, maxInterval: 5000, jitter: true }
- * )
- *
- * // For offerer:
- * await signaler.setOffer(offer)
- * signaler.addAnswerListener(answer => {
- *   // Handle remote answer
- * })
- *
- * // For answerer:
- * signaler.addOfferListener(offer => {
- *   // Handle remote offer
- * })
- * await signaler.setAnswer(answer)
- * ```
- */
-export declare class RondevuSignaler implements Signaler {
-    private readonly rondevu;
-    private readonly service;
-    private readonly host?;
-    private offerId;
-    private serviceFqn;
-    private offerListeners;
-    private answerListeners;
-    private iceListeners;
-    private pollingTimeout;
-    private icePollingTimeout;
-    private lastPollTimestamp;
-    private isPolling;
-    private isOfferer;
-    private pollingConfig;
-    constructor(rondevu: Rondevu, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
-    /**
-     * Publish an offer as a service
-     * Used by the offerer to make their offer available
-     */
-    setOffer(offer: RTCSessionDescriptionInit): Promise<void>;
-    /**
-     * Send an answer to the offerer
-     * Used by the answerer to respond to an offer
-     */
-    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>;
-    /**
-     * Listen for incoming offers
-     * Used by the answerer to receive offers from the offerer
-     */
-    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
-    /**
-     * Listen for incoming answers
-     * Used by the offerer to receive the answer from the answerer
-     */
-    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable;
-    /**
-     * Send an ICE candidate to the remote peer
-     */
-    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
-    /**
-     * Listen for ICE candidates from the remote peer
-     */
-    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;
-    /**
-     * Search for an offer from the host
-     * Used by the answerer to find the offerer's service
-     */
-    private searchForOffer;
-    /**
-     * Start combined polling for answers and ICE candidates (offerer side)
-     * Uses poll() for efficient batch polling
-     */
-    private startPolling;
-    /**
-     * Stop combined polling
-     */
-    private stopPolling;
-    /**
-     * Start polling for ICE candidates (answerer side only)
-     * Answerers use the separate endpoint since they don't have offers to poll
-     */
-    private startIcePolling;
-    /**
-     * Stop polling for ICE candidates
-     */
-    private stopIcePolling;
-    /**
-     * Stop all polling and cleanup
-     */
-    dispose(): void;
-}

package/dist/rondevu-signaler.js

@@ -1,401 +0,0 @@
-/**
- * RondevuSignaler - Handles WebRTC signaling via Rondevu service
- *
- * Manages offer/answer exchange and ICE candidate polling for establishing
- * WebRTC connections through the Rondevu signaling server.
- *
- * Supports configurable polling with exponential backoff and jitter to reduce
- * server load and prevent thundering herd issues.
- *
- * @example
- * ```typescript
- * const signaler = new RondevuSignaler(
- *   rondevuService,
- *   'chat.app@1.0.0',
- *   'peer-username',
- *   { initialInterval: 500, maxInterval: 5000, jitter: true }
- * )
- *
- * // For offerer:
- * await signaler.setOffer(offer)
- * signaler.addAnswerListener(answer => {
- *   // Handle remote answer
- * })
- *
- * // For answerer:
- * signaler.addOfferListener(offer => {
- *   // Handle remote offer
- * })
- * await signaler.setAnswer(answer)
- * ```
- */
-export class RondevuSignaler {
-    constructor(rondevu, service, host, pollingConfig) {
-        this.rondevu = rondevu;
-        this.service = service;
-        this.host = host;
-        this.offerId = null;
-        this.serviceFqn = null;
-        this.offerListeners = [];
-        this.answerListeners = [];
-        this.iceListeners = [];
-        this.pollingTimeout = null;
-        this.icePollingTimeout = null;
-        this.lastPollTimestamp = 0;
-        this.isPolling = false;
-        this.isOfferer = false;
-        this.pollingConfig = {
-            initialInterval: pollingConfig?.initialInterval ?? 500,
-            maxInterval: pollingConfig?.maxInterval ?? 5000,
-            backoffMultiplier: pollingConfig?.backoffMultiplier ?? 1.5,
-            maxRetries: pollingConfig?.maxRetries ?? 50,
-            jitter: pollingConfig?.jitter ?? true
-        };
-    }
-    /**
-     * Publish an offer as a service
-     * Used by the offerer to make their offer available
-     */
-    async setOffer(offer) {
-        if (!offer.sdp) {
-            throw new Error('Offer SDP is required');
-        }
-        // Publish service with the offer SDP
-        const publishedService = await this.rondevu.publishService({
-            serviceFqn: this.service,
-            offers: [{ sdp: offer.sdp }],
-            ttl: 300000, // 5 minutes
-        });
-        // Get the first offer from the published service
-        if (!publishedService.offers || publishedService.offers.length === 0) {
-            throw new Error('No offers returned from service publication');
-        }
-        this.offerId = publishedService.offers[0].offerId;
-        this.serviceFqn = publishedService.serviceFqn;
-        this.isOfferer = true;
-        // Start combined polling for answers and ICE candidates
-        this.startPolling();
-    }
-    /**
-     * Send an answer to the offerer
-     * Used by the answerer to respond to an offer
-     */
-    async setAnswer(answer) {
-        if (!answer.sdp) {
-            throw new Error('Answer SDP is required');
-        }
-        if (!this.serviceFqn || !this.offerId) {
-            throw new Error('No service FQN or offer ID available. Must receive offer first.');
-        }
-        // Send answer to the service
-        await this.rondevu.getAPIPublic().answerOffer(this.serviceFqn, this.offerId, answer.sdp);
-        this.isOfferer = false;
-        // Start polling for ICE candidates (answerer uses separate endpoint)
-        this.startIcePolling();
-    }
-    /**
-     * Listen for incoming offers
-     * Used by the answerer to receive offers from the offerer
-     */
-    addOfferListener(callback) {
-        this.offerListeners.push(callback);
-        // If we have a host, start searching for their service
-        if (this.host && !this.isPolling) {
-            this.searchForOffer();
-        }
-        // Return cleanup function
-        return () => {
-            const index = this.offerListeners.indexOf(callback);
-            if (index > -1) {
-                this.offerListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Listen for incoming answers
-     * Used by the offerer to receive the answer from the answerer
-     */
-    addAnswerListener(callback) {
-        this.answerListeners.push(callback);
-        // Return cleanup function
-        return () => {
-            const index = this.answerListeners.indexOf(callback);
-            if (index > -1) {
-                this.answerListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Send an ICE candidate to the remote peer
-     */
-    async addIceCandidate(candidate) {
-        if (!this.serviceFqn || !this.offerId) {
-            console.warn('Cannot send ICE candidate: no service FQN or offer ID');
-            return;
-        }
-        const candidateData = candidate.toJSON();
-        // Skip empty candidates
-        if (!candidateData.candidate || candidateData.candidate === '') {
-            return;
-        }
-        try {
-            await this.rondevu.getAPIPublic().addOfferIceCandidates(this.serviceFqn, this.offerId, [candidateData]);
-        }
-        catch (err) {
-            console.error('Failed to send ICE candidate:', err);
-        }
-    }
-    /**
-     * Listen for ICE candidates from the remote peer
-     */
-    addListener(callback) {
-        this.iceListeners.push(callback);
-        // Return cleanup function
-        return () => {
-            const index = this.iceListeners.indexOf(callback);
-            if (index > -1) {
-                this.iceListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Search for an offer from the host
-     * Used by the answerer to find the offerer's service
-     */
-    async searchForOffer() {
-        if (!this.host) {
-            throw new Error('No host specified for offer search');
-        }
-        this.isPolling = true;
-        try {
-            // Get service by FQN (service should include @username)
-            const serviceFqn = `${this.service}@${this.host}`;
-            const serviceData = await this.rondevu.getAPIPublic().getService(serviceFqn);
-            if (!serviceData) {
-                console.warn(`No service found for ${serviceFqn}`);
-                this.isPolling = false;
-                return;
-            }
-            // Store service details
-            this.offerId = serviceData.offerId;
-            this.serviceFqn = serviceData.serviceFqn;
-            // Notify offer listeners
-            const offer = {
-                type: 'offer',
-                sdp: serviceData.sdp,
-            };
-            this.offerListeners.forEach(listener => {
-                try {
-                    listener(offer);
-                }
-                catch (err) {
-                    console.error('Offer listener error:', err);
-                }
-            });
-        }
-        catch (err) {
-            console.error('Failed to search for offer:', err);
-            this.isPolling = false;
-        }
-    }
-    /**
-     * Start combined polling for answers and ICE candidates (offerer side)
-     * Uses poll() for efficient batch polling
-     */
-    startPolling() {
-        if (this.pollingTimeout || !this.isOfferer) {
-            return;
-        }
-        let interval = this.pollingConfig.initialInterval;
-        let retries = 0;
-        let answerReceived = false;
-        const poll = async () => {
-            try {
-                const result = await this.rondevu.poll(this.lastPollTimestamp);
-                let foundActivity = false;
-                // Process answers
-                if (result.answers.length > 0 && !answerReceived) {
-                    foundActivity = true;
-                    // Find answer for our offerId
-                    const answer = result.answers.find(a => a.offerId === this.offerId);
-                    if (answer && answer.sdp) {
-                        answerReceived = true;
-                        const answerDesc = {
-                            type: 'answer',
-                            sdp: answer.sdp,
-                        };
-                        this.answerListeners.forEach(listener => {
-                            try {
-                                listener(answerDesc);
-                            }
-                            catch (err) {
-                                console.error('Answer listener error:', err);
-                            }
-                        });
-                        this.lastPollTimestamp = Math.max(this.lastPollTimestamp, answer.answeredAt);
-                    }
-                }
-                // Process ICE candidates for our offer
-                if (this.offerId && result.iceCandidates[this.offerId]) {
-                    const candidates = result.iceCandidates[this.offerId];
-                    // Filter for answerer candidates (offerer receives answerer's candidates)
-                    const answererCandidates = candidates.filter(c => c.role === 'answerer');
-                    if (answererCandidates.length > 0) {
-                        foundActivity = true;
-                        for (const item of answererCandidates) {
-                            if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
-                                try {
-                                    const rtcCandidate = new RTCIceCandidate(item.candidate);
-                                    this.iceListeners.forEach(listener => {
-                                        try {
-                                            listener(rtcCandidate);
-                                        }
-                                        catch (err) {
-                                            console.error('ICE listener error:', err);
-                                        }
-                                    });
-                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
-                                }
-                                catch (err) {
-                                    console.warn('Failed to process ICE candidate:', err);
-                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
-                                }
-                            }
-                        }
-                    }
-                }
-                // Adjust interval based on activity
-                if (foundActivity) {
-                    interval = this.pollingConfig.initialInterval;
-                    retries = 0;
-                }
-                else {
-                    retries++;
-                    if (retries > this.pollingConfig.maxRetries) {
-                        console.warn('Max retries reached for polling');
-                        this.stopPolling();
-                        return;
-                    }
-                    interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
-                }
-                // Add jitter to prevent thundering herd
-                const finalInterval = this.pollingConfig.jitter
-                    ? interval + Math.random() * 100
-                    : interval;
-                this.pollingTimeout = setTimeout(poll, finalInterval);
-            }
-            catch (err) {
-                console.error('Error polling offers:', err);
-                // Retry with backoff
-                const finalInterval = this.pollingConfig.jitter
-                    ? interval + Math.random() * 100
-                    : interval;
-                this.pollingTimeout = setTimeout(poll, finalInterval);
-            }
-        };
-        poll(); // Start immediately
-    }
-    /**
-     * Stop combined polling
-     */
-    stopPolling() {
-        if (this.pollingTimeout) {
-            clearTimeout(this.pollingTimeout);
-            this.pollingTimeout = null;
-        }
-    }
-    /**
-     * Start polling for ICE candidates (answerer side only)
-     * Answerers use the separate endpoint since they don't have offers to poll
-     */
-    startIcePolling() {
-        if (this.icePollingTimeout || !this.serviceFqn || !this.offerId || this.isOfferer) {
-            return;
-        }
-        let interval = this.pollingConfig.initialInterval;
-        const poll = async () => {
-            if (!this.serviceFqn || !this.offerId) {
-                this.stopIcePolling();
-                return;
-            }
-            try {
-                const result = await this.rondevu
-                    .getAPIPublic()
-                    .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastPollTimestamp);
-                let foundCandidates = false;
-                for (const item of result.candidates) {
-                    if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
-                        foundCandidates = true;
-                        try {
-                            const rtcCandidate = new RTCIceCandidate(item.candidate);
-                            this.iceListeners.forEach(listener => {
-                                try {
-                                    listener(rtcCandidate);
-                                }
-                                catch (err) {
-                                    console.error('ICE listener error:', err);
-                                }
-                            });
-                            this.lastPollTimestamp = item.createdAt;
-                        }
-                        catch (err) {
-                            console.warn('Failed to process ICE candidate:', err);
-                            this.lastPollTimestamp = item.createdAt;
-                        }
-                    }
-                    else {
-                        this.lastPollTimestamp = item.createdAt;
-                    }
-                }
-                // If candidates found, reset interval to initial value
-                // Otherwise, increase interval with backoff
-                if (foundCandidates) {
-                    interval = this.pollingConfig.initialInterval;
-                }
-                else {
-                    interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
-                }
-                // Add jitter
-                const finalInterval = this.pollingConfig.jitter
-                    ? interval + Math.random() * 100
-                    : interval;
-                this.icePollingTimeout = setTimeout(poll, finalInterval);
-            }
-            catch (err) {
-                // 404/410 means offer expired, stop polling
-                if (err instanceof Error && (err.message?.includes('404') || err.message?.includes('410'))) {
-                    console.warn('Offer not found or expired, stopping ICE polling');
-                    this.stopIcePolling();
-                }
-                else if (err instanceof Error && !err.message?.includes('404')) {
-                    console.error('Error polling for ICE candidates:', err);
-                    // Continue polling despite errors
-                    const finalInterval = this.pollingConfig.jitter
-                        ? interval + Math.random() * 100
-                        : interval;
-                    this.icePollingTimeout = setTimeout(poll, finalInterval);
-                }
-            }
-        };
-        poll(); // Start immediately
-    }
-    /**
-     * Stop polling for ICE candidates
-     */
-    stopIcePolling() {
-        if (this.icePollingTimeout) {
-            clearTimeout(this.icePollingTimeout);
-            this.icePollingTimeout = null;
-        }
-    }
-    /**
-     * Stop all polling and cleanup
-     */
-    dispose() {
-        this.stopPolling();
-        this.stopIcePolling();
-        this.offerListeners = [];
-        this.answerListeners = [];
-        this.iceListeners = [];
-    }
-}