node-datachannel 0.10.0 → 0.11.0

package/lib/index.js

@@ -1,9 +1,6 @@
-// createRequire is native in node version >= 12
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-
-const nodeDataChannel = require('../build/Release/node_datachannel.node');
+import nodeDataChannel from './node-datachannel.js';
 import DataChannelStream from './datachannel-stream.js';
+import WebSocketServer from './websocket-server.js';
 
 const {
     initLogger,
@@ -17,9 +14,16 @@ const {
     DataChannel,
     PeerConnection,
     WebSocket,
-    WebSocketServer,
 } = nodeDataChannel;
 
+export const DescriptionType = {
+    Unspec: 'unspec',
+    Offer: 'offer',
+    Answer: 'answer',
+    Pranswer: 'pranswer',
+    Rollback: 'rollback',
+};
+
 export {
     initLogger,
     cleanup,
@@ -38,14 +42,17 @@ export {
 };
 
 export default {
-    ...nodeDataChannel,
+    initLogger,
+    cleanup,
+    preload,
+    setSctpSettings,
+    RtcpReceivingSession,
+    Track,
+    Video,
+    Audio,
+    DataChannel,
+    PeerConnection,
+    WebSocket,
+    WebSocketServer,
     DataChannelStream,
 };
-
-export const DescriptionType = {
-    Unspec: 'unspec',
-    Offer: 'offer',
-    Answer: 'answer',
-    Pranswer: 'pranswer',
-    Rollback: 'rollback',
-};

package/lib/node-datachannel.js

@@ -0,0 +1,7 @@
+// createRequire is native in node version >= 12
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const nodeDataChannel = require('../build/Release/node_datachannel.node');
+
+export default nodeDataChannel;

package/lib/websocket-server.js

@@ -0,0 +1,34 @@
+import { EventEmitter } from 'events';
+import nodeDataChannel from './node-datachannel.js';
+
+export default class WebSocketServer extends EventEmitter {
+    #server;
+    #clients = [];
+
+    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);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-datachannel",
-    "version": "0.10.0",
+    "version": "0.11.0",
     "description": "libdatachannel node bindings",
     "type": "module",
     "types": "./lib/index.d.ts",
@@ -93,11 +93,11 @@
         "node-addon-api": "^7.0.0",
         "prebuild": "^12.0.0",
         "prettier": "^2.8.8",
-        "typescript": "^5.3.2",
-        "rollup": "^4.14.1"
+        "rollup": "^4.14.1",
+        "typescript": "^5.3.2"
     },
     "dependencies": {
         "node-domexception": "^2.0.1",
         "prebuild-install": "^7.0.1"
     }
-}
+}

package/polyfill/Events.js

