@xtr-dev/rondevu-client 0.12.3 → 0.13.0

package/dist/durable-connection.d.ts

@@ -1,120 +0,0 @@
-import { ConnectionEvents, ConnectionInterface, Message, QueueMessageOptions, Signaler } from './types.js';
-import { EventBus } from './event-bus.js';
-import { WebRTCContext } from './webrtc-context';
-export type WebRTCRondevuConnectionOptions = {
-    offer?: RTCSessionDescriptionInit | null;
-    context: WebRTCContext;
-    signaler: Signaler;
-};
-/**
- * WebRTCRondevuConnection - WebRTC peer connection wrapper with Rondevu signaling
- *
- * Manages a WebRTC peer connection lifecycle including:
- * - Automatic offer/answer creation based on role
- * - ICE candidate exchange via Rondevu signaling server
- * - Connection state management with type-safe events
- * - Data channel creation and message handling
- *
- * The connection automatically determines its role (offerer or answerer) based on whether
- * an offer is provided in the constructor. The offerer creates the data channel, while
- * the answerer receives it via the 'datachannel' event.
- *
- * @example
- * ```typescript
- * // Offerer side (creates offer)
- * const connection = new WebRTCRondevuConnection(
- *   'conn-123',
- *   'peer-username',
- *   'chat.service@1.0.0'
- * );
- *
- * await connection.ready; // Wait for local offer
- * const sdp = connection.connection.localDescription!.sdp!;
- * // Send sdp to signaling server...
- *
- * // Answerer side (receives offer)
- * const connection = new WebRTCRondevuConnection(
- *   'conn-123',
- *   'peer-username',
- *   'chat.service@1.0.0',
- *   { type: 'offer', sdp: remoteOfferSdp }
- * );
- *
- * await connection.ready; // Wait for local answer
- * const answerSdp = connection.connection.localDescription!.sdp!;
- * // Send answer to signaling server...
- *
- * // Both sides: Set up signaler and listen for state changes
- * connection.setSignaler(signaler);
- * connection.events.on('state-change', (state) => {
- *   console.log('Connection state:', state);
- * });
- * ```
- */
-export declare class RTCDurableConnection implements ConnectionInterface {
-    private readonly side;
-    readonly expiresAt: number;
-    readonly lastActive: number;
-    readonly events: EventBus<ConnectionEvents>;
-    readonly ready: Promise<void>;
-    private iceBin;
-    private context;
-    private readonly signaler;
-    private _conn;
-    private _state;
-    private _dataChannel;
-    private messageQueue;
-    constructor({ context, offer, signaler }: WebRTCRondevuConnectionOptions);
-    /**
-     * Getter method for retrieving the current connection.
-     *
-     * @return {RTCPeerConnection|null} The current connection instance.
-     */
-    get connection(): RTCPeerConnection | null;
-    /**
-     * Update connection state and emit state-change event
-     */
-    private setState;
-    /**
-     * Start ICE candidate exchange when gathering begins
-     */
-    private startIce;
-    /**
-     * Stop ICE candidate exchange when gathering completes
-     */
-    private stopIce;
-    /**
-     * Disconnects the current connection and cleans up resources.
-     * Closes the active connection if it exists, resets the connection instance to null,
-     * stops the ICE process, and updates the state to 'disconnected'.
-     *
-     * @return {void} No return value.
-     */
-    disconnect(): void;
-    /**
-     * Current connection state
-     */
-    get state(): "connected" | "disconnected" | "connecting";
-    /**
-     * Setup data channel event listeners
-     */
-    private setupDataChannelListeners;
-    /**
-     * Flush the message queue
-     */
-    private flushQueue;
-    /**
-     * Queue a message for sending when connection is established
-     *
-     * @param message - Message to queue (string or ArrayBuffer)
-     * @param options - Queue options (e.g., expiration time)
-     */
-    queueMessage(message: Message, options?: QueueMessageOptions): Promise<void>;
-    /**
-     * Send a message immediately
-     *
-     * @param message - Message to send (string or ArrayBuffer)
-     * @returns Promise resolving to true if sent successfully
-     */
-    sendMessage(message: Message): Promise<boolean>;
-}

package/dist/durable-connection.js

