@xtr-dev/rondevu-client 0.9.1 → 0.10.0

package/dist/offer-pool.js

@@ -1,145 +0,0 @@
-/**
- * Manages a pool of offers with automatic polling and refill
- *
- * The OfferPool maintains a configurable number of simultaneous offers,
- * polls for answers periodically, and automatically refills the pool
- * when offers are consumed.
- */
-export class OfferPool {
-    constructor(offersApi, options) {
-        this.offersApi = offersApi;
-        this.options = options;
-        this.offers = new Map();
-        this.peerConnections = new Map();
-        this.dataChannels = new Map();
-        this.polling = false;
-        this.lastPollTime = 0;
-        this.pollingInterval = options.pollingInterval || 2000;
-    }
-    /**
-     * Add offers to the pool with their peer connections and data channels
-     */
-    async addOffers(offers, peerConnections, dataChannels) {
-        for (let i = 0; i < offers.length; i++) {
-            const offer = offers[i];
-            this.offers.set(offer.id, offer);
-            if (peerConnections && peerConnections[i]) {
-                this.peerConnections.set(offer.id, peerConnections[i]);
-            }
-            if (dataChannels && dataChannels[i]) {
-                this.dataChannels.set(offer.id, dataChannels[i]);
-            }
-        }
-    }
-    /**
-     * Start polling for answers
-     */
-    async start() {
-        if (this.polling) {
-            return;
-        }
-        this.polling = true;
-        // Do an immediate poll
-        await this.poll().catch((error) => {
-            this.options.onError(error, 'initial-poll');
-        });
-        // Start polling interval
-        this.pollingTimer = setInterval(async () => {
-            if (this.polling) {
-                await this.poll().catch((error) => {
-                    this.options.onError(error, 'poll');
-                });
-            }
-        }, this.pollingInterval);
-    }
-    /**
-     * Stop polling for answers
-     */
-    async stop() {
-        this.polling = false;
-        if (this.pollingTimer) {
-            clearInterval(this.pollingTimer);
-            this.pollingTimer = undefined;
-        }
-    }
-    /**
-     * Poll for answers and refill the pool if needed
-     */
-    async poll() {
-        try {
-            // Get all answers from server
-            const answers = await this.offersApi.getAnswers();
-            // Filter for our pool's offers
-            const myAnswers = answers.filter(a => this.offers.has(a.offerId));
-            // Process each answer
-            for (const answer of myAnswers) {
-                // Get the original offer, peer connection, and data channel
-                const offer = this.offers.get(answer.offerId);
-                const pc = this.peerConnections.get(answer.offerId);
-                const channel = this.dataChannels.get(answer.offerId);
-                if (!offer || !pc) {
-                    continue; // Offer or peer connection already consumed, skip
-                }
-                // Remove from pool BEFORE processing to prevent duplicate processing
-                this.offers.delete(answer.offerId);
-                this.peerConnections.delete(answer.offerId);
-                this.dataChannels.delete(answer.offerId);
-                // Notify ServicePool with answer, original peer connection, and data channel
-                await this.options.onAnswered({
-                    offerId: answer.offerId,
-                    answererId: answer.answererId,
-                    sdp: answer.sdp,
-                    peerConnection: pc,
-                    dataChannel: channel,
-                    answeredAt: answer.answeredAt
-                });
-            }
-            // Immediate refill if below pool size
-            if (this.offers.size < this.options.poolSize) {
-                const needed = this.options.poolSize - this.offers.size;
-                try {
-                    const result = await this.options.onRefill(needed);
-                    await this.addOffers(result.offers, result.peerConnections, result.dataChannels);
-                }
-                catch (refillError) {
-                    this.options.onError(refillError, 'refill');
-                }
-            }
-            this.lastPollTime = Date.now();
-        }
-        catch (error) {
-            // Don't crash the pool on errors - let error handler deal with it
-            this.options.onError(error, 'poll');
-        }
-    }
-    /**
-     * Get the current number of active offers in the pool
-     */
-    getActiveOfferCount() {
-        return this.offers.size;
-    }
-    /**
-     * Get all active offer IDs
-     */
-    getActiveOfferIds() {
-        return Array.from(this.offers.keys());
-    }
-    /**
-     * Get all active peer connections
-     */
-    getActivePeerConnections() {
-        return Array.from(this.peerConnections.values());
-    }
-    /**
-     * Get the last poll timestamp
-     */
-    getLastPollTime() {
-        return this.lastPollTime;
-    }
-    /**
-     * Check if the pool is currently polling
-     */
-    isPolling() {
-        return this.polling;
-    }
-}

