node-rtc-connection 1.0.4 → 1.0.6

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "node-rtc-connection",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "WebRTC DataChannel implementation for Node.js with STUN, TURN, NAT traversal, and encryption. Pure Node.js, no native dependencies.",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
+  "types": "src/index.d.ts",
   "exports": {
     ".": {
+      "types": "./src/index.d.ts",
       "require": "./dist/index.cjs",
       "import": "./dist/index.mjs"
     }

package/src/NativePeerConnectionFactory.js

@@ -100,6 +100,9 @@ class NativePeerConnection extends EventEmitter {
     this._secureConnection = null;
     this._udpTransport = null;
     this._iceCandidates = [];
+    this._remoteCandidates = [];
+    this._selectedLocalCandidate = null;
+    this._selectedRemoteCandidate = null;
     
     console.log('[NativePeerConnection] Created with STUN/ICE/Encryption support');
     console.log(`  - Encryption: ${this._useEncryption ? 'enabled' : 'disabled (requires valid certs)'}`);
@@ -245,22 +248,106 @@ class NativePeerConnection extends EventEmitter {
     }
 
     if (!candidate || !candidate.candidate) {
+      // null candidate signals end of candidates - try to select best pair
+      if (this._remoteCandidates.length > 0 && !this._selectedRemoteCandidate) {
+        this._selectBestCandidatePair();
+      }
+      return;
+    }
+
+    // Parse ICE candidate
+    const parsed = this._parseIceCandidate(candidate.candidate);
+    if (!parsed) {
       return;
     }
 
-    // Parse ICE candidate to extract address and port
-    const parts = candidate.candidate.split(' ');
-    if (parts.length >= 6) {
-      this._remoteAddress = parts[4];
-      this._remotePort = parseInt(parts[5], 10);
+    // Store the remote candidate
+    this._remoteCandidates.push(parsed);
+    console.log(`[NativePeerConnection] Added remote ICE candidate (${parsed.type}): ${parsed.ip}:${parsed.port}`);
+
+    // For backward compatibility, set remote address immediately if not set
+    if (!this._remoteAddress) {
+      this._remoteAddress = parsed.ip;
+      this._remotePort = parsed.port;
       console.log(`[NativePeerConnection] Remote address: ${this._remoteAddress}:${this._remotePort}`);
-      
-      // If we have both local and remote info, and we're offerer, connect
-      if (this._isOfferer && this._localAddress && this._remoteAddress && 
-          this._signalingState === 0 && !this._socket) {
-        await this._connectToPeer();
+    }
+
+    // If we haven't selected a pair yet, try to select now
+    if (!this._selectedRemoteCandidate && this._iceCandidates.length > 0) {
+      this._selectBestCandidatePair();
+    }
+
+    // If we selected a pair and are offerer, connect
+    if (this._selectedRemoteCandidate && this._isOfferer && 
+        this._signalingState === 0 && !this._socket) {
+      await this._connectToPeer();
+    }
+  }
+
+  /**
+   * Parse ICE candidate string
+   * @private
+   */
+  _parseIceCandidate(candidateStr) {
+    const parts = candidateStr.split(' ');
+    if (parts.length < 6) {
+      return null;
+    }
+
+    return {
+      foundation: parts[0].replace('candidate:', ''),
+      component: parts[1],
+      protocol: parts[2],
+      priority: parseInt(parts[3], 10),
+      ip: parts[4],
+      port: parseInt(parts[5], 10),
+      type: parts[7], // typ host/srflx/relay
+      relatedAddress: parts[9] || null,
+      relatedPort: parts[11] ? parseInt(parts[11], 10) : null
+    };
+  }
+
+  /**
+   * Select best candidate pair for connection
+   * Prioritizes: relay > srflx > host
+   * @private
+   */
+  _selectBestCandidatePair() {
+    if (this._remoteCandidates.length === 0 || this._iceCandidates.length === 0) {
+      return;
+    }
+
+    // Priority order: relay > srflx > host
+    const typePriority = { 'relay': 3, 'srflx': 2, 'host': 1 };
+
+    // Find best local candidate
+    let bestLocal = this._iceCandidates[0];
+    for (const candidate of this._iceCandidates) {
+      if (typePriority[candidate.type] > typePriority[bestLocal.type]) {
+        bestLocal = candidate;
+      }
+    }
+
+    // Find best remote candidate
+    let bestRemote = this._remoteCandidates[0];
+    for (const candidate of this._remoteCandidates) {
+      if (typePriority[candidate.type] > typePriority[bestRemote.type]) {
+        bestRemote = candidate;
       }
     }
+
+    this._selectedLocalCandidate = bestLocal;
+    this._selectedRemoteCandidate = bestRemote;
+
+    // Update addresses for connection
+    this._localAddress = bestLocal.ip;
+    this._localPort = bestLocal.port;
+    this._remoteAddress = bestRemote.ip;
+    this._remotePort = bestRemote.port;
+
+    console.log(`[NativePeerConnection] Selected candidate pair:`);
+    console.log(`  Local: ${bestLocal.type} ${this._localAddress}:${this._localPort}`);
+    console.log(`  Remote: ${bestRemote.type} ${this._remoteAddress}:${this._remotePort}`);
   }
 
   /**
@@ -396,14 +483,24 @@ class NativePeerConnection extends EventEmitter {
       return;
     }
 
-    // Tie-breaking: only connect if our port is higher than remote port
-    // This ensures only one peer connects, avoiding the race condition
-    if (this._localPort < this._remotePort) {
-      console.log(`[NativePeerConnection] Not connecting (local port ${this._localPort} < remote port ${this._remotePort}), waiting for incoming`);
-      return;
+    // Check if we're using relay candidates - if so, skip tie-breaking
+    const usingRelay = this._selectedLocalCandidate?.type === 'relay' || 
+                       this._selectedRemoteCandidate?.type === 'relay';
+
+    if (!usingRelay) {
+      // Tie-breaking: only connect if our port is higher than remote port
+      // This ensures only one peer connects, avoiding the race condition
+      // Note: This only works for direct connections (host/srflx)
+      if (this._localPort < this._remotePort) {
+        console.log(`[NativePeerConnection] Not connecting (local port ${this._localPort} < remote port ${this._remotePort}), waiting for incoming`);
+        return;
+      }
     }
 
     console.log(`[NativePeerConnection] Connecting to ${this._remoteAddress}:${this._remotePort}`);
+    if (usingRelay) {
+      console.log(`[NativePeerConnection] Using TURN relay connection`);
+    }
     
     this._socket = new net.Socket();
     
@@ -696,7 +793,12 @@ a=max-message-size:262144
       
       // Emit each candidate
       for (const candidate of candidates) {
-        this._iceCandidates.push(candidate);
+        // Parse and store the candidate
+        const parsed = this._parseIceCandidate(candidate.candidate);
+        if (parsed) {
+          this._iceCandidates.push(parsed);
+        }
+
         this.emit('icecandidate', {
           candidate: candidate.candidate,
           sdpMid: candidate.sdpMid,
@@ -710,8 +812,14 @@ a=max-message-size:262144
       
       // Fallback: emit only local host candidate
       if (this._localAddress && this._localPort) {
+        const candidateStr = `candidate:1 1 tcp 2130706431 ${this._localAddress} ${this._localPort} typ host`;
+        const parsed = this._parseIceCandidate(candidateStr);
+        if (parsed) {
+          this._iceCandidates.push(parsed);
+        }
+
         const candidate = {
-          candidate: `candidate:1 1 tcp 2130706431 ${this._localAddress} ${this._localPort} typ host`,
+          candidate: candidateStr,
           sdpMid: 'data',
           sdpMLineIndex: 0
         };

package/src/RTCPeerConnection.js

@@ -3,6 +3,16 @@ const RTCDataChannel = require('./RTCDataChannel');
 const RTCSessionDescription = require('./RTCSessionDescription');
 const RTCIceCandidate = require('./RTCIceCandidate');
 
+// Lazy-load factory to avoid circular dependency
+let _defaultFactory = null;
+function getDefaultFactory() {
+  if (!_defaultFactory) {
+    const NativePeerConnectionFactory = require('./NativePeerConnectionFactory');
+    _defaultFactory = new NativePeerConnectionFactory();
+  }
+  return _defaultFactory;
+}
+
 /**
  * RTCPeerConnection represents a WebRTC connection between the local computer and a remote peer.
  * This is a DataChannel-only implementation ported from Chromium.
@@ -25,7 +35,8 @@ class RTCPeerConnection extends EventEmitter {
     
     // Native peer connection (would be native WebRTC binding)
     this._nativePeerConnection = null;
-    this._nativePeerConnectionFactory = nativePeerConnectionFactory;
+    // Use provided factory or default factory
+    this._nativePeerConnectionFactory = nativePeerConnectionFactory || getDefaultFactory();
     
     // Initialize native peer connection
     this._initializeNativePeerConnection();

package/src/index.d.ts

@@ -0,0 +1,229 @@
+// Type definitions for node-rtc-connection
+// Project: https://github.com/nmhung1210/nodertc
+// Definitions by: nmhung1210
+
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+
+// RTCConfiguration
+export interface RTCIceServer {
+  urls: string | string[];
+  username?: string;
+  credential?: string;
+  credentialType?: 'password' | 'oauth';
+}
+
+export interface RTCConfiguration {
+  iceServers?: RTCIceServer[];
+  iceTransportPolicy?: 'all' | 'relay';
+  bundlePolicy?: 'balanced' | 'max-compat' | 'max-bundle';
+  rtcpMuxPolicy?: 'negotiate' | 'require';
+  iceCandidatePoolSize?: number;
+}
+
+// RTCSessionDescription
+export type RTCSdpType = 'offer' | 'answer' | 'pranswer' | 'rollback';
+
+export interface RTCSessionDescriptionInit {
+  type: RTCSdpType;
+  sdp?: string;
+}
+
+export class RTCSessionDescription {
+  constructor(descriptionInitDict?: RTCSessionDescriptionInit);
+  readonly type: RTCSdpType;
+  readonly sdp: string;
+  toJSON(): RTCSessionDescriptionInit;
+}
+
+// RTCIceCandidate
+export type RTCIceCandidateType = 'host' | 'srflx' | 'prflx' | 'relay';
+export type RTCIceProtocol = 'udp' | 'tcp';
+export type RTCIceTcpCandidateType = 'active' | 'passive' | 'so';
+
+export interface RTCIceCandidateInit {
+  candidate?: string;
+  sdpMid?: string | null;
+  sdpMLineIndex?: number | null;
+  usernameFragment?: string | null;
+}
+
+export class RTCIceCandidate {
+  constructor(candidateInitDict?: RTCIceCandidateInit);
+  readonly candidate: string;
+  readonly sdpMid: string | null;
+  readonly sdpMLineIndex: number | null;
+  readonly foundation: string | null;
+  readonly component: 'rtp' | 'rtcp' | null;
+  readonly priority: number | null;
+  readonly address: string | null;
+  readonly protocol: RTCIceProtocol | null;
+  readonly port: number | null;
+  readonly type: RTCIceCandidateType | null;
+  readonly tcpType: RTCIceTcpCandidateType | null;
+  readonly relatedAddress: string | null;
+  readonly relatedPort: number | null;
+  readonly usernameFragment: string | null;
+  toJSON(): RTCIceCandidateInit;
+}
+
+// RTCDataChannel
+export type RTCDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
+export type RTCBinaryType = 'blob' | 'arraybuffer';
+
+export interface RTCDataChannelInit {
+  ordered?: boolean;
+  maxPacketLifeTime?: number;
+  maxRetransmits?: number;
+  protocol?: string;
+  negotiated?: boolean;
+  id?: number;
+}
+
+export interface RTCDataChannelEventMap {
+  open: Event;
+  message: MessageEvent;
+  error: RTCErrorEvent;
+  close: Event;
+  bufferedamountlow: Event;
+}
+
+export class RTCDataChannel extends EventEmitter {
+  readonly label: string;
+  readonly ordered: boolean;
+  readonly maxPacketLifeTime: number | null;
+  readonly maxRetransmits: number | null;
+  readonly protocol: string;
+  readonly negotiated: boolean;
+  readonly id: number | null;
+  readonly readyState: RTCDataChannelState;
+  readonly bufferedAmount: number;
+  bufferedAmountLowThreshold: number;
+  binaryType: RTCBinaryType;
+
+  close(): void;
+  send(data: string | ArrayBuffer | ArrayBufferView): void;
+
+  on<K extends keyof RTCDataChannelEventMap>(event: K, listener: (ev: RTCDataChannelEventMap[K]) => void): this;
+  once<K extends keyof RTCDataChannelEventMap>(event: K, listener: (ev: RTCDataChannelEventMap[K]) => void): this;
+  off<K extends keyof RTCDataChannelEventMap>(event: K, listener: (ev: RTCDataChannelEventMap[K]) => void): this;
+  emit<K extends keyof RTCDataChannelEventMap>(event: K, ...args: any[]): boolean;
+}
+
+// RTCPeerConnection
+export type RTCSignalingState = 'stable' | 'have-local-offer' | 'have-remote-offer' | 
+  'have-local-pranswer' | 'have-remote-pranswer' | 'closed';
+
+export type RTCIceGatheringState = 'new' | 'gathering' | 'complete';
+
+export type RTCIceConnectionState = 'new' | 'checking' | 'connected' | 'completed' | 
+  'failed' | 'disconnected' | 'closed';
+
+export type RTCPeerConnectionState = 'new' | 'connecting' | 'connected' | 
+  'disconnected' | 'failed' | 'closed';
+
+export interface RTCOfferOptions {
+  iceRestart?: boolean;
+  offerToReceiveAudio?: boolean;
+  offerToReceiveVideo?: boolean;
+}
+
+export interface RTCAnswerOptions {
+  iceRestart?: boolean;
+}
+
+export interface RTCDataChannelEventInit {
+  channel: RTCDataChannel;
+}
+
+export class RTCDataChannelEvent extends Event {
+  constructor(type: string, eventInitDict: RTCDataChannelEventInit);
+  readonly channel: RTCDataChannel;
+}
+
+export interface RTCPeerConnectionIceEventInit {
+  candidate?: RTCIceCandidate | null;
+  url?: string | null;
+}
+
+export class RTCPeerConnectionIceEvent extends Event {
+  constructor(type: string, eventInitDict?: RTCPeerConnectionIceEventInit);
+  readonly candidate: RTCIceCandidate | null;
+  readonly url: string | null;
+}
+
+export interface RTCPeerConnectionEventMap {
+  connectionstatechange: Event;
+  datachannel: RTCDataChannelEvent;
+  icecandidate: RTCPeerConnectionIceEvent;
+  icecandidateerror: Event;
+  iceconnectionstatechange: Event;
+  icegatheringstatechange: Event;
+  negotiationneeded: Event;
+  signalingstatechange: Event;
+}
+
+export class RTCPeerConnection extends EventEmitter {
+  constructor(configuration?: RTCConfiguration, factory?: NativePeerConnectionFactory);
+
+  readonly signalingState: RTCSignalingState;
+  readonly iceGatheringState: RTCIceGatheringState;
+  readonly iceConnectionState: RTCIceConnectionState;
+  readonly connectionState: RTCPeerConnectionState;
+  readonly localDescription: RTCSessionDescription | null;
+  readonly remoteDescription: RTCSessionDescription | null;
+  readonly pendingLocalDescription: RTCSessionDescription | null;
+  readonly pendingRemoteDescription: RTCSessionDescription | null;
+  readonly currentLocalDescription: RTCSessionDescription | null;
+  readonly currentRemoteDescription: RTCSessionDescription | null;
+
+  createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescription>;
+  createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescription>;
+  setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
+  setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+  addIceCandidate(candidate?: RTCIceCandidateInit | null): Promise<void>;
+  createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
+  getConfiguration(): RTCConfiguration;
+  setConfiguration(configuration: RTCConfiguration): void;
+  close(): void;
+  getStats(): Promise<any>;
+
+  on<K extends keyof RTCPeerConnectionEventMap>(event: K, listener: (ev: RTCPeerConnectionEventMap[K]) => void): this;
+  once<K extends keyof RTCPeerConnectionEventMap>(event: K, listener: (ev: RTCPeerConnectionEventMap[K]) => void): this;
+  off<K extends keyof RTCPeerConnectionEventMap>(event: K, listener: (ev: RTCPeerConnectionEventMap[K]) => void): this;
+  emit<K extends keyof RTCPeerConnectionEventMap>(event: K, ...args: any[]): boolean;
+}
+
+// RTCError
+export class RTCError extends Error {
+  constructor(message: string, errorDetail?: string);
+  readonly errorDetail: string;
+}
+
+export interface RTCErrorEventInit {
+  error: RTCError;
+}
+
+export class RTCErrorEvent extends Event {
+  constructor(type: string, eventInitDict: RTCErrorEventInit);
+  readonly error: RTCError;
+}
+
+// NativePeerConnectionFactory
+export class NativePeerConnectionFactory {
+  constructor();
+  initialize(): void;
+  createPeerConnection(configuration: RTCConfiguration): any;
+  dispose(): void;
+}
+
+// Factory functions
+export function createPeerConnection(configuration?: RTCConfiguration): RTCPeerConnection;
+export function createPeerConnectionWithFactory(configuration: RTCConfiguration, factory: NativePeerConnectionFactory): RTCPeerConnection;
+
+// Alias
+export { RTCPeerConnection as RTCConnection };
+
+// Default factory instance
+export const defaultFactory: NativePeerConnectionFactory;

package/src/index.js

@@ -40,6 +40,7 @@ function createPeerConnectionWithFactory(configuration, factory) {
 module.exports = {
   // Main API
   RTCPeerConnection,
+  RTCConnection: RTCPeerConnection, // Alias for convenience
   createPeerConnection,
   createPeerConnectionWithFactory,