@@ -1,244 +0,0 @@
-import { isConnectionState, } from './types.js';
-import { EventBus } from './event-bus.js';
-import { createBin } from './bin.js';
-/**
- * WebRTCRondevuConnection - WebRTC peer connection wrapper with Rondevu signaling
- *
- * Manages a WebRTC peer connection lifecycle including:
- * - Automatic offer/answer creation based on role
- * - ICE candidate exchange via Rondevu signaling server
- * - Connection state management with type-safe events
- * - Data channel creation and message handling
- *
- * The connection automatically determines its role (offerer or answerer) based on whether
- * an offer is provided in the constructor. The offerer creates the data channel, while
- * the answerer receives it via the 'datachannel' event.
- *
- * @example
- * ```typescript
- * // Offerer side (creates offer)
- * const connection = new WebRTCRondevuConnection(
- *   'conn-123',
- *   'peer-username',
- *   'chat.service@1.0.0'
- * );
- *
- * await connection.ready; // Wait for local offer
- * const sdp = connection.connection.localDescription!.sdp!;
- * // Send sdp to signaling server...
- *
- * // Answerer side (receives offer)
- * const connection = new WebRTCRondevuConnection(
- *   'conn-123',
- *   'peer-username',
- *   'chat.service@1.0.0',
- *   { type: 'offer', sdp: remoteOfferSdp }
- * );
- *
- * await connection.ready; // Wait for local answer
- * const answerSdp = connection.connection.localDescription!.sdp!;
- * // Send answer to signaling server...
- *
- * // Both sides: Set up signaler and listen for state changes
- * connection.setSignaler(signaler);
- * connection.events.on('state-change', (state) => {
- *   console.log('Connection state:', state);
- * });
- * ```
- */
-export class RTCDurableConnection {
-    constructor({ context, offer, signaler }) {
-        this.expiresAt = 0;
-        this.lastActive = 0;
-        this.events = new EventBus();
-        this.iceBin = createBin();
-        this._conn = null;
-        this._state = 'disconnected';
-        this._dataChannel = null;
-        this.messageQueue = [];
-        this.context = context;
-        this.signaler = signaler;
-        this._conn = context.createPeerConnection();
-        this.side = offer ? 'answer' : 'offer';
-        // setup data channel
-        if (offer) {
-            this._conn.addEventListener('datachannel', e => {
-                this._dataChannel = e.channel;
-                this.setupDataChannelListeners(this._dataChannel);
-            });
-        }
-        else {
-            this._dataChannel = this._conn.createDataChannel('vu.ronde.protocol');
-            this.setupDataChannelListeners(this._dataChannel);
-        }
-        // setup description exchange
-        this.ready = offer
-            ? this._conn
-                .setRemoteDescription(offer)
-                .then(() => this._conn?.createAnswer())
-                .then(async (answer) => {
-                if (!answer || !this._conn)
-                    throw new Error('Connection disappeared');
-                await this._conn.setLocalDescription(answer);
-                return await signaler.setAnswer(answer);
-            })
-            : this._conn.createOffer().then(async (offer) => {
-                if (!this._conn)
-                    throw new Error('Connection disappeared');
-                await this._conn.setLocalDescription(offer);
-                return await signaler.setOffer(offer);
-            });
-        // propagate connection state changes
-        this._conn.addEventListener('connectionstatechange', () => {
-            console.log(this.side, 'connection state changed: ', this._conn.connectionState);
-            const state = isConnectionState(this._conn.connectionState)
-                ? this._conn.connectionState
-                : 'disconnected';
-            this.setState(state);
-        });
-        this._conn.addEventListener('iceconnectionstatechange', () => {
-            console.log(this.side, 'ice connection state changed: ', this._conn.iceConnectionState);
-        });
-        // start ICE candidate exchange when gathering begins
-        this._conn.addEventListener('icegatheringstatechange', () => {
-            if (this._conn.iceGatheringState === 'gathering') {
-                this.startIce();
-            }
-            else if (this._conn.iceGatheringState === 'complete') {
-                this.stopIce();
-            }
-        });
-    }
-    /**
-     * Getter method for retrieving the current connection.
-     *
-     * @return {RTCPeerConnection|null} The current connection instance.
-     */
-    get connection() {
-        return this._conn;
-    }
-    /**
-     * Update connection state and emit state-change event
-     */
-    setState(state) {
-        this._state = state;
-        this.events.emit('state-change', state);
-    }
-    /**
-     * Start ICE candidate exchange when gathering begins
-     */
-    startIce() {
-        const listener = ({ candidate }) => {
-            if (candidate)
-                this.signaler.addIceCandidate(candidate);
-        };
-        if (!this._conn)
-            throw new Error('Connection disappeared');
-        this._conn.addEventListener('icecandidate', listener);
-        this.iceBin(this.signaler.addListener((candidate) => this._conn?.addIceCandidate(candidate)), () => this._conn?.removeEventListener('icecandidate', listener));
-    }
-    /**
-     * Stop ICE candidate exchange when gathering completes
-     */
-    stopIce() {
-        this.iceBin.clean();
-    }
-    /**
-     * Disconnects the current connection and cleans up resources.
-     * Closes the active connection if it exists, resets the connection instance to null,
-     * stops the ICE process, and updates the state to 'disconnected'.
-     *
-     * @return {void} No return value.
-     */
-    disconnect() {
-        this._conn?.close();
-        this._conn = null;
-        this.stopIce();
-        this.setState('disconnected');
-    }
-    /**
-     * Current connection state
-     */
-    get state() {
-        return this._state;
-    }
-    /**
-     * Setup data channel event listeners
-     */
-    setupDataChannelListeners(channel) {
-        channel.addEventListener('message', e => {
-            this.events.emit('message', e.data);
-        });
-        channel.addEventListener('open', () => {
-            // Channel opened - flush queued messages
-            this.flushQueue().catch(err => {
-                console.error('Failed to flush message queue:', err);
-            });
-        });
-        channel.addEventListener('error', err => {
-            console.error('Data channel error:', err);
-        });
-        channel.addEventListener('close', () => {
-            console.log('Data channel closed');
-        });
-    }
-    /**
-     * Flush the message queue
-     */
-    async flushQueue() {
-        while (this.messageQueue.length > 0 && this._state === 'connected') {
-            const item = this.messageQueue.shift();
-            // Check expiration
-            if (item.options.expiresAt && Date.now() > item.options.expiresAt) {
-                continue;
-            }
-            const success = await this.sendMessage(item.message);
-            if (!success) {
-                // Re-queue on failure
-                this.messageQueue.unshift(item);
-                break;
-            }
-        }
-    }
-    /**
-     * Queue a message for sending when connection is established
-     *
-     * @param message - Message to queue (string or ArrayBuffer)
-     * @param options - Queue options (e.g., expiration time)
-     */
-    async queueMessage(message, options = {}) {
-        this.messageQueue.push({
-            message,
-            options,
-            timestamp: Date.now()
-        });
-        // Try immediate send if connected
-        if (this._state === 'connected') {
-            await this.flushQueue();
-        }
-    }
-    /**
-     * Send a message immediately
-     *
-     * @param message - Message to send (string or ArrayBuffer)
-     * @returns Promise resolving to true if sent successfully
-     */
-    async sendMessage(message) {
-        if (this._state !== 'connected' || !this._dataChannel) {
-            return false;
-        }
-        if (this._dataChannel.readyState !== 'open') {
-            return false;
-        }
-        try {
-            // TypeScript has trouble with the union type, so we cast to any
-            // Both string and ArrayBuffer are valid for RTCDataChannel.send()
-            this._dataChannel.send(message);
-            return true;
-        }
-        catch (err) {
-            console.error('Send failed:', err);
-            return false;
-        }
-    }
-}