@@ -15,10 +15,12 @@ export class RTCPeerConnectionIceEvent extends Event {
 export class RTCDataChannelEvent extends Event {
     #channel;
 
-    constructor(channel) {
-        super('datachannel');
+    constructor(type, eventInitDict) {
+        super(type);
 
-        this.#channel = channel;
+        if (type && !eventInitDict.channel) throw new TypeError('channel member is required');
+
+        this.#channel = eventInitDict?.channel;
     }
 
     get channel() {

package/polyfill/Exception.js

@@ -0,0 +1,23 @@
+export const InvalidStateError = (msg) => {
+    return new DOMException(msg, 'InvalidStateError');
+};
+
+export const InvalidAccessError = (msg) => {
+    return new DOMException(msg, 'InvalidAccessError');
+};
+
+export const NotFoundError = (msg) => {
+    return new DOMException(msg, 'NotFoundError');
+};
+
+export const OperationError = (msg) => {
+    return new DOMException(msg, 'OperationError');
+};
+
+export const TypeError = (msg) => {
+    return new DOMException(msg, 'TypeError');
+};
+
+export const SyntaxError = (msg) => {
+    return new DOMException(msg, 'SyntaxError');
+};

package/polyfill/README.md

@@ -1,10 +1,10 @@
 # WebRTC Polyfills
 
-> This part is ongoing work and is considered to be in beta phase.
+WebRTC polyfills to be used for libraries like `simple-peer`.
 
-> Any feedback and contributions are welcomed.
+# web-platform-tests
 
-WebRTC polyfills to be used for libraries like `simple-peer`.
+Please check actual situation [here](/test/wpt-tests/)
 
 ## Example Usage
 

package/polyfill/RTCDataChannel.js

@@ -1,4 +1,5 @@
-import DOMException from 'node-domexception';
+import 'node-domexception';
+import * as exceptions from './Exception.js';
 
 export default class _RTCDataChannel extends EventTarget {
     #dataChannel;
@@ -10,6 +11,8 @@ export default class _RTCDataChannel extends EventTarget {
     #negotiated;
     #ordered;
 
+    #closeRequested = false;
+
     onbufferedamountlow;
     onclose;
     onclosing;
@@ -32,12 +35,20 @@ export default 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) => {
@@ -54,7 +65,7 @@ export default class _RTCDataChannel extends EventTarget {
         });
 
         this.#dataChannel.onBufferedAmountLow(() => {
-            this.dispatchEvent(new Event('bufferedamountlow'));
+            this.dispatchEvent(new Event('bufferedamountlow', { channel: this }));
         });
 
         this.#dataChannel.onMessage((data) => {
@@ -62,7 +73,7 @@ export default 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
@@ -148,9 +159,8 @@ export default class _RTCDataChannel extends EventTarget {
 
     send(data) {
         if (this.#readyState !== 'open') {
-            throw new DOMException(
+            throw exceptions.InvalidStateError(
                 "Failed to execute 'send' on 'RTCDataChannel': RTCDataChannel.readyState is not 'open'",
-                'InvalidStateError',
             );
         }
 
@@ -167,9 +177,7 @@ export default class _RTCDataChannel extends EventTarget {
     }
 
     close() {
-        this.#readyState = 'closing';
-        this.dispatchEvent(new Event('closing'));
-
+        this.#closeRequested = true;
         this.#dataChannel.close();
     }
 }

package/polyfill/RTCPeerConnection.js

@@ -5,6 +5,7 @@ import RTCIceCandidate from './RTCIceCandidate.js';
 import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
 import RTCSctpTransport from './RTCSctpTransport.js';
 import 'node-domexception';
+import * as exceptions from './Exception.js';
 
 export default class _RTCPeerConnection extends EventTarget {
     static async generateCertificate() {
@@ -15,6 +16,7 @@ export default class _RTCPeerConnection extends EventTarget {
     #localOffer;
     #localAnswer;
     #dataChannels;
+    #dataChannelsClosed = 0;
     #config;
     #canTrickleIceCandidates;
     #sctp;
@@ -32,32 +34,98 @@ export default 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 exceptions.SyntaxError('IceServers urls cannot be empty');
+
+                // urls should match the regex "stun\:\w*|turn\:\w*|turns\:\w*"
+                if (
+                    config.iceServers[i].urls?.some(
+                        (url) => !/^(stun:[\w,\.,:]*|turn:[\w,\.,:]*|turns:[\w,\.,:]*)$/.test(url),
+                    )
+                )
+                    throw exceptions.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 exceptions.InvalidAccessError('IceServers username cannot be null');
+                    if (!config.iceServers[i].credential)
+                        throw exceptions.InvalidAccessError('IceServers username cannot be undefined');
+                }
+
+                // length of urls can not be 0
+                if (config.iceServers[i].urls?.length === 0)
+                    throw exceptions.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 exceptions.NotFoundError('Unknown error');
+            throw exceptions.SyntaxError(error.message);
+        }
 
         // forward peerConnection events
         this.#peerConnection.onStateChange(() => {
@@ -77,9 +145,9 @@ export default 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) => {
@@ -153,7 +221,11 @@ export default 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() {
@@ -193,14 +265,45 @@ export default 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');
         }
 
-        this.#remoteCandidates.push(
-            new RTCIceCandidate({ candidate: candidate.candidate, sdpMid: candidate.sdpMid || '0' }),
-        );
-        this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
+        // Reject if sdpMid format is not valid
+        // ??
+        if (candidate.sdpMid && candidate.sdpMid.length > 3) {
+            // console.log(candidate.sdpMid);
+            throw exceptions.OperationError('Invalid sdpMid format');
+        }
+
+        // We don't care about sdpMLineIndex, just for test
+        if (!candidate.sdpMid && candidate.sdpMLineIndex > 1) {
+            throw exceptions.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 exceptions.NotFoundError('Unknown error');
+
+            // Check error Message if contains specific message
+            if (error.message.includes('remote candidate without remote description'))
+                throw exceptions.InvalidStateError(error.message);
+            if (error.message.includes('Invalid candidate format')) throw exceptions.OperationError(error.message);
+
+            throw exceptions.NotFoundError(error.message);
+        }
     }
 
     addTrack(track, ...streams) {
@@ -215,6 +318,7 @@ export default class _RTCPeerConnection extends EventTarget {
         // close all channels before shutting down
         this.#dataChannels.forEach((channel) => {
             channel.close();
+            this.#dataChannelsClosed++;
         });
 
         this.#peerConnection.close();
@@ -232,6 +336,7 @@ export default class _RTCPeerConnection extends EventTarget {
         this.#dataChannels.add(dataChannel);
         dataChannel.addEventListener('close', () => {
             this.#dataChannels.delete(dataChannel);
+            this.#dataChannelsClosed++;
         });
 
         return dataChannel;
@@ -265,7 +370,7 @@ export default 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,
@@ -276,7 +381,7 @@ export default 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,
@@ -311,6 +416,15 @@ export default 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);
         });
     }
@@ -327,20 +441,13 @@ export default 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) {