@xtr-dev/rondevu-client 0.9.1 → 0.10.0

package/dist/rondevu.d.ts

@@ -1,184 +0,0 @@
-import { RondevuAuth, Credentials, FetchFunction } from './auth.js';
-import { RondevuOffers } from './offers.js';
-import { RondevuUsername } from './usernames.js';
-import RondevuPeer from './peer/index.js';
-import { DurableService } from './durable/service.js';
-import { DurableConnection } from './durable/connection.js';
-import { DurableChannel } from './durable/channel.js';
-import type { DurableServiceConfig, DurableConnectionConfig } from './durable/types.js';
-export interface RondevuOptions {
-    /**
-     * Base URL of the Rondevu server
-     * @default 'https://api.ronde.vu'
-     */
-    baseUrl?: string;
-    /**
-     * Existing credentials (peerId + secret) to skip registration
-     */
-    credentials?: Credentials;
-    /**
-     * Custom fetch implementation for environments without native fetch
-     * (Node.js < 18, some Workers environments, etc.)
-     *
-     * @example Node.js
-     * ```typescript
-     * import fetch from 'node-fetch';
-     * const client = new Rondevu({ fetch });
-     * ```
-     */
-    fetch?: FetchFunction;
-    /**
-     * Custom RTCPeerConnection implementation for Node.js environments
-     * Required when using in Node.js with wrtc or similar polyfills
-     *
-     * @example Node.js with wrtc
-     * ```typescript
-     * import { RTCPeerConnection } from 'wrtc';
-     * const client = new Rondevu({ RTCPeerConnection });
-     * ```
-     */
-    RTCPeerConnection?: typeof RTCPeerConnection;
-    /**
-     * Custom RTCSessionDescription implementation for Node.js environments
-     * Required when using in Node.js with wrtc or similar polyfills
-     *
-     * @example Node.js with wrtc
-     * ```typescript
-     * import { RTCSessionDescription } from 'wrtc';
-     * const client = new Rondevu({ RTCSessionDescription });
-     * ```
-     */
-    RTCSessionDescription?: typeof RTCSessionDescription;
-    /**
-     * Custom RTCIceCandidate implementation for Node.js environments
-     * Required when using in Node.js with wrtc or similar polyfills
-     *
-     * @example Node.js with wrtc
-     * ```typescript
-     * import { RTCIceCandidate } from 'wrtc';
-     * const client = new Rondevu({ RTCIceCandidate });
-     * ```
-     */
-    RTCIceCandidate?: typeof RTCIceCandidate;
-}
-export declare class Rondevu {
-    readonly auth: RondevuAuth;
-    readonly usernames: RondevuUsername;
-    private _offers?;
-    private credentials?;
-    private baseUrl;
-    private fetchFn?;
-    private rtcPeerConnection?;
-    private rtcSessionDescription?;
-    private rtcIceCandidate?;
-    constructor(options?: RondevuOptions);
-    /**
-     * Get offers API (low-level access, requires authentication)
-     * For most use cases, use the durable connection APIs instead
-     */
-    get offers(): RondevuOffers;
-    /**
-     * Register and initialize authenticated client
-     * Generates a cryptographically random peer ID (128-bit)
-     */
-    register(): Promise<Credentials>;
-    /**
-     * Check if client is authenticated
-     */
-    isAuthenticated(): boolean;
-    /**
-     * Get current credentials
-     */
-    getCredentials(): Credentials | undefined;
-    /**
-     * Create a new WebRTC peer connection (requires authentication)
-     * This is a high-level helper that creates and manages WebRTC connections with state management
-     *
-     * @param rtcConfig Optional RTCConfiguration for the peer connection
-     * @returns RondevuPeer instance
-     */
-    createPeer(rtcConfig?: RTCConfiguration): RondevuPeer;
-    /**
-     * Expose a durable service with automatic reconnection and TTL refresh
-     *
-     * Creates a service that handles incoming connections with automatic
-     * reconnection and message queuing during network interruptions.
-     *
-     * @param config Service configuration
-     * @returns DurableService instance
-     *
-     * @example
-     * ```typescript
-     * const service = await client.exposeService({
-     *   username: 'alice',
-     *   privateKey: keypair.privateKey,
-     *   serviceFqn: 'chat@1.0.0',
-     *   poolSize: 10,
-     *   handler: (channel, connectionId) => {
-     *     channel.on('message', (data) => {
-     *       console.log('Received:', data);
-     *       channel.send(`Echo: ${data}`);
-     *     });
-     *   }
-     * });
-     *
-     * await service.start();
-     * ```
-     */
-    exposeService(config: DurableServiceConfig & {
-        handler: (channel: DurableChannel, connectionId: string) => void | Promise<void>;
-    }): Promise<DurableService>;
-    /**
-     * Create a durable connection to a service by username and service FQN
-     *
-     * Establishes a WebRTC connection with automatic reconnection and
-     * message queuing during network interruptions.
-     *
-     * @param username Username of the service provider
-     * @param serviceFqn Fully qualified service name
-     * @param config Optional connection configuration
-     * @returns DurableConnection instance
-     *
-     * @example
-     * ```typescript
-     * const connection = await client.connect('alice', 'chat@1.0.0', {
-     *   maxReconnectAttempts: 5
-     * });
-     *
-     * const channel = connection.createChannel('main');
-     * channel.on('message', (data) => {
-     *   console.log('Received:', data);
-     * });
-     *
-     * await connection.connect();
-     * channel.send('Hello!');
-     * ```
-     */
-    connect(username: string, serviceFqn: string, config?: DurableConnectionConfig): Promise<DurableConnection>;
-    /**
-     * Create a durable connection to a service by UUID
-     *
-     * Establishes a WebRTC connection with automatic reconnection and
-     * message queuing during network interruptions.
-     *
-     * @param uuid Service UUID
-     * @param config Optional connection configuration
-     * @returns DurableConnection instance
-     *
-     * @example
-     * ```typescript
-     * const connection = await client.connectByUuid('service-uuid-here', {
-     *   maxReconnectAttempts: 5
-     * });
-     *
-     * const channel = connection.createChannel('main');
-     * channel.on('message', (data) => {
-     *   console.log('Received:', data);
-     * });
-     *
-     * await connection.connect();
-     * channel.send('Hello!');
-     * ```
-     */
-    connectByUuid(uuid: string, config?: DurableConnectionConfig): Promise<DurableConnection>;
-}