package/dist/event-bus.d.ts

@@ -1,52 +0,0 @@
-/**
- * Type-safe EventBus with event name to payload type mapping
- */
-type EventHandler<T = any> = (data: T) => void;
-/**
- * EventBus - Type-safe event emitter with inferred event data types
- *
- * @example
- * interface MyEvents {
- *   'user:connected': { userId: string; timestamp: number };
- *   'user:disconnected': { userId: string };
- *   'message:received': string;
- * }
- *
- * const bus = new EventBus<MyEvents>();
- *
- * // TypeScript knows data is { userId: string; timestamp: number }
- * bus.on('user:connected', (data) => {
- *   console.log(data.userId, data.timestamp);
- * });
- *
- * // TypeScript knows data is string
- * bus.on('message:received', (data) => {
- *   console.log(data.toUpperCase());
- * });
- */
-export declare class EventBus<TEvents extends Record<string, any>> {
-    private handlers;
-    constructor();
-    /**
-     * Subscribe to an event
-     * Returns a cleanup function to unsubscribe
-     */
-    on<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): () => void;
-    /**
-     * Subscribe to an event once (auto-unsubscribe after first call)
-     */
-    once<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void;
-    /**
-     * Unsubscribe from an event
-     */
-    off<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void;
-    /**
-     * Emit an event with data
-     */
-    emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
-    /**
-     * Remove all handlers for a specific event, or all handlers if no event specified
-     */
-    clear<K extends keyof TEvents>(event?: K): void;
-}
-export {};

