node-datachannel 0.10.1 → 0.12.0

package/polyfill/index.cjs

@@ -2,9 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var DOMException$1 = require('node-domexception');
+require('node-domexception');
 var module$1 = require('module');
 var stream = require('stream');
+var events = require('events');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 class RTCCertificate {
@@ -25,6 +26,26 @@ class RTCCertificate {
     }
 }
 
+const InvalidStateError = (msg) => {
+    return new DOMException(msg, 'InvalidStateError');
+};
+
+const InvalidAccessError = (msg) => {
+    return new DOMException(msg, 'InvalidAccessError');
+};
+
+const NotFoundError = (msg) => {
+    return new DOMException(msg, 'NotFoundError');
+};
+
+const OperationError = (msg) => {
+    return new DOMException(msg, 'OperationError');
+};
+
+const SyntaxError = (msg) => {
+    return new DOMException(msg, 'SyntaxError');
+};
+
 class _RTCDataChannel extends EventTarget {
     #dataChannel;
     #readyState;
@@ -35,6 +56,8 @@ class _RTCDataChannel extends EventTarget {
     #negotiated;
     #ordered;
 
+    #closeRequested = false;
+
     onbufferedamountlow;
     onclose;
     onclosing;
@@ -57,12 +80,20 @@ class _RTCDataChannel extends EventTarget {
         // forward dataChannel events
         this.#dataChannel.onOpen(() => {
             this.#readyState = 'open';
-            this.dispatchEvent(new Event('open'));
+            this.dispatchEvent(new Event('open', { channel: this }));
         });
 
         this.#dataChannel.onClosed(() => {
-            this.#readyState = 'closed';
-            this.dispatchEvent(new Event('close'));
+            // Simulate closing event
+            if (!this.#closeRequested) {
+                this.#readyState = 'closing';
+                this.dispatchEvent(new Event('closing', { channel: this }));
+            }
+
+            setImmediate(() => {
+                this.#readyState = 'closed';
+                this.dispatchEvent(new Event('close', { channel: this }));
+            });
         });
 
         this.#dataChannel.onError((msg) => {
@@ -79,7 +110,7 @@ class _RTCDataChannel extends EventTarget {
         });
 
         this.#dataChannel.onBufferedAmountLow(() => {
-            this.dispatchEvent(new Event('bufferedamountlow'));
+            this.dispatchEvent(new Event('bufferedamountlow', { channel: this }));
         });
 
         this.#dataChannel.onMessage((data) => {
@@ -87,7 +118,7 @@ class _RTCDataChannel extends EventTarget {
                 data = data.buffer;
             }
 
-            this.dispatchEvent(new MessageEvent('message', { data }));
+            this.dispatchEvent(new MessageEvent('message', { data, channel: this }));
         });
 
         // forward events to properties