package/dist/rondevu.js

@@ -1,171 +0,0 @@
-import { RondevuAuth } from './auth.js';
-import { RondevuOffers } from './offers.js';
-import { RondevuUsername } from './usernames.js';
-import RondevuPeer from './peer/index.js';
-import { DurableService } from './durable/service.js';
-import { DurableConnection } from './durable/connection.js';
-export class Rondevu {
-    constructor(options = {}) {
-        this.baseUrl = options.baseUrl || 'https://api.ronde.vu';
-        this.fetchFn = options.fetch;
-        this.rtcPeerConnection = options.RTCPeerConnection;
-        this.rtcSessionDescription = options.RTCSessionDescription;
-        this.rtcIceCandidate = options.RTCIceCandidate;
-        this.auth = new RondevuAuth(this.baseUrl, this.fetchFn);
-        this.usernames = new RondevuUsername(this.baseUrl);
-        if (options.credentials) {
-            this.credentials = options.credentials;
-            this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
-        }
-    }
-    /**
-     * Get offers API (low-level access, requires authentication)
-     * For most use cases, use the durable connection APIs instead
-     */
-    get offers() {
-        if (!this._offers) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        return this._offers;
-    }
-    /**
-     * Register and initialize authenticated client
-     * Generates a cryptographically random peer ID (128-bit)
-     */
-    async register() {
-        this.credentials = await this.auth.register();
-        // Create offers API instance
-        this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
-        return this.credentials;
-    }
-    /**
-     * Check if client is authenticated
-     */
-    isAuthenticated() {
-        return !!this.credentials;
-    }
-    /**
-     * Get current credentials
-     */
-    getCredentials() {
-        return this.credentials;
-    }
-    /**
-     * Create a new WebRTC peer connection (requires authentication)
-     * This is a high-level helper that creates and manages WebRTC connections with state management
-     *
-     * @param rtcConfig Optional RTCConfiguration for the peer connection
-     * @returns RondevuPeer instance
-     */
-    createPeer(rtcConfig) {
-        if (!this._offers) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        return new RondevuPeer(this._offers, rtcConfig, undefined, // No existing peer connection
-        this.rtcPeerConnection, this.rtcSessionDescription, this.rtcIceCandidate);
-    }
-    /**
-     * Expose a durable service with automatic reconnection and TTL refresh
-     *
-     * Creates a service that handles incoming connections with automatic
-     * reconnection and message queuing during network interruptions.
-     *
-     * @param config Service configuration
-     * @returns DurableService instance
-     *
-     * @example
-     * ```typescript
-     * const service = await client.exposeService({
-     *   username: 'alice',
-     *   privateKey: keypair.privateKey,
-     *   serviceFqn: 'chat@1.0.0',
-     *   poolSize: 10,
-     *   handler: (channel, connectionId) => {
-     *     channel.on('message', (data) => {
-     *       console.log('Received:', data);
-     *       channel.send(`Echo: ${data}`);
-     *     });
-     *   }
-     * });
-     *
-     * await service.start();
-     * ```
-     */
-    async exposeService(config) {
-        if (!this._offers || !this.credentials) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        const service = new DurableService(this._offers, this.baseUrl, this.credentials, config.handler, config);
-        return service;
-    }
-    /**
-     * Create a durable connection to a service by username and service FQN
-     *
-     * Establishes a WebRTC connection with automatic reconnection and
-     * message queuing during network interruptions.
-     *
-     * @param username Username of the service provider
-     * @param serviceFqn Fully qualified service name
-     * @param config Optional connection configuration
-     * @returns DurableConnection instance
-     *
-     * @example
-     * ```typescript
-     * const connection = await client.connect('alice', 'chat@1.0.0', {
-     *   maxReconnectAttempts: 5
-     * });
-     *
-     * const channel = connection.createChannel('main');
-     * channel.on('message', (data) => {
-     *   console.log('Received:', data);
-     * });
-     *
-     * await connection.connect();
-     * channel.send('Hello!');
-     * ```
-     */
-    async connect(username, serviceFqn, config) {
-        if (!this._offers) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        const connectionInfo = {
-            username,
-            serviceFqn
-        };
-        return new DurableConnection(this._offers, connectionInfo, config);
-    }
-    /**
-     * Create a durable connection to a service by UUID
-     *
-     * Establishes a WebRTC connection with automatic reconnection and
-     * message queuing during network interruptions.
-     *
-     * @param uuid Service UUID
-     * @param config Optional connection configuration
-     * @returns DurableConnection instance
-     *
-     * @example
-     * ```typescript
-     * const connection = await client.connectByUuid('service-uuid-here', {
-     *   maxReconnectAttempts: 5
-     * });
-     *
-     * const channel = connection.createChannel('main');
-     * channel.on('message', (data) => {
-     *   console.log('Received:', data);
-     * });
-     *
-     * await connection.connect();
-     * channel.send('Hello!');
-     * ```
-     */
-    async connectByUuid(uuid, config) {
-        if (!this._offers) {
-            throw new Error('Not authenticated. Call register() first or provide credentials.');
-        }
-        const connectionInfo = {
-            uuid
-        };
-        return new DurableConnection(this._offers, connectionInfo, config);
-    }
-}