package/dist/event-bus.js

@@ -1,84 +0,0 @@
-/**
- * Type-safe EventBus with event name to payload type mapping
- */
-/**
- * EventBus - Type-safe event emitter with inferred event data types
- *
- * @example
- * interface MyEvents {
- *   'user:connected': { userId: string; timestamp: number };
- *   'user:disconnected': { userId: string };
- *   'message:received': string;
- * }
- *
- * const bus = new EventBus<MyEvents>();
- *
- * // TypeScript knows data is { userId: string; timestamp: number }
- * bus.on('user:connected', (data) => {
- *   console.log(data.userId, data.timestamp);
- * });
- *
- * // TypeScript knows data is string
- * bus.on('message:received', (data) => {
- *   console.log(data.toUpperCase());
- * });
- */
-export class EventBus {
-    constructor() {
-        this.handlers = new Map();
-    }
-    /**
-     * Subscribe to an event
-     * Returns a cleanup function to unsubscribe
-     */
-    on(event, handler) {
-        if (!this.handlers.has(event)) {
-            this.handlers.set(event, new Set());
-        }
-        this.handlers.get(event).add(handler);
-        // Return cleanup function
-        return () => this.off(event, handler);
-    }
-    /**
-     * Subscribe to an event once (auto-unsubscribe after first call)
-     */
-    once(event, handler) {
-        const wrappedHandler = (data) => {
-            handler(data);
-            this.off(event, wrappedHandler);
-        };
-        this.on(event, wrappedHandler);
-    }
-    /**
-     * Unsubscribe from an event
-     */
-    off(event, handler) {
-        const eventHandlers = this.handlers.get(event);
-        if (eventHandlers) {
-            eventHandlers.delete(handler);
-            if (eventHandlers.size === 0) {
-                this.handlers.delete(event);
-            }
-        }
-    }
-    /**
-     * Emit an event with data
-     */
-    emit(event, data) {
-        const eventHandlers = this.handlers.get(event);
-        if (eventHandlers) {
-            eventHandlers.forEach(handler => handler(data));
-        }
-    }
-    /**
-     * Remove all handlers for a specific event, or all handlers if no event specified
-     */
-    clear(event) {
-        if (event !== undefined) {
-            this.handlers.delete(event);
-        }
-        else {
-            this.handlers.clear();
-        }
-    }
-}

package/dist/noop-signaler.d.ts

