@xtr-dev/rondevu-client 0.12.4 → 0.17.0

package/dist/rpc-batcher.js

@@ -0,0 +1,111 @@
+/**
+ * RPC Batcher - Throttles and batches RPC requests to reduce HTTP overhead
+ */
+/**
+ * Batches and throttles RPC requests to optimize network usage
+ *
+ * @example
+ * ```typescript
+ * const batcher = new RpcBatcher(
+ *   (requests) => api.rpcBatch(requests),
+ *   { maxBatchSize: 10, maxWaitTime: 50 }
+ * )
+ *
+ * // These will be batched together if called within maxWaitTime
+ * const result1 = await batcher.add(request1)
+ * const result2 = await batcher.add(request2)
+ * const result3 = await batcher.add(request3)
+ * ```
+ */
+export class RpcBatcher {
+    constructor(sendBatch, options) {
+        this.queue = [];
+        this.batchTimeout = null;
+        this.lastBatchTime = 0;
+        this.sendBatch = sendBatch;
+        this.options = {
+            maxBatchSize: options?.maxBatchSize ?? 10,
+            maxWaitTime: options?.maxWaitTime ?? 50,
+            throttleInterval: options?.throttleInterval ?? 10,
+        };
+    }
+    /**
+     * Add an RPC request to the batch queue
+     * Returns a promise that resolves when the request completes
+     */
+    async add(request) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ request, resolve, reject });
+            // Send immediately if batch is full
+            if (this.queue.length >= this.options.maxBatchSize) {
+                this.flush();
+                return;
+            }
+            // Schedule batch if not already scheduled
+            if (!this.batchTimeout) {
+                this.batchTimeout = setTimeout(() => {
+                    this.flush();
+                }, this.options.maxWaitTime);
+            }
+        });
+    }
+    /**
+     * Flush the queue immediately
+     */
+    async flush() {
+        // Clear timeout if set
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        // Nothing to flush
+        if (this.queue.length === 0) {
+            return;
+        }
+        // Throttle: wait if we sent a batch too recently
+        const now = Date.now();
+        const timeSinceLastBatch = now - this.lastBatchTime;
+        if (timeSinceLastBatch < this.options.throttleInterval) {
+            const waitTime = this.options.throttleInterval - timeSinceLastBatch;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+        }
+        // Extract requests from queue
+        const batch = this.queue.splice(0, this.options.maxBatchSize);
+        const requests = batch.map(item => item.request);
+        this.lastBatchTime = Date.now();
+        try {
+            // Send batch request
+            const results = await this.sendBatch(requests);
+            // Resolve individual promises
+            for (let i = 0; i < batch.length; i++) {
+                batch[i].resolve(results[i]);
+            }
+        }
+        catch (error) {
+            // Reject all promises in batch
+            for (const item of batch) {
+                item.reject(error);
+            }
+        }
+    }
+    /**
+     * Get current queue size
+     */
+    getQueueSize() {
+        return this.queue.length;
+    }
+    /**
+     * Clear the queue without sending
+     */
+    clear() {
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        // Reject all pending requests
+        for (const item of this.queue) {
+            item.reject(new Error('Batch queue cleared'));
+        }
+        this.queue = [];
+    }
+}

package/dist/types.d.ts

@@ -1,26 +1,13 @@
 /**
- * Core connection types
+ * Core signaling types
+ */
+/**
+ * Cleanup function returned by listener methods
+ */
+export type Binnable = () => void;
+/**
+ * Signaler interface for WebRTC offer/answer/ICE exchange
  */