package/dist/offers.d.ts

@@ -1,101 +0,0 @@
-import { Credentials, FetchFunction } from './auth.js';
-export interface CreateOfferRequest {
-    sdp: string;
-    topics: string[];
-    ttl?: number;
-    secret?: string;
-    info?: string;
-}
-export interface Offer {
-    id: string;
-    peerId: string;
-    sdp: string;
-    topics: string[];
-    createdAt?: number;
-    expiresAt: number;
-    lastSeen: number;
-    secret?: string;
-    hasSecret?: boolean;
-    info?: string;
-    answererPeerId?: string;
-    answerSdp?: string;
-    answeredAt?: number;
-}
-export interface IceCandidate {
-    candidate: any;
-    peerId: string;
-    role: 'offerer' | 'answerer';
-    createdAt: number;
-}
-export interface TopicInfo {
-    topic: string;
-    activePeers: number;
-}
-export declare class RondevuOffers {
-    private baseUrl;
-    private credentials;
-    private fetchFn;
-    constructor(baseUrl: string, credentials: Credentials, fetchFn?: FetchFunction);
-    /**
-     * Create one or more offers
-     */
-    create(offers: CreateOfferRequest[]): Promise<Offer[]>;
-    /**
-     * Find offers by topic with optional bloom filter
-     */
-    findByTopic(topic: string, options?: {
-        bloomFilter?: Uint8Array;
-        limit?: number;
-    }): Promise<Offer[]>;
-    /**
-     * Get all offers from a specific peer
-     */
-    getByPeerId(peerId: string): Promise<{
-        offers: Offer[];
-        topics: string[];
-    }>;
-    /**
-     * Get topics with active peer counts (paginated)
-     */
-    getTopics(options?: {
-        limit?: number;
-        offset?: number;
-        startsWith?: string;
-    }): Promise<{
-        topics: TopicInfo[];
-        total: number;
-        limit: number;
-        offset: number;
-        startsWith?: string;
-    }>;
-    /**
-     * Get own offers
-     */
-    getMine(): Promise<Offer[]>;
-    /**
-     * Delete an offer
-     */
-    delete(offerId: string): Promise<void>;
-    /**
-     * Answer an offer
-     */
-    answer(offerId: string, sdp: string, secret?: string): Promise<void>;
-    /**
-     * Get answers to your offers
-     */
-    getAnswers(): Promise<Array<{
-        offerId: string;
-        answererId: string;
-        sdp: string;
-        answeredAt: number;
-        topics: string[];
-    }>>;
-    /**
-     * Post ICE candidates for an offer
-     */
-    addIceCandidates(offerId: string, candidates: any[]): Promise<void>;
-    /**
-     * Get ICE candidates for an offer
-     */
-    getIceCandidates(offerId: string, since?: number): Promise<IceCandidate[]>;
-}

package/dist/offers.js