@@ -1,14 +0,0 @@
-import { Signaler } from './types.js';
-import { Binnable } from './bin.js';
-/**
- * NoOpSignaler - A signaler that does nothing
- * Used as a placeholder during connection setup before the real signaler is available
- */
-export declare class NoOpSignaler implements Signaler {
-    addIceCandidate(_candidate: RTCIceCandidate): void;
-    addListener(_callback: (candidate: RTCIceCandidate) => void): Binnable;
-    addOfferListener(_callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
-    addAnswerListener(_callback: (answer: RTCSessionDescriptionInit) => void): Binnable;
-    setOffer(_offer: RTCSessionDescriptionInit): Promise<void>;
-    setAnswer(_answer: RTCSessionDescriptionInit): Promise<void>;
-}

package/dist/noop-signaler.js

@@ -1,27 +0,0 @@
-/**
- * NoOpSignaler - A signaler that does nothing
- * Used as a placeholder during connection setup before the real signaler is available
- */
-export class NoOpSignaler {
-    addIceCandidate(_candidate) {
-        // No-op
-    }
-    addListener(_callback) {
-        // Return no-op cleanup function
-        return () => { };
-    }
-    addOfferListener(_callback) {
-        // Return no-op cleanup function
-        return () => { };
-    }
-    addAnswerListener(_callback) {
-        // Return no-op cleanup function
-        return () => { };
-    }
-    async setOffer(_offer) {
-        // No-op
-    }
-    async setAnswer(_answer) {
-        // No-op
-    }
-}

package/dist/quick-start.d.ts

@@ -1,29 +0,0 @@
-import { RondevuService } from './rondevu-service.js';
-import { Keypair } from './api.js';
-export interface QuickStartOptions {
-    apiUrl: string;
-    username?: string;
-    keypair?: Keypair;
-}
-/**
- * Quick start helper for initializing Rondevu service
- *
- * Simplifies initialization by:
- * - Auto-generating username if not provided
- * - Auto-generating keypair if not provided
- * - Registering with the server
- * - Claiming the username
- *
- * @example
- * ```typescript
- * // Simple usage with auto-generated username
- * const service = await quickStart({ apiUrl: 'https://api.ronde.vu' })
- *
- * // With custom username
- * const service = await quickStart({
- *     apiUrl: 'https://api.ronde.vu',
- *     username: 'my-username'
- * })
- * ```
- */
-export declare function quickStart(options: QuickStartOptions): Promise<RondevuService>;

package/dist/quick-start.js

@@ -1,44 +0,0 @@
-import { RondevuService } from './rondevu-service.js';
-/**
- * Quick start helper for initializing Rondevu service
- *
- * Simplifies initialization by:
- * - Auto-generating username if not provided
- * - Auto-generating keypair if not provided
- * - Registering with the server
- * - Claiming the username
- *
- * @example
- * ```typescript
- * // Simple usage with auto-generated username
- * const service = await quickStart({ apiUrl: 'https://api.ronde.vu' })
- *
- * // With custom username
- * const service = await quickStart({
- *     apiUrl: 'https://api.ronde.vu',
- *     username: 'my-username'
- * })
- * ```
- */
-export async function quickStart(options) {
-    // Generate username if not provided
-    const username = options.username || `user-${generateId()}`;
-    // Create service
-    const serviceOptions = {
-        apiUrl: options.apiUrl,
-        username,
-        keypair: options.keypair
-    };
-    const service = new RondevuService(serviceOptions);
-    // Initialize (generates keypair and registers)
-    await service.initialize();
-    // Claim username
-    await service.claimUsername();
-    return service;
-}
-/**
- * Generate a random ID
- */
-function generateId() {
-    return Math.random().toString(36).substring(2, 10);
-}

package/dist/rondevu-context.d.ts

@@ -1,10 +0,0 @@
-import { RondevuService } from "./rondevu-service";
-import { RTCDurableConnection } from "./durable-connection";
-export declare class RondevuContext {
-    readonly rondevu: RondevuService;
-    readonly rtcConfig: RTCConfiguration;
-    private readonly context;
-    private readonly connections;
-    constructor(rondevu: RondevuService, rtcConfig: RTCConfiguration);
-    createConnection(service: string, host?: string, offer?: RTCSessionDescriptionInit): RTCDurableConnection;
-}

package/dist/rondevu-context.js

@@ -1,20 +0,0 @@
-import { WebRTCContext } from "./webrtc-context";
-import { RTCDurableConnection } from "./durable-connection";
-import { RondevuSignaler } from "./rondevu-signaler";
-export class RondevuContext {
-    constructor(rondevu, rtcConfig) {
-        this.rondevu = rondevu;
-        this.rtcConfig = rtcConfig;
-        this.connections = [];
-        this.context = new WebRTCContext(rtcConfig);
-    }
-    createConnection(service, host, offer) {
-        const conn = new RTCDurableConnection({
-            context: this.context,
-            offer,
-            signaler: new RondevuSignaler(this.rondevu, service, host)
-        });
-        this.connections.push(conn);
-        return conn;
-    }
-}