-import { EventBus } from './event-bus.js';
-import { Binnable } from './bin.js';
-export type Message = string | ArrayBuffer;
-export interface QueueMessageOptions {
-    expiresAt?: number;
-}
-export interface ConnectionEvents {
-    'state-change': ConnectionInterface['state'];
-    message: Message;
-}
-export declare const ConnectionStates: readonly ["connected", "disconnected", "connecting"];
-export declare const isConnectionState: (state: string) => state is (typeof ConnectionStates)[number];
-export interface ConnectionInterface {
-    state: (typeof ConnectionStates)[number];
-    lastActive: number;
-    expiresAt?: number;
-    events: EventBus<ConnectionEvents>;
-    queueMessage(message: Message, options?: QueueMessageOptions): Promise<void>;
-    sendMessage(message: Message): Promise<boolean>;
-}
 export interface Signaler {
     addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
     addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;

package/dist/types.js

@@ -1,6 +1,4 @@
-export const ConnectionStates = [
-    'connected',
-    'disconnected',
-    'connecting'
-];
-export const isConnectionState = (state) => ConnectionStates.includes(state);
+/**
+ * Core signaling types
+ */
+export {};

package/dist/web-crypto-adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Web Crypto adapter for browser environments
+ */
+import { CryptoAdapter, Keypair } from './crypto-adapter.js';
+/**
+ * Web Crypto implementation using browser APIs
+ * Uses btoa/atob for base64 encoding and crypto.getRandomValues for random bytes
+ */
+export declare class WebCryptoAdapter implements CryptoAdapter {
+    generateKeypair(): Promise<Keypair>;
+    signMessage(message: string, privateKeyBase64: string): Promise<string>;
+    verifySignature(message: string, signatureBase64: string, publicKeyBase64: string): Promise<boolean>;
+    bytesToBase64(bytes: Uint8Array): string;
+    base64ToBytes(base64: string): Uint8Array;
+    randomBytes(length: number): Uint8Array;
+}

package/dist/web-crypto-adapter.js

@@ -0,0 +1,52 @@
+/**
+ * Web Crypto adapter for browser environments
+ */
+import * as ed25519 from '@noble/ed25519';
+// Set SHA-512 hash function for ed25519 (required in @noble/ed25519 v3+)
+ed25519.hashes.sha512Async = async (message) => {
+    return new Uint8Array(await crypto.subtle.digest('SHA-512', message));
+};
+/**
+ * Web Crypto implementation using browser APIs
+ * Uses btoa/atob for base64 encoding and crypto.getRandomValues for random bytes
+ */
+export class WebCryptoAdapter {
+    async generateKeypair() {
+        const privateKey = ed25519.utils.randomSecretKey();
+        const publicKey = await ed25519.getPublicKeyAsync(privateKey);
+        return {
+            publicKey: this.bytesToBase64(publicKey),
+            privateKey: this.bytesToBase64(privateKey),
+        };
+    }
+    async signMessage(message, privateKeyBase64) {
+        const privateKey = this.base64ToBytes(privateKeyBase64);
+        const encoder = new TextEncoder();
+        const messageBytes = encoder.encode(message);
+        const signature = await ed25519.signAsync(messageBytes, privateKey);
+        return this.bytesToBase64(signature);
+    }
+    async verifySignature(message, signatureBase64, publicKeyBase64) {
+        try {
+            const signature = this.base64ToBytes(signatureBase64);
+            const publicKey = this.base64ToBytes(publicKeyBase64);
+            const encoder = new TextEncoder();
+            const messageBytes = encoder.encode(message);
+            return await ed25519.verifyAsync(signature, messageBytes, publicKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    bytesToBase64(bytes) {
+        const binString = Array.from(bytes, byte => String.fromCodePoint(byte)).join('');
+        return btoa(binString);
+    }
+    base64ToBytes(base64) {
+        const binString = atob(base64);
+        return Uint8Array.from(binString, char => char.codePointAt(0));
+    }
+    randomBytes(length) {
+        return crypto.getRandomValues(new Uint8Array(length));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.12.4",
+  "version": "0.17.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",

package/dist/bin.d.ts

@@ -1,35 +0,0 @@
-/**
- * Binnable - A cleanup function that can be synchronous or asynchronous
- *
- * Used to unsubscribe from events, close connections, or perform other cleanup operations.
- */
-export type Binnable = () => void | Promise<void>;
-/**
- * Create a cleanup function collector (garbage bin)
- *
- * Collects cleanup functions and provides a single `clean()` method to execute all of them.
- * Useful for managing multiple cleanup operations in a single place.
- *
- * @returns A function that accepts cleanup functions and has a `clean()` method
- *
- * @example
- * ```typescript
- * const bin = createBin();
- *
- * // Add cleanup functions
- * bin(
- *   () => console.log('Cleanup 1'),
- *   () => connection.close(),
- *   () => clearInterval(timer)
- * );
- *
- * // Later, clean everything
- * bin.clean(); // Executes all cleanup functions
- * ```
- */
-export declare const createBin: () => ((...rubbish: Binnable[]) => number) & {
-    /**
-     * Execute all cleanup functions and clear the bin
-     */
-    clean: () => void;
-};

package/dist/bin.js

@@ -1,35 +0,0 @@
-/**
- * Create a cleanup function collector (garbage bin)
- *
- * Collects cleanup functions and provides a single `clean()` method to execute all of them.
- * Useful for managing multiple cleanup operations in a single place.
- *
- * @returns A function that accepts cleanup functions and has a `clean()` method
- *
- * @example
- * ```typescript
- * const bin = createBin();
- *
- * // Add cleanup functions
- * bin(
- *   () => console.log('Cleanup 1'),
- *   () => connection.close(),
- *   () => clearInterval(timer)
- * );
- *
- * // Later, clean everything
- * bin.clean(); // Executes all cleanup functions
- * ```
- */
-export const createBin = () => {
-    const bin = [];
-    return Object.assign((...rubbish) => bin.push(...rubbish), {
-        /**
-         * Execute all cleanup functions and clear the bin
-         */
-        clean: () => {
-            bin.forEach(binnable => binnable());
-            bin.length = 0;
-        },
-    });
-};

package/dist/connection-manager.d.ts

@@ -1,104 +0,0 @@
-import { WebRTCRondevuConnection } from './connection.js';
-import { Credentials } from './api.js';
-import { ConnectionInterface } from './types.js';
-export interface ConnectionManagerOptions {
-    apiUrl: string;
-    username: string;
-    credentials?: Credentials;
-    autoReconnect?: boolean;
-    reconnectDelay?: number;
-    maxReconnectAttempts?: number;
-}
-export interface HostServiceOptions {
-    service: string;
-    ttl?: number;
-    onConnection?: (connection: ConnectionInterface) => void;
-}
-export interface ConnectToServiceOptions {
-    username: string;
-    service: string;
-    onConnection?: (connection: ConnectionInterface) => void;
-}
-/**
- * ConnectionManager - High-level connection management
- *
- * @example
- * // Host a service
- * const manager = new ConnectionManager({
- *   apiUrl: 'https://api.ronde.vu',
- *   credentials: await api.register()
- * })
- *
- * await manager.hostService({
- *   service: 'chat.app@1.0.0',
- *   onConnection: (conn) => {
- *     conn.events.on('message', msg => console.log('Received:', msg))
- *   }
- * })
- *
- * @example
- * // Connect to a service
- * const connection = await manager.connectToService({
- *   username: 'alice',
- *   service: 'chat.app@1.0.0'
- * })
- *
- * await connection.sendMessage('Hello!')
- */
-export declare class ConnectionManager {
-    private readonly api;
-    private readonly username;
-    private readonly connections;
-    private readonly autoReconnect;
-    private readonly reconnectDelay;
-    private readonly maxReconnectAttempts;
-    private readonly bin;
-    constructor(options: ConnectionManagerOptions);
-    /**
-     * Host a service - Creates an offer and publishes it to the signaling server
-     *
-     * The service will automatically accept incoming connections and manage them.
-     * Each new connection triggers the onConnection callback.
-     *
-     * @param options - Service hosting options
-     * @returns Promise that resolves when the service is published
-     */
-    hostService(options: HostServiceOptions): Promise<void>;
-    /**
-     * Connect to a hosted service
-     *
-     * Searches for the service, retrieves the offer, and creates an answering connection.
-     *
-     * @param options - Connection options
-     * @returns The established connection
-     */
-    connectToService(options: ConnectToServiceOptions): Promise<WebRTCRondevuConnection>;
-    /**
-     * Get a connection by ID
-     */
-    getConnection(id: string): WebRTCRondevuConnection | undefined;
-    /**
-     * Get all managed connections
-     */
-    getAllConnections(): WebRTCRondevuConnection[];
-    /**
-     * Remove a connection
-     */
-    private removeConnection;
-    /**
-     * Schedule reconnection for a failed connection
-     */
-    private scheduleReconnect;
-    /**
-     * Attempt to reconnect a failed connection
-     */
-    private attemptReconnect;
-    /**
-     * Create a temporary signaler (used during initial offer creation)
-     */
-    private createTempSignaler;
-    /**
-     * Clean up all connections and resources
-     */
-    destroy(): void;
-}