@@ -113,7 +144,7 @@ class _RTCDataChannel extends EventTarget {
 
     set binaryType(type) {
         if (type !== 'blob' && type !== 'arraybuffer') {
-            throw new DOMException$1(
+            throw new DOMException(
                 "Failed to set the 'binaryType' property on 'RTCDataChannel': Unknown binary type : " + type,
                 'TypeMismatchError',
             );
@@ -173,9 +204,8 @@ class _RTCDataChannel extends EventTarget {
 
     send(data) {
         if (this.#readyState !== 'open') {
-            throw new DOMException$1(
+            throw InvalidStateError(
                 "Failed to execute 'send' on 'RTCDataChannel': RTCDataChannel.readyState is not 'open'",
-                'InvalidStateError',
             );
         }
 
@@ -192,9 +222,7 @@ class _RTCDataChannel extends EventTarget {
     }
 
     close() {
-        this.#readyState = 'closing';
-        this.dispatchEvent(new Event('closing'));
-
+        this.#closeRequested = true;
         this.#dataChannel.close();
     }
 }
@@ -219,41 +247,40 @@ class _RTCIceCandidate {
     #tcpType;
     #type;
     #usernameFragment;
-    #ip;
 
     constructor({ candidate, sdpMLineIndex, sdpMid, usernameFragment }) {
-        if (candidate == null) {
-            throw new DOMException$1('candidate must be specified');
-        }
+        if (sdpMLineIndex == null && sdpMid == null)
+            throw new TypeError('At least one of sdpMLineIndex or sdpMid must be specified');
 
-        this.#candidate = candidate;
-        this.#sdpMLineIndex = sdpMLineIndex || null;
-        this.#sdpMid = sdpMid || null;
-        this.#usernameFragment = usernameFragment || null;
+        this.#candidate = candidate === null ? 'null' : candidate ?? '';
+        this.#sdpMLineIndex = sdpMLineIndex ?? null;
+        this.#sdpMid = sdpMid ?? null;
+        this.#usernameFragment = usernameFragment ?? null;
 
         if (candidate) {
             const fields = candidate.split(' ');
-            this.#foundation = fields[0];
+            this.#foundation = fields[0].replace('candidate:', ''); // remove text candidate:
             this.#component = fields[1] == '1' ? 'rtp' : 'rtcp';
             this.#protocol = fields[2];
             this.#priority = parseInt(fields[3], 10);
-            this.#ip = fields[4];
+            this.#address = fields[4];
             this.#port = parseInt(fields[5], 10);
             this.#type = fields[7];
-            if (fields[6] === 'typ') {
-                this.#tcpType = null;
-            } else if (fields[6] === 'tcp') {
-                this.#tcpType = fields[7];
-                this.#type = fields[8];
-            }
+            this.#tcpType = null;
+            this.#relatedAddress = null;
+            this.#relatedPort = null;
 
             // Parse the candidate string to extract relatedPort and relatedAddress
-            for (let i = 9; i < fields.length; i++) {
+            for (let i = 8; i < fields.length; i++) {
                 const field = fields[i];
-                if (field.startsWith('raddr')) {
-                    this.#relatedAddress = field.split('=')[1];
-                } else if (field.startsWith('rport')) {
-                    this.#relatedPort = parseInt(field.split('=')[1], 10);
+                if (field === 'raddr') {
+                    this.#relatedAddress = fields[i + 1];
+                } else if (field === 'rport') {
+                    this.#relatedPort = parseInt(fields[i + 1], 10);
+                }
+
+                if (this.#protocol === 'tcp' && field === 'tcptype') {
+                    this.#tcpType = fields[i + 1];
                 }
             }
         }
@@ -264,7 +291,7 @@ class _RTCIceCandidate {
     }
 
     get candidate() {
-        return this.#candidate || '';
+        return this.#candidate;
     }
 
     get component() {
@@ -451,6 +478,11 @@ class _RTCDtlsTransport extends EventTarget {
     }
 }
 
+// createRequire is native in node version >= 12
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+
+const nodeDataChannel = require$1('../build/Release/node_datachannel.node');
+
 /**
  * Turns a node-datachannel DataChannel into a real Node.js stream, complete with buffering,
  * backpressure (up to a point - if the buffer fills up, messages are dropped), and
@@ -546,13 +578,65 @@ class DataChannelStream extends stream.Duplex {
     }
 }
 
-// createRequire is native in node version >= 12
-const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+class WebSocketServer extends events.EventEmitter {
+    #server;
+    #clients = [];
 
-const nodeDataChannel = require$1('../build/Release/node_datachannel.node');
+    constructor(options) {
+        super();
+        this.#server = new nodeDataChannel.WebSocketServer(options);
+
+        this.#server.onClient((client) => {
+            this.emit('client', client);
+            this.#clients.push(client);
+        });
+    }
+
+    port() {
+        return this.#server?.port() || 0;
+    }
+
+    stop() {
+        this.#clients.forEach((client) => {
+            client?.close();
+        });
+        this.#server?.stop();
+        this.#server = null;
+        this.removeAllListeners();
+    }
+
+    onClient(cb) {
+        if (this.#server) this.on('client', cb);
+    }
+}
+
+const {
+    initLogger,
+    cleanup,
+    preload,
+    setSctpSettings,
+    RtcpReceivingSession,
+    Track,
+    Video,
+    Audio,
+    DataChannel,
+    PeerConnection,
+    WebSocket,
+} = nodeDataChannel;
 
 var NodeDataChannel = {
-    ...nodeDataChannel,
+    initLogger,
+    cleanup,
+    preload,
+    setSctpSettings,
+    RtcpReceivingSession,
+    Track,
+    Video,
+    Audio,
+    DataChannel,
+    PeerConnection,
+    WebSocket,
+    WebSocketServer,
     DataChannelStream,
 };
 
@@ -611,10 +695,12 @@ class RTCPeerConnectionIceEvent extends Event {
 class RTCDataChannelEvent extends Event {
     #channel;
 
-    constructor(channel) {
-        super('datachannel');
+    constructor(type, eventInitDict) {
+        super(type);
+
+        if (type && !eventInitDict.channel) throw new TypeError('channel member is required');
 
-        this.#channel = channel;
+        this.#channel = eventInitDict?.channel;
     }
 
     get channel() {
@@ -683,6 +769,7 @@ class _RTCPeerConnection extends EventTarget {
     #localOffer;
     #localAnswer;
     #dataChannels;
+    #dataChannelsClosed = 0;
     #config;
     #canTrickleIceCandidates;
     #sctp;
@@ -700,32 +787,106 @@ class _RTCPeerConnection extends EventTarget {
     onsignalingstatechange;
     ontrack;
 
-    constructor(init = {}) {
+    _checkConfiguration(config) {
+        if (config && config.iceServers === undefined) config.iceServers = [];
+        if (config && config.iceTransportPolicy === undefined) config.iceTransportPolicy = 'all';
+
+        if (config?.iceServers === null) throw new TypeError('IceServers cannot be null');
+
+        // Check for all the properties of iceServers
+        if (Array.isArray(config?.iceServers)) {
+            for (let i = 0; i < config.iceServers.length; i++) {
+                if (config.iceServers[i] === null) throw new TypeError('IceServers cannot be null');
+                if (config.iceServers[i] === undefined) throw new TypeError('IceServers cannot be undefined');
+                if (Object.keys(config.iceServers[i]).length === 0) throw new TypeError('IceServers cannot be empty');
+
+                // If iceServers is string convert to array
+                if (typeof config.iceServers[i].urls === 'string')
+                    config.iceServers[i].urls = [config.iceServers[i].urls];
+
+                // urls can not be empty
+                if (config.iceServers[i].urls?.some((url) => url == ''))
+                    throw SyntaxError('IceServers urls cannot be empty');
+
+                // urls should be valid URLs and match the protocols "stun:|turn:|turns:"
+                if (
+                    config.iceServers[i].urls?.some(
+                        (url) => {
+                            try {
+                                const parsedURL = new URL(url);
+
+                                return !/^(stun:|turn:|turns:)$/.test(parsedURL.protocol)
+                            } catch (error) {
+                                return true
+                            }
+                        },
+                    )
+                )
+                    throw SyntaxError('IceServers urls wrong format');
+
+                // If this is a turn server check for username and credential
+                if (config.iceServers[i].urls?.some((url) => url.startsWith('turn'))) {
+                    if (!config.iceServers[i].username)
+                        throw InvalidAccessError('IceServers username cannot be null');
+                    if (!config.iceServers[i].credential)
+                        throw InvalidAccessError('IceServers username cannot be undefined');
+                }
+
+                // length of urls can not be 0
+                if (config.iceServers[i].urls?.length === 0)
+                    throw SyntaxError('IceServers urls cannot be empty');
+            }
+        }
+
+        if (
+            config &&
+            config.iceTransportPolicy &&
+            config.iceTransportPolicy !== 'all' &&
+            config.iceTransportPolicy !== 'relay'
+        )
+            throw new TypeError('IceTransportPolicy must be either "all" or "relay"');
+    }
+
+    setConfiguration(config) {
+        this._checkConfiguration(config);
+        this.#config = config;
+    }
+
+    constructor(config = { iceServers: [], iceTransportPolicy: 'all' }) {
         super();
 
-        this.#config = init;
+        this._checkConfiguration(config);
+        this.#config = config;
         this.#localOffer = createDeferredPromise();
         this.#localAnswer = createDeferredPromise();
         this.#dataChannels = new Set();
         this.#canTrickleIceCandidates = null;
 
-        this.#peerConnection = new NodeDataChannel.PeerConnection(init?.peerIdentity ?? `peer-${getRandomString(7)}`, {
-            ...init,
-            iceServers:
-                init?.iceServers
-                    ?.map((server) => {
-                        const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
-
-                        return urls.map((url) => {
-                            if (server.username && server.credential) {
-                                const [protocol, rest] = url.split(/:(.*)/);
-                                return `${protocol}:${server.username}:${server.credential}@${rest}`;
-                            }
-                            return url;
-                        });
-                    })
-                    .flat() ?? [],
-        });
+        try {
+            this.#peerConnection = new NodeDataChannel.PeerConnection(
+                config?.peerIdentity ?? `peer-${getRandomString(7)}`,
+                {
+                    ...config,
+                    iceServers:
+                        config?.iceServers
+                            ?.map((server) => {
+                                const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
+
+                                return urls.map((url) => {
+                                    if (server.username && server.credential) {
+                                        const [protocol, rest] = url.split(/:(.*)/);
+                                        return `${protocol}:${server.username}:${server.credential}@${rest}`;
+                                    }
+                                    return url;
+                                });
+                            })
+                            .flat() ?? [],
+                },
+            );
+        } catch (error) {
+            if (!error || !error.message) throw NotFoundError('Unknown error');
+            throw SyntaxError(error.message);
+        }
 
         // forward peerConnection events
         this.#peerConnection.onStateChange(() => {
@@ -745,9 +906,9 @@ class _RTCPeerConnection extends EventTarget {
         });
 
         this.#peerConnection.onDataChannel((channel) => {
-            const dataChannel = new _RTCDataChannel(channel);
-            this.#dataChannels.add(dataChannel);
-            this.dispatchEvent(new RTCDataChannelEvent(dataChannel));
+            const dc = new _RTCDataChannel(channel);
+            this.#dataChannels.add(dc);
+            this.dispatchEvent(new RTCDataChannelEvent('datachannel', { channel: dc }));
         });
 
         this.#peerConnection.onLocalDescription((sdp, type) => {
@@ -821,7 +982,11 @@ class _RTCPeerConnection extends EventTarget {
     }
 
     get iceConnectionState() {
-        return this.#peerConnection.iceState();
+        let state = this.#peerConnection.iceState();
+        // libdatachannel uses 'completed' instead of 'connected'
+        // see /webrtc/getstats.html
+        if (state == 'completed') state = 'connected';
+        return state;
     }
 
     get iceGatheringState() {
@@ -861,14 +1026,45 @@ class _RTCPeerConnection extends EventTarget {
     }
 
     async addIceCandidate(candidate) {
-        if (candidate == null || candidate.candidate == null) {
-            throw new DOMException('Candidate invalid');
+        if (!candidate || !candidate.candidate) {
+            return;
+        }
+
+        if (candidate.sdpMid === null && candidate.sdpMLineIndex === null) {
+            throw new TypeError('sdpMid must be set');
+        }
+
+        if (candidate.sdpMid === undefined && candidate.sdpMLineIndex == undefined) {
+            throw new TypeError('sdpMid must be set');
+        }
+
+        // Reject if sdpMid format is not valid
+        // ??
+        if (candidate.sdpMid && candidate.sdpMid.length > 3) {
+            // console.log(candidate.sdpMid);
+            throw OperationError('Invalid sdpMid format');
         }
 
-        this.#remoteCandidates.push(
-            new _RTCIceCandidate({ candidate: candidate.candidate, sdpMid: candidate.sdpMid || '0' }),
-        );
-        this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
+        // We don't care about sdpMLineIndex, just for test
+        if (!candidate.sdpMid && candidate.sdpMLineIndex > 1) {
+            throw OperationError('This is only for test case.');
+        }
+
+        try {
+            this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
+            this.#remoteCandidates.push(
+                new _RTCIceCandidate({ candidate: candidate.candidate, sdpMid: candidate.sdpMid || '0' }),
+            );
+        } catch (error) {
+            if (!error || !error.message) throw NotFoundError('Unknown error');
+
+            // Check error Message if contains specific message
+            if (error.message.includes('remote candidate without remote description'))
+                throw InvalidStateError(error.message);
+            if (error.message.includes('Invalid candidate format')) throw OperationError(error.message);
+
+            throw NotFoundError(error.message);
+        }
     }
 
     addTrack(track, ...streams) {
@@ -883,6 +1079,7 @@ class _RTCPeerConnection extends EventTarget {
         // close all channels before shutting down
         this.#dataChannels.forEach((channel) => {
             channel.close();
+            this.#dataChannelsClosed++;
         });
 
         this.#peerConnection.close();
@@ -900,6 +1097,7 @@ class _RTCPeerConnection extends EventTarget {
         this.#dataChannels.add(dataChannel);
         dataChannel.addEventListener('close', () => {
             this.#dataChannels.delete(dataChannel);
+            this.#dataChannelsClosed++;
         });
 
         return dataChannel;
@@ -933,7 +1131,7 @@ class _RTCPeerConnection extends EventTarget {
             let localId = 'RTCIceCandidate_' + localIdRs;
             report.set(localId, {
                 id: localId,
-                type: 'localcandidate',
+                type: 'local-candidate',
                 timestamp: Date.now(),
                 candidateType: cp.local.type,
                 ip: cp.local.address,
@@ -944,7 +1142,7 @@ class _RTCPeerConnection extends EventTarget {
             let remoteId = 'RTCIceCandidate_' + remoteIdRs;
             report.set(remoteId, {
                 id: remoteId,
-                type: 'remotecandidate',
+                type: 'remote-candidate',
                 timestamp: Date.now(),
                 candidateType: cp.remote.type,
                 ip: cp.remote.address,
@@ -979,6 +1177,15 @@ class _RTCPeerConnection extends EventTarget {
                 selectedCandidatePairChanges: 1,
             });
 
+            // peer-connection'
+            report.set('P', {
+                id: 'P',
+                type: 'peer-connection',
+                timestamp: Date.now(),
+                dataChannelsOpened: this.#dataChannels.size,
+                dataChannelsClosed: this.#dataChannelsClosed,
+            });
+
             return resolve(report);
         });
     }
@@ -995,20 +1202,13 @@ class _RTCPeerConnection extends EventTarget {
         throw new DOMException('Not implemented');
     }
 
-    setConfiguration(config) {
-        this.#config = config;
-    }
-
     async setLocalDescription(description) {
-        if (description == null || description.type == null) {
-            throw new DOMException('Local description type must be set');
-        }
-
-        if (description.type !== 'offer') {
+        if (description?.type !== 'offer') {
             // any other type causes libdatachannel to throw
             return;
         }
-        this.#peerConnection.setLocalDescription(description.type);
+
+        this.#peerConnection.setLocalDescription(description?.type);
     }
 
     async setRemoteDescription(description) {
@@ -1039,6 +1239,72 @@ function getRandomString(length) {
         .substring(2, 2 + length);
 }
 
+let RTCError$1 = class RTCError extends DOMException {
+    constructor(init, message = '') {
+        super(message, 'OperationError');
+
+        if (!init || !init.errorDetail) throw new TypeError('Cannot construct RTCError, errorDetail is required');
+        if (
+            [
+                'data-channel-failure',
+                'dtls-failure',
+                'fingerprint-failure',
+                'hardware-encoder-error',
+                'hardware-encoder-not-available',
+                'sctp-failure',
+                'sdp-syntax-error',
+            ].indexOf(init.errorDetail) === -1
+        )
+            throw new TypeError('Cannot construct RTCError, errorDetail is invalid');
+
+        this._errorDetail = init.errorDetail;
+        this._receivedAlert = init.receivedAlert ?? null;
+        this._sctpCauseCode = init.sctpCauseCode ?? null;
+        this._sdpLineNumber = init.sdpLineNumber ?? null;
+        this._sentAlert = init.sentAlert ?? null;
+    }
+
+    get errorDetail() {
+        return this._errorDetail;
+    }
+
+    set errorDetail(value) {
+        throw new TypeError('Cannot set errorDetail, it is read-only');
+    }
+
+    get receivedAlert() {
+        return this._receivedAlert;
+    }
+
+    set receivedAlert(value) {
+        throw new TypeError('Cannot set receivedAlert, it is read-only');
+    }
+
+    get sctpCauseCode() {
+        return this._sctpCauseCode;
+    }
+
+    set sctpCauseCode(value) {
+        throw new TypeError('Cannot set sctpCauseCode, it is read-only');
+    }
+
+    get sdpLineNumber() {
+        return this._sdpLineNumber;
+    }
+
+    set sdpLineNumber(value) {
+        throw new TypeError('Cannot set sdpLineNumber, it is read-only');
+    }
+
+    get sentAlert() {
+        return this._sentAlert;
+    }
+
+    set sentAlert(value) {
+        throw new TypeError('Cannot set sentAlert, it is read-only');
+    }
+};
+
 var index = {
     RTCCertificate,
     RTCDataChannel: _RTCDataChannel,
@@ -1050,12 +1316,14 @@ var index = {
     RTCSessionDescription: _RTCSessionDescription,
     RTCDataChannelEvent,
     RTCPeerConnectionIceEvent,
+    RTCError: RTCError$1,
 };
 
 exports.RTCCertificate = RTCCertificate;
 exports.RTCDataChannel = _RTCDataChannel;
 exports.RTCDataChannelEvent = RTCDataChannelEvent;
 exports.RTCDtlsTransport = _RTCDtlsTransport;
+exports.RTCError = RTCError$1;
 exports.RTCIceCandidate = _RTCIceCandidate;
 exports.RTCIceTransport = _RTCIceTransport;
 exports.RTCPeerConnection = _RTCPeerConnection;

package/polyfill/index.js

@@ -7,6 +7,7 @@ import RTCPeerConnection from './RTCPeerConnection.js';
 import RTCSctpTransport from './RTCSctpTransport.js';
 import RTCSessionDescription from './RTCSessionDescription.js';
 import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
+import RTCError from './RTCError.js';
 
 export {
     RTCCertificate,
@@ -19,6 +20,7 @@ export {
     RTCSessionDescription,
     RTCDataChannelEvent,
     RTCPeerConnectionIceEvent,
+    RTCError,
 };
 
 export default {
@@ -32,4 +34,5 @@ export default {
     RTCSessionDescription,
     RTCDataChannelEvent,
     RTCPeerConnectionIceEvent,
+    RTCError,
 };