package/dist/service-pool.d.ts

@@ -1,123 +0,0 @@
-import RondevuPeer from './peer/index.js';
-/**
- * Status information about the pool
- */
-export interface PoolStatus {
-    /** Number of active offers in the pool */
-    activeOffers: number;
-    /** Number of currently connected peers */
-    activeConnections: number;
-    /** Total number of connections handled since start */
-    totalConnectionsHandled: number;
-    /** Number of failed offer creation attempts */
-    failedOfferCreations: number;
-}
-/**
- * Configuration options for a pooled service
- */
-export interface ServicePoolOptions {
-    /** 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;
-    /** WebRTC configuration */
-    rtcConfig?: RTCConfiguration;
-    /** Whether the service is publicly discoverable */
-    isPublic?: boolean;
-    /** Optional metadata for the service */
-    metadata?: Record<string, any>;
-    /** Time-to-live for offers in milliseconds */
-    ttl?: number;
-    /** Handler invoked for each new connection */
-    handler: (channel: RTCDataChannel, peer: RondevuPeer, connectionId: string) => void;
-    /** Number of simultaneous open offers to maintain (default: 1) */
-    poolSize?: number;
-    /** Polling interval in milliseconds (default: 2000ms) */
-    pollingInterval?: number;
-    /** Callback for pool status updates */
-    onPoolStatus?: (status: PoolStatus) => void;
-    /** Error handler for pool operations */
-    onError?: (error: Error, context: string) => void;
-}
-/**
- * Service handle with pool-specific methods
- */
-export interface PooledServiceHandle {
-    /** Service ID */
-    serviceId: string;
-    /** Service UUID */
-    uuid: string;
-    /** Offer ID */
-    offerId: string;
-    /** Unpublish the service */
-    unpublish: () => Promise<void>;
-    /** Get current pool status */
-    getStatus: () => PoolStatus;
-    /** Manually add offers to the pool */
-    addOffers: (count: number) => Promise<void>;
-}
-/**
- * Manages a pooled service with multiple concurrent connections
- *
- * ServicePool coordinates offer creation, answer polling, and connection
- * management for services that need to handle multiple simultaneous connections.
- */
-export declare class ServicePool {
-    private baseUrl;
-    private credentials;
-    private options;
-    private offerPool?;
-    private connections;
-    private peerConnections;
-    private status;
-    private serviceId?;
-    private uuid?;
-    private offersApi;
-    private usernameApi;
-    constructor(baseUrl: string, credentials: {
-        peerId: string;
-        secret: string;
-    }, options: ServicePoolOptions);
-    /**
-     * Start the pooled service
-     */
-    start(): Promise<PooledServiceHandle>;
-    /**
-     * Stop the pooled service and clean up
-     */
-    stop(): Promise<void>;
-    /**
-     * Handle an answered offer by setting up the connection
-     */
-    private handleConnection;
-    /**
-     * Create multiple offers
-     */
-    private createOffers;
-    /**
-     * Publish the initial service (creates first offer)
-     */
-    private publishInitialService;
-    /**
-     * Manually add offers to the pool
-     */
-    private manualRefill;
-    /**
-     * Get current pool status
-     */
-    private getStatus;
-    /**
-     * Update status and notify listeners
-     */
-    private updateStatus;
-    /**
-     * Handle errors
-     */
-    private handleError;
-    /**
-     * Generate a unique connection ID
-     */
-    private generateConnectionId;
-}