@xtr-dev/rondevu-client 0.9.2 → 0.10.0

package/dist/durable/service.js

@@ -1,264 +0,0 @@
-/**
- * DurableService - Service with automatic TTL refresh
- *
- * Manages service publishing with automatic reconnection for incoming
- * connections and TTL auto-refresh to prevent expiration.
- */
-import { EventEmitter } from '../event-emitter.js';
-import { ServicePool } from '../service-pool.js';
-import { DurableChannel } from './channel.js';
-/**
- * Default configuration for durable services
- */
-const DEFAULT_CONFIG = {
-    isPublic: false,
-    ttlRefreshMargin: 0.2,
-    poolSize: 1,
-    pollingInterval: 2000,
-    maxReconnectAttempts: 10,
-    reconnectBackoffBase: 1000,
-    reconnectBackoffMax: 30000,
-    reconnectJitter: 0.2,
-    connectionTimeout: 30000,
-    maxQueueSize: 1000,
-    maxMessageAge: 60000,
-    rtcConfig: {
-        iceServers: [
-            { urls: 'stun:stun.l.google.com:19302' },
-            { urls: 'stun:stun1.l.google.com:19302' }
-        ]
-    }
-};
-/**
- * Durable service that automatically refreshes TTL and handles reconnections
- *
- * The DurableService manages service publishing and provides:
- * - Automatic TTL refresh before expiration
- * - Durable connections for incoming peers
- * - Connection pooling for multiple simultaneous connections
- * - High-level connection lifecycle events
- *
- * @example
- * ```typescript
- * const service = new DurableService(
- *   offersApi,
- *   (channel, connectionId) => {
- *     channel.on('message', (data) => {
- *       console.log(`Message from ${connectionId}:`, data);
- *       channel.send(`Echo: ${data}`);
- *     });
- *   },
- *   {
- *     username: 'alice',
- *     privateKey: keypair.privateKey,
- *     serviceFqn: 'chat@1.0.0',
- *     poolSize: 10
- *   }
- * );
- *
- * service.on('published', (serviceId, uuid) => {
- *   console.log(`Service published: ${uuid}`);
- * });
- *
- * service.on('connection', (connectionId) => {
- *   console.log(`New connection: ${connectionId}`);
- * });
- *
- * await service.start();
- * ```
- */
-export class DurableService extends EventEmitter {
-    constructor(offersApi, baseUrl, credentials, handler, config) {
-        super();
-        this.offersApi = offersApi;
-        this.baseUrl = baseUrl;
-        this.credentials = credentials;
-        this.handler = handler;
-        this.activeChannels = new Map();
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Start the service
-     *
-     * Publishes the service and begins accepting connections.
-     *
-     * @returns Service information
-     */
-    async start() {
-        if (this.servicePool) {
-            throw new Error('Service already started');
-        }
-        // Create and start service pool
-        this.servicePool = new ServicePool(this.baseUrl, this.credentials, {
-            username: this.config.username,
-            privateKey: this.config.privateKey,
-            serviceFqn: this.config.serviceFqn,
-            rtcConfig: this.config.rtcConfig,
-            isPublic: this.config.isPublic,
-            metadata: this.config.metadata,
-            ttl: this.config.ttl,
-            poolSize: this.config.poolSize,
-            pollingInterval: this.config.pollingInterval,
-            handler: (channel, peer, connectionId) => {
-                this.handleNewConnection(channel, connectionId);
-            },
-            onPoolStatus: (status) => {
-                // Could emit pool status event if needed
-            },
-            onError: (error, context) => {
-                this.emit('error', error, context);
-            }
-        });
-        const handle = await this.servicePool.start();
-        // Store service info
-        this.serviceId = handle.serviceId;
-        this.uuid = handle.uuid;
-        this.expiresAt = Date.now() + (this.config.ttl || 300000); // Default 5 minutes
-        this.emit('published', this.serviceId, this.uuid);
-        // Schedule TTL refresh
-        this.scheduleRefresh();
-        return {
-            serviceId: this.serviceId,
-            uuid: this.uuid,
-            expiresAt: this.expiresAt
-        };
-    }
-    /**
-     * Stop the service
-     *
-     * Unpublishes the service and closes all active connections.
-     */
-    async stop() {
-        // Cancel TTL refresh
-        if (this.ttlRefreshTimer) {
-            clearTimeout(this.ttlRefreshTimer);
-            this.ttlRefreshTimer = undefined;
-        }
-        // Close all active channels
-        for (const channel of this.activeChannels.values()) {
-            channel.close();
-        }
-        this.activeChannels.clear();
-        // Stop service pool
-        if (this.servicePool) {
-            await this.servicePool.stop();
-            this.servicePool = undefined;
-        }
-        this.emit('closed');
-    }
-    /**
-     * Get list of active connection IDs
-     */
-    getActiveConnections() {
-        return Array.from(this.activeChannels.keys());
-    }
-    /**
-     * Get service information
-     */
-    getServiceInfo() {
-        if (!this.serviceId || !this.uuid || !this.expiresAt) {
-            return null;
-        }
-        return {
-            serviceId: this.serviceId,
-            uuid: this.uuid,
-            expiresAt: this.expiresAt
-        };
-    }
-    /**
-     * Schedule TTL refresh
-     */
-    scheduleRefresh() {
-        if (!this.expiresAt || !this.config.ttl) {
-            return;
-        }
-        // Cancel existing timer
-        if (this.ttlRefreshTimer) {
-            clearTimeout(this.ttlRefreshTimer);
-        }
-        // Calculate refresh time (default: refresh at 80% of TTL)
-        const timeUntilExpiry = this.expiresAt - Date.now();
-        const refreshMargin = timeUntilExpiry * this.config.ttlRefreshMargin;
-        const refreshTime = Math.max(0, timeUntilExpiry - refreshMargin);
-        // Schedule refresh
-        this.ttlRefreshTimer = setTimeout(() => {
-            this.refreshServiceTTL().catch(error => {
-                this.emit('error', error, 'ttl-refresh');
-                // Retry after short delay
-                setTimeout(() => this.scheduleRefresh(), 5000);
-            });
-        }, refreshTime);
-    }
-    /**
-     * Refresh service TTL
-     */
-    async refreshServiceTTL() {
-        if (!this.serviceId || !this.uuid) {
-            return;
-        }
-        // Delete old service
-        await this.servicePool?.stop();
-        // Recreate service pool (this republishes the service)
-        this.servicePool = new ServicePool(this.baseUrl, this.credentials, {
-            username: this.config.username,
-            privateKey: this.config.privateKey,
-            serviceFqn: this.config.serviceFqn,
-            rtcConfig: this.config.rtcConfig,
-            isPublic: this.config.isPublic,
-            metadata: this.config.metadata,
-            ttl: this.config.ttl,
-            poolSize: this.config.poolSize,
-            pollingInterval: this.config.pollingInterval,
-            handler: (channel, peer, connectionId) => {
-                this.handleNewConnection(channel, connectionId);
-            },
-            onPoolStatus: (status) => {
-                // Could emit pool status event if needed
-            },
-            onError: (error, context) => {
-                this.emit('error', error, context);
-            }
-        });
-        const handle = await this.servicePool.start();
-        // Update service info
-        this.serviceId = handle.serviceId;
-        this.uuid = handle.uuid;
-        this.expiresAt = Date.now() + (this.config.ttl || 300000);
-        this.emit('ttl-refreshed', this.expiresAt);
-        // Schedule next refresh
-        this.scheduleRefresh();
-    }
-    /**
-     * Handle new incoming connection
-     */
-    handleNewConnection(channel, connectionId) {
-        // Create durable channel
-        const durableChannel = new DurableChannel(channel.label, {
-            maxQueueSize: this.config.maxQueueSize,
-            maxMessageAge: this.config.maxMessageAge
-        });
-        // Attach to underlying channel
-        durableChannel.attachToChannel(channel);
-        // Track channel
-        this.activeChannels.set(connectionId, durableChannel);
-        // Setup cleanup on close
-        durableChannel.on('close', () => {
-            this.activeChannels.delete(connectionId);
-            this.emit('disconnection', connectionId);
-        });
-        // Emit connection event
-        this.emit('connection', connectionId);
-        // Invoke user handler
-        try {
-            const result = this.handler(durableChannel, connectionId);
-            if (result && typeof result.then === 'function') {
-                result.catch(error => {
-                    this.emit('error', error, 'handler');
-                });
-            }
-        }
-        catch (error) {
-            this.emit('error', error, 'handler');
-        }
-    }
-}

package/dist/durable/types.d.ts

@@ -1,149 +0,0 @@
-/**
- * Type definitions for durable WebRTC connections
- *
- * This module defines all interfaces, enums, and types used by the durable
- * connection system for automatic reconnection and message queuing.
- */
-/**
- * Connection state enum
- */
-export declare enum DurableConnectionState {
-    CONNECTING = "connecting",
-    CONNECTED = "connected",
-    RECONNECTING = "reconnecting",
-    DISCONNECTED = "disconnected",
-    FAILED = "failed",
-    CLOSED = "closed"
-}
-/**
- * Channel state enum
- */
-export declare enum DurableChannelState {
-    CONNECTING = "connecting",
-    OPEN = "open",
-    CLOSING = "closing",
-    CLOSED = "closed"
-}
-/**
- * Configuration for durable connections
- */
-export interface DurableConnectionConfig {
-    /** Maximum number of reconnection attempts (default: 10) */
-    maxReconnectAttempts?: number;
-    /** Base delay for exponential backoff in milliseconds (default: 1000) */
-    reconnectBackoffBase?: number;
-    /** Maximum delay between reconnection attempts in milliseconds (default: 30000) */
-    reconnectBackoffMax?: number;
-    /** Jitter factor for randomizing reconnection delays (default: 0.2 = ±20%) */
-    reconnectJitter?: number;
-    /** Timeout for initial connection attempt in milliseconds (default: 30000) */
-    connectionTimeout?: number;
-    /** Maximum number of messages to queue during disconnection (default: 1000) */
-    maxQueueSize?: number;
-    /** Maximum age of queued messages in milliseconds (default: 60000) */
-    maxMessageAge?: number;
-    /** WebRTC configuration */
-    rtcConfig?: RTCConfiguration;
-}
-/**
- * Configuration for durable channels
- */
-export interface DurableChannelConfig {
-    /** Maximum number of messages to queue (default: 1000) */
-    maxQueueSize?: number;
-    /** Maximum age of queued messages in milliseconds (default: 60000) */
-    maxMessageAge?: number;
-    /** Whether messages should be delivered in order (default: true) */
-    ordered?: boolean;
-    /** Maximum retransmits for unordered channels (default: undefined) */
-    maxRetransmits?: number;
-}
-/**
- * Configuration for durable services
- */
-export interface DurableServiceConfig extends DurableConnectionConfig {
-    /** Username that owns the service */
-    username: string;
-    /** Private key for signing service operations */
-    privateKey: string;
-    /** Fully qualified service name (e.g., com.example.chat@1.0.0) */
-    serviceFqn: string;
-    /** Whether the service is publicly discoverable (default: false) */
-    isPublic?: boolean;
-    /** Optional metadata for the service */
-    metadata?: Record<string, any>;
-    /** Time-to-live for service in milliseconds (default: server default) */
-    ttl?: number;
-    /** Margin before TTL expiry to trigger refresh (default: 0.2 = refresh at 80%) */
-    ttlRefreshMargin?: number;
-    /** Number of simultaneous open offers to maintain (default: 1) */
-    poolSize?: number;
-    /** Polling interval for checking answers in milliseconds (default: 2000) */
-    pollingInterval?: number;
-}
-/**
- * Queued message structure
- */
-export interface QueuedMessage {
-    /** Message data */
-    data: string | Blob | ArrayBuffer | ArrayBufferView;
-    /** Timestamp when message was enqueued */
-    enqueuedAt: number;
-    /** Unique message ID */
-    id: string;
-}
-/**
- * Event type map for DurableConnection
- */
-export interface DurableConnectionEvents extends Record<string, (...args: any[]) => void> {
-    'state': (state: DurableConnectionState, previousState: DurableConnectionState) => void;
-    'connected': () => void;
-    'reconnecting': (attempt: number, maxAttempts: number, nextRetryIn: number) => void;
-    'disconnected': () => void;
-    'failed': (error: Error, permanent: boolean) => void;
-    'closed': () => void;
-}
-/**
- * Event type map for DurableChannel
- */
-export interface DurableChannelEvents extends Record<string, (...args: any[]) => void> {
-    'open': () => void;
-    'message': (data: any) => void;
-    'error': (error: Error) => void;
-    'close': () => void;
-    'bufferedAmountLow': () => void;
-    'queueOverflow': (droppedCount: number) => void;
-}
-/**
- * Event type map for DurableService
- */
-export interface DurableServiceEvents extends Record<string, (...args: any[]) => void> {
-    'published': (serviceId: string, uuid: string) => void;
-    'connection': (connectionId: string) => void;
-    'disconnection': (connectionId: string) => void;
-    'ttl-refreshed': (expiresAt: number) => void;
-    'error': (error: Error, context: string) => void;
-    'closed': () => void;
-}
-/**
- * Information about a durable connection
- */
-export interface ConnectionInfo {
-    /** Username (for username-based connections) */
-    username?: string;
-    /** Service FQN (for service-based connections) */
-    serviceFqn?: string;
-    /** UUID (for UUID-based connections) */
-    uuid?: string;
-}
-/**
- * Service information returned when service is published
- */
-export interface ServiceInfo {
-    /** Service ID */
-    serviceId: string;
-    /** Service UUID for discovery */
-    uuid: string;
-    /** Expiration timestamp */
-    expiresAt: number;
-}

package/dist/durable/types.js

@@ -1,28 +0,0 @@
-/**
- * Type definitions for durable WebRTC connections
- *
- * This module defines all interfaces, enums, and types used by the durable
- * connection system for automatic reconnection and message queuing.
- */
-/**
- * Connection state enum
- */
-export var DurableConnectionState;
-(function (DurableConnectionState) {
-    DurableConnectionState["CONNECTING"] = "connecting";
-    DurableConnectionState["CONNECTED"] = "connected";
-    DurableConnectionState["RECONNECTING"] = "reconnecting";
-    DurableConnectionState["DISCONNECTED"] = "disconnected";
-    DurableConnectionState["FAILED"] = "failed";
-    DurableConnectionState["CLOSED"] = "closed";
-})(DurableConnectionState || (DurableConnectionState = {}));
-/**
- * Channel state enum
- */
-export var DurableChannelState;
-(function (DurableChannelState) {
-    DurableChannelState["CONNECTING"] = "connecting";
-    DurableChannelState["OPEN"] = "open";
-    DurableChannelState["CLOSING"] = "closing";
-    DurableChannelState["CLOSED"] = "closed";
-})(DurableChannelState || (DurableChannelState = {}));

package/dist/event-emitter.d.ts

@@ -1,54 +0,0 @@
-/**
- * Type-safe EventEmitter implementation for browser and Node.js compatibility
- *
- * @template EventMap - A type mapping event names to their handler signatures
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   'data': (value: string) => void;
- *   'error': (error: Error) => void;
- *   'ready': () => void;
- * }
- *
- * class MyClass extends EventEmitter<MyEvents> {
- *   doSomething() {
- *     this.emit('data', 'hello'); // Type-safe!
- *     this.emit('error', new Error('oops')); // Type-safe!
- *     this.emit('ready'); // Type-safe!
- *   }
- * }
- *
- * const instance = new MyClass();
- * instance.on('data', (value) => {
- *   console.log(value.toUpperCase()); // 'value' is typed as string
- * });
- * ```
- */
-export declare class EventEmitter<EventMap extends Record<string, (...args: any[]) => void>> {
-    private events;
-    /**
-     * Register an event listener
-     */
-    on<K extends keyof EventMap>(event: K, listener: EventMap[K]): this;
-    /**
-     * Register a one-time event listener
-     */
-    once<K extends keyof EventMap>(event: K, listener: EventMap[K]): this;
-    /**
-     * Remove an event listener
-     */
-    off<K extends keyof EventMap>(event: K, listener: EventMap[K]): this;
-    /**
-     * Emit an event
-     */
-    protected emit<K extends keyof EventMap>(event: K, ...args: Parameters<EventMap[K]>): boolean;
-    /**
-     * Remove all listeners for an event (or all events if not specified)
-     */
-    removeAllListeners<K extends keyof EventMap>(event?: K): this;
-    /**
-     * Get listener count for an event
-     */
-    listenerCount<K extends keyof EventMap>(event: K): number;
-}

package/dist/event-emitter.js

@@ -1,102 +0,0 @@
-/**
- * Type-safe EventEmitter implementation for browser and Node.js compatibility
- *
- * @template EventMap - A type mapping event names to their handler signatures
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   'data': (value: string) => void;
- *   'error': (error: Error) => void;
- *   'ready': () => void;
- * }
- *
- * class MyClass extends EventEmitter<MyEvents> {
- *   doSomething() {
- *     this.emit('data', 'hello'); // Type-safe!
- *     this.emit('error', new Error('oops')); // Type-safe!
- *     this.emit('ready'); // Type-safe!
- *   }
- * }
- *
- * const instance = new MyClass();
- * instance.on('data', (value) => {
- *   console.log(value.toUpperCase()); // 'value' is typed as string
- * });
- * ```
- */
-export class EventEmitter {
-    constructor() {
-        this.events = new Map();
-    }
-    /**
-     * Register an event listener
-     */
-    on(event, listener) {
-        if (!this.events.has(event)) {
-            this.events.set(event, new Set());
-        }
-        this.events.get(event).add(listener);
-        return this;
-    }
-    /**
-     * Register a one-time event listener
-     */
-    once(event, listener) {
-        const onceWrapper = (...args) => {
-            this.off(event, onceWrapper);
-            listener(...args);
-        };
-        return this.on(event, onceWrapper);
-    }
-    /**
-     * Remove an event listener
-     */
-    off(event, listener) {
-        const listeners = this.events.get(event);
-        if (listeners) {
-            listeners.delete(listener);
-            if (listeners.size === 0) {
-                this.events.delete(event);
-            }
-        }
-        return this;
-    }
-    /**
-     * Emit an event
-     */
-    emit(event, ...args) {
-        const listeners = this.events.get(event);
-        if (!listeners || listeners.size === 0) {
-            return false;
-        }
-        listeners.forEach(listener => {
-            try {
-                listener(...args);
-            }
-            catch (err) {
-                console.error(`Error in ${String(event)} event listener:`, err);
-            }
-        });
-        return true;
-    }
-    /**
-     * Remove all listeners for an event (or all events if not specified)
-     */
-    removeAllListeners(event) {
-        if (event !== undefined) {
-            this.events.delete(event);
-        }
-        else {
-            this.events.clear();
-        }
-        return this;
-    }
-    /**
-     * Get listener count for an event
-     */
-    listenerCount(event) {
-        const listeners = this.events.get(event);
-        return listeners ? listeners.size : 0;
-    }
-}

package/dist/offer-pool.d.ts

@@ -1,86 +0,0 @@
-import { RondevuOffers, Offer } from './offers.js';
-/**
- * Represents an offer that has been answered
- */
-export interface AnsweredOffer {
-    offerId: string;
-    answererId: string;
-    sdp: string;
-    peerConnection: RTCPeerConnection;
-    dataChannel?: RTCDataChannel;
-    answeredAt: number;
-}
-/**
- * Configuration options for the offer pool
- */
-export interface OfferPoolOptions {
-    /** Number of simultaneous open offers to maintain */
-    poolSize: number;
-    /** Polling interval in milliseconds (default: 2000ms) */
-    pollingInterval?: number;
-    /** Callback invoked when an offer is answered */
-    onAnswered: (answer: AnsweredOffer) => Promise<void>;
-    /** Callback to create new offers when refilling the pool */
-    onRefill: (count: number) => Promise<{
-        offers: Offer[];
-        peerConnections: RTCPeerConnection[];
-        dataChannels: RTCDataChannel[];
-    }>;
-    /** Error handler for pool operations */
-    onError: (error: Error, context: string) => void;
-}
-/**
- * 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 declare class OfferPool {
-    private offersApi;
-    private options;
-    private offers;
-    private peerConnections;
-    private dataChannels;
-    private polling;
-    private pollingTimer?;
-    private lastPollTime;
-    private readonly pollingInterval;
-    constructor(offersApi: RondevuOffers, options: OfferPoolOptions);
-    /**
-     * Add offers to the pool with their peer connections and data channels
-     */
-    addOffers(offers: Offer[], peerConnections?: RTCPeerConnection[], dataChannels?: RTCDataChannel[]): Promise<void>;
-    /**
-     * Start polling for answers
-     */
-    start(): Promise<void>;
-    /**
-     * Stop polling for answers
-     */
-    stop(): Promise<void>;
-    /**
-     * Poll for answers and refill the pool if needed
-     */
-    private poll;
-    /**
-     * Get the current number of active offers in the pool
-     */
-    getActiveOfferCount(): number;
-    /**
-     * Get all active offer IDs
-     */
-    getActiveOfferIds(): string[];
-    /**
-     * Get all active peer connections
-     */
-    getActivePeerConnections(): RTCPeerConnection[];
-    /**
-     * Get the last poll timestamp
-     */
-    getLastPollTime(): number;
-    /**
-     * Check if the pool is currently polling
-     */
-    isPolling(): boolean;
-}