@@ -1,202 +0,0 @@
-import { RondevuAuth } from './auth.js';
-export class RondevuOffers {
-    constructor(baseUrl, credentials, fetchFn) {
-        this.baseUrl = baseUrl;
-        this.credentials = credentials;
-        // Use provided fetch or fall back to global fetch
-        this.fetchFn = fetchFn || ((...args) => {
-            if (typeof globalThis.fetch === 'function') {
-                return globalThis.fetch(...args);
-            }
-            throw new Error('fetch is not available. Please provide a fetch implementation in the constructor options.');
-        });
-    }
-    /**
-     * Create one or more offers
-     */
-    async create(offers) {
-        const response = await this.fetchFn(`${this.baseUrl}/offers`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-            body: JSON.stringify({ offers }),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to create offers: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return data.offers;
-    }
-    /**
-     * Find offers by topic with optional bloom filter
-     */
-    async findByTopic(topic, options) {
-        const params = new URLSearchParams();
-        if (options?.bloomFilter) {
-            // Convert to base64
-            const binaryString = String.fromCharCode(...Array.from(options.bloomFilter));
-            const base64 = typeof btoa !== 'undefined'
-                ? btoa(binaryString)
-                : (typeof Buffer !== 'undefined' ? Buffer.from(options.bloomFilter).toString('base64') : '');
-            params.set('bloom', base64);
-        }
-        if (options?.limit) {
-            params.set('limit', options.limit.toString());
-        }
-        const url = `${this.baseUrl}/offers/by-topic/${encodeURIComponent(topic)}${params.toString() ? '?' + params.toString() : ''}`;
-        const response = await this.fetchFn(url, {
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to find offers: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return data.offers;
-    }
-    /**
-     * Get all offers from a specific peer
-     */
-    async getByPeerId(peerId) {
-        const response = await this.fetchFn(`${this.baseUrl}/peers/${encodeURIComponent(peerId)}/offers`, {
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get peer offers: ${error.error || response.statusText}`);
-        }
-        return await response.json();
-    }
-    /**
-     * Get topics with active peer counts (paginated)
-     */
-    async getTopics(options) {
-        const params = new URLSearchParams();
-        if (options?.limit) {
-            params.set('limit', options.limit.toString());
-        }
-        if (options?.offset) {
-            params.set('offset', options.offset.toString());
-        }
-        if (options?.startsWith) {
-            params.set('startsWith', options.startsWith);
-        }
-        const url = `${this.baseUrl}/topics${params.toString() ? '?' + params.toString() : ''}`;
-        const response = await this.fetchFn(url, {
-            method: 'GET',
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get topics: ${error.error || response.statusText}`);
-        }
-        return await response.json();
-    }
-    /**
-     * Get own offers
-     */
-    async getMine() {
-        const response = await this.fetchFn(`${this.baseUrl}/offers/mine`, {
-            method: 'GET',
-            headers: {
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get own offers: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return data.offers;
-    }
-    /**
-     * Delete an offer
-     */
-    async delete(offerId) {
-        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}`, {
-            method: 'DELETE',
-            headers: {
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to delete offer: ${error.error || response.statusText}`);
-        }
-    }
-    /**
-     * Answer an offer
-     */
-    async answer(offerId, sdp, secret) {
-        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/answer`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-            body: JSON.stringify({ sdp, secret }),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to answer offer: ${error.error || response.statusText}`);
-        }
-    }
-    /**
-     * Get answers to your offers
-     */
-    async getAnswers() {
-        const response = await this.fetchFn(`${this.baseUrl}/offers/answers`, {
-            method: 'GET',
-            headers: {
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get answers: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return data.answers;
-    }
-    /**
-     * Post ICE candidates for an offer
-     */
-    async addIceCandidates(offerId, candidates) {
-        const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/ice-candidates`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-            body: JSON.stringify({ candidates }),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to add ICE candidates: ${error.error || response.statusText}`);
-        }
-    }
-    /**
-     * Get ICE candidates for an offer
-     */
-    async getIceCandidates(offerId, since) {
-        const params = new URLSearchParams();
-        if (since !== undefined) {
-            params.set('since', since.toString());
-        }
-        const url = `${this.baseUrl}/offers/${encodeURIComponent(offerId)}/ice-candidates${params.toString() ? '?' + params.toString() : ''}`;
-        const response = await this.fetchFn(url, {
-            method: 'GET',
-            headers: {
-                Authorization: RondevuAuth.createAuthHeader(this.credentials),
-            },
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return data.candidates;
-    }
-}

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

@@ -1,11 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-/**
- * Answering an offer and sending to server
- */
-export declare class AnsweringState extends PeerState {
-    constructor(peer: RondevuPeer);
-    get name(): string;
-    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
-}

package/dist/peer/answering-state.js

@@ -1,39 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Answering an offer and sending to server
- */
-export 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();
-            // Send answer to server BEFORE setLocalDescription
-            // This registers us as the answerer so ICE candidates will be accepted
-            await this.peer.offersApi.answer(offerId, answer.sdp, options.secret);
-            // Enable trickle ICE - set up handler before ICE gathering starts
-            this.setupIceCandidateHandler();
-            // Set local description - ICE gathering starts here
-            // Server already knows we're the answerer, so candidates will be accepted
-            await this.peer.pc.setLocalDescription(answer);
-            // Transition to exchanging ICE
-            const { ExchangingIceState } = await import('./exchanging-ice-state.js');
-            this.peer.setState(new ExchangingIceState(this.peer, offerId, options));
-        }
-        catch (error) {
-            const { FailedState } = await import('./failed-state.js');
-            this.peer.setState(new FailedState(this.peer, error));
-            throw error;
-        }
-    }
-}

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

@@ -1,8 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Closed state - connection has been terminated
- */
-export declare class ClosedState extends PeerState {
-    get name(): string;
-    cleanup(): void;
-}

package/dist/peer/closed-state.js

@@ -1,10 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Closed state - connection has been terminated
- */
-export class ClosedState extends PeerState {
-    get name() { return 'closed'; }
-    cleanup() {
-        this.peer.pc.close();
-    }
-}

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

@@ -1,8 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Connected state - peer connection is established
- */
-export declare class ConnectedState extends PeerState {
-    get name(): string;
-    cleanup(): void;
-}

package/dist/peer/connected-state.js

@@ -1,11 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Connected state - peer connection is established
- */
-export class ConnectedState extends PeerState {
-    get name() { return 'connected'; }
-    cleanup() {
-        // Keep connection alive, but stop any polling
-        // The peer connection will handle disconnects via onconnectionstatechange
-    }
-}

package/dist/peer/creating-offer-state.d.ts

@@ -1,12 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-/**
- * Creating offer and sending to server
- */
-export declare class CreatingOfferState extends PeerState {
-    private options;
-    constructor(peer: RondevuPeer, options: PeerOptions);
-    get name(): string;
-    createOffer(options: PeerOptions): Promise<string>;
-}

package/dist/peer/creating-offer-state.js

@@ -1,45 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Creating offer and sending to server
- */
-export 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);
-            }
-            // Enable trickle ICE - set up handler before ICE gathering starts
-            // Handler will check this.peer.offerId before sending
-            this.setupIceCandidateHandler();
-            // Create WebRTC offer
-            const offer = await this.peer.pc.createOffer();
-            await this.peer.pc.setLocalDescription(offer); // ICE gathering starts here
-            // 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,
-                    secret: options.secret
-                }]);
-            const offerId = offers[0].id;
-            this.peer.offerId = offerId; // Now handler can send candidates
-            // Transition to waiting for answer
-            const { WaitingForAnswerState } = await import('./waiting-for-answer-state.js');
-            this.peer.setState(new WaitingForAnswerState(this.peer, offerId, options));
-            return offerId;
-        }
-        catch (error) {
-            const { FailedState } = await import('./failed-state.js');
-            this.peer.setState(new FailedState(this.peer, error));
-            throw error;
-        }
-    }
-}

package/dist/peer/exchanging-ice-state.d.ts

@@ -1,17 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-/**
- * Exchanging ICE candidates and waiting for connection
- */
-export declare class ExchangingIceState extends PeerState {
-    private offerId;
-    private options;
-    private pollingInterval?;
-    private timeout?;
-    private lastIceTimestamp;
-    constructor(peer: RondevuPeer, offerId: string, options: PeerOptions);
-    get name(): string;
-    private startPolling;
-    cleanup(): void;
-}

package/dist/peer/exchanging-ice-state.js

@@ -1,64 +0,0 @@
-import { PeerState } from './state.js';
-/**
- * Exchanging ICE candidates and waiting for connection
- */
-export 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(async () => {
-            this.cleanup();
-            const { FailedState } = await import('./failed-state.js');
-            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);
-                if (candidates.length > 0) {
-                    console.log(`📥 Received ${candidates.length} remote ICE candidate(s)`);
-                }
-                for (const cand of candidates) {
-                    if (cand.candidate && cand.candidate.candidate && cand.candidate.candidate !== '') {
-                        const type = cand.candidate.candidate.includes('typ host') ? 'host' :
-                            cand.candidate.candidate.includes('typ srflx') ? 'srflx' :
-                                cand.candidate.candidate.includes('typ relay') ? 'relay' : 'unknown';
-                        console.log(`🧊 Adding remote ${type} ICE candidate:`, cand.candidate.candidate);
-                        try {
-                            await this.peer.pc.addIceCandidate(new this.peer.RTCIceCandidate(cand.candidate));
-                            console.log(`✅ Added remote ${type} ICE candidate`);
-                            this.lastIceTimestamp = cand.createdAt;
-                        }
-                        catch (err) {
-                            console.warn(`⚠️ Failed to add remote ${type} 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();
-                    const { FailedState } = await import('./failed-state.js');
-                    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);
-    }
-}