node-datachannel 0.4.3 → 0.5.0-dev

package/polyfill/RTCIceCandidate.js

@@ -0,0 +1,126 @@
+// https://developer.mozilla.org/docs/Web/API/RTCIceCandidate
+//
+// Example: candidate:123456 1 UDP 123456 192.168.1.1 12345 typ host raddr=10.0.0.1 rport=54321 generation 0
+
+import DOMException from 'node-domexception';
+
+export default class _RTCIceCandidate {
+    #address;
+    #candidate;
+    #component;
+    #foundation;
+    #port;
+    #priority;
+    #protocol;
+    #relatedAddress;
+    #relatedPort;
+    #sdpMLineIndex;
+    #sdpMid;
+    #tcpType;
+    #type;
+    #usernameFragment;
+    #ip;
+
+    constructor({ candidate, sdpMLineIndex, sdpMid, usernameFragment }) {
+        if (candidate == null) {
+            throw new DOMException('candidate must be specified');
+        }
+
+        this.#candidate = candidate;
+        this.#sdpMLineIndex = sdpMLineIndex || null;
+        this.#sdpMid = sdpMid || null;
+        this.#usernameFragment = usernameFragment || null;
+
+        if (candidate) {
+            const fields = candidate.split(' ');
+            this.#foundation = fields[0];
+            this.#component = fields[1];
+            this.#protocol = fields[2];
+            this.#priority = parseInt(fields[3], 10);
+            this.#ip = 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];
+            }
+
+            // Parse the candidate string to extract relatedPort and relatedAddress
+            for (let i = 9; 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);
+                }
+            }
+        }
+    }
+
+    get address() {
+        return this.#address || null;
+    }
+
+    get candidate() {
+        return this.#candidate || '';
+    }
+
+    get component() {
+        return this.#component;
+    }
+
+    get foundation() {
+        return this.#foundation || null;
+    }
+
+    get port() {
+        return this.#port || null;
+    }
+
+    get priority() {
+        return this.#priority || null;
+    }
+
+    get protocol() {
+        return this.#protocol || null;
+    }
+
+    get relatedAddress() {
+        return this.#relatedAddress;
+    }
+
+    get relatedPort() {
+        return this.#relatedPort || null;
+    }
+
+    get sdpMLineIndex() {
+        return this.#sdpMLineIndex;
+    }
+
+    get sdpMid() {
+        return this.#sdpMid;
+    }
+
+    get tcpType() {
+        return this.#tcpType;
+    }
+
+    get type() {
+        return this.#type || null;
+    }
+
+    get usernameFragment() {
+        return this.#usernameFragment;
+    }
+
+    toJSON() {
+        return {
+            candidate: this.#candidate,
+            sdpMLineIndex: this.#sdpMLineIndex,
+            sdpMid: this.#sdpMid,
+            usernameFragment: this.#usernameFragment,
+        };
+    }
+}

package/polyfill/RTCIceTransport.d.ts

@@ -0,0 +1,18 @@
+/// <reference lib="dom" />
+
+export default class _RTCIceTransport extends EventTarget implements RTCIceTransport {
+    readonly component: RTCIceComponent;
+    readonly gatheringState: RTCIceGatheringState;
+    readonly role: string; // RTCIceRole;
+    readonly state: RTCIceTransportState;
+
+    getLocalCandidates(): RTCIceCandidate[];
+    getLocalParameters(): any; // RTCIceParameters;
+    getRemoteCandidates(): RTCIceCandidate[];
+    getRemoteParameters(): any; // RTCIceParameters;
+    getSelectedCandidatePair(): RTCIceCandidatePair | null;
+
+    ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
+    onselectedcandidatepairchange: ((this: RTCIceTransport, ev: Event) => any) | null;
+    onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
+}

package/polyfill/RTCIceTransport.js

@@ -0,0 +1,55 @@
+export default class _RTCIceTransport extends EventTarget {
+    #component = null;
+    #gatheringState = null;
+    #role = null;
+    #state = null;
+
+    ongatheringstatechange = createEmptyFunction();
+    onselectedcandidatepairchange = createEmptyFunction();
+    onstatechange = createEmptyFunction();
+
+    constructor() {
+        super();
+    }
+
+    get component() {
+        return this.#component;
+    }
+
+    get gatheringState() {
+        return this.#gatheringState;
+    }
+
+    get role() {
+        return this.#role;
+    }
+
+    get state() {
+        return this.#state;
+    }
+    getLocalCandidates() {
+        /** */
+    }
+
+    getLocalParameters() {
+        /** */
+    }
+
+    getRemoteCandidates() {
+        /** */
+    }
+
+    getRemoteParameters() {
+        /** */
+    }
+
+    getSelectedCandidatePair() {
+        /** */
+    }
+}
+
+function createEmptyFunction() {
+    return () => {
+        /** */
+    };
+}

package/polyfill/RTCPeerConnection.d.ts

@@ -0,0 +1,50 @@
+/// <reference lib="dom" />
+
+export default class _RTCPeerConnection extends EventTarget implements RTCPeerConnection {
+    constructor(config?: RTCConfiguration);
+
+    // events
+    onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
+    onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
+    onicecandidateerror: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+    ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
+
+    // props
+    readonly canTrickleIceCandidates: boolean | null;
+    readonly connectionState: RTCPeerConnectionState;
+    readonly iceConnectionState: RTCIceConnectionState;
+    readonly iceGatheringState: RTCIceGatheringState;
+    readonly currentLocalDescription: RTCSessionDescription | null;
+    readonly currentRemoteDescription: RTCSessionDescription | null;
+    readonly localDescription: RTCSessionDescription | null;
+    readonly pendingLocalDescription: RTCSessionDescription | null;
+    readonly pendingRemoteDescription: RTCSessionDescription | null;
+    readonly remoteDescription: RTCSessionDescription | null;
+    readonly sctp: RTCSctpTransport | null;
+    readonly signalingState: RTCSignalingState;
+
+    // methods
+    generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
+    addIceCandidate(candidate?: RTCIceCandidateInit | RTCIceCandidate): Promise<void>;
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
+    addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    close(): void;
+    createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit>;
+    createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
+    createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
+    getConfiguration(): RTCConfiguration;
+    getReceivers(): RTCRtpReceiver[];
+    getSenders(): RTCRtpSender[];
+    getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
+    getTransceivers(): RTCRtpTransceiver[];
+    removeTrack(sender: RTCRtpSender): void;
+    restartIce(): Promise<void>;
+    setConfiguration(configuration: RTCConfiguration): void;
+    setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+}

package/polyfill/RTCPeerConnection.js

@@ -0,0 +1,348 @@
+import NodeDataChannel from '../lib/index.js';
+import RTCSessionDescription from './RTCSessionDescription.js';
+import RTCDataChannel from './RTCDataChannel.js';
+import RTCIceCandidate from './RTCIceCandidate.js';
+import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
+import DOMException from 'node-domexception';
+
+export default class _RTCPeerConnection extends EventTarget {
+    #peerConnection;
+    #localOffer;
+    #localAnswer;
+    #dataChannels;
+    #config;
+    #canTrickleIceCandidates;
+    #sctp;
+
+    onconnectionstatechange;
+    ondatachannel;
+    onicecandidate;
+    onicecandidateerror;
+    oniceconnectionstatechange;
+    onicegatheringstatechange;
+    onnegotiationneeded;
+    onsignalingstatechange;
+    ontrack;
+
+    constructor(init = {}) {
+        super();
+
+        this.#config = init;
+        this.#localOffer = createDeferredPromise();
+        this.#localAnswer = createDeferredPromise();
+        this.#dataChannels = new Set();
+        this.#canTrickleIceCandidates = null;
+        this.#sctp = null;
+
+        const iceServers = init ? init.iceServers : [];
+
+        this.#peerConnection = new NodeDataChannel.PeerConnection(
+            init && init.peerIdentity ? init.peerIdentity : `peer-${getRandomString(7)}`,
+            {
+                iceServers: 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(),
+                iceTransportPolicy: init ? init.iceTransportPolicy : undefined,
+            },
+        );
+
+        // forward peerConnection events
+        this.#peerConnection.onStateChange(() => {
+            this.dispatchEvent(new Event('connectionstatechange'));
+        });
+
+        this.#peerConnection.onIceStateChange(() => {
+            this.dispatchEvent(new Event('iceconnectionstatechange'));
+        });
+
+        this.#peerConnection.onSignalingStateChange(() => {
+            this.dispatchEvent(new Event('signalingstatechange'));
+        });
+
+        this.#peerConnection.onGatheringStateChange(() => {
+            this.dispatchEvent(new Event('icegatheringstatechange'));
+        });
+
+        this.#peerConnection.onDataChannel((channel) => {
+            const dataChannel = new RTCDataChannel(channel);
+            this.#dataChannels.add(dataChannel);
+            this.dispatchEvent(new RTCDataChannelEvent(dataChannel));
+        });
+
+        this.#peerConnection.onLocalDescription((sdp, type) => {
+            if (type === 'offer') {
+                this.#localOffer.resolve({ sdp, type });
+            }
+
+            if (type === 'answer') {
+                this.#localAnswer.resolve({ sdp, type });
+            }
+        });
+
+        this.#peerConnection.onLocalCandidate((candidate, sdpMid) => {
+            if (sdpMid === 'unspec') {
+                this.#localAnswer.reject(new Error(`Invalid description type ${sdpMid}`));
+                return;
+            }
+
+            this.dispatchEvent(new RTCPeerConnectionIceEvent(new RTCIceCandidate({ candidate, sdpMid })));
+        });
+
+        // forward events to properties
+        this.addEventListener('connectionstatechange', (e) => {
+            if (this.onconnectionstatechange) this.onconnectionstatechange(e);
+        });
+        this.addEventListener('signalingstatechange', (e) => {
+            if (this.onsignalingstatechange) this.onsignalingstatechange(e);
+        });
+        this.addEventListener('iceconnectionstatechange', (e) => {
+            if (this.oniceconnectionstatechange) this.oniceconnectionstatechange(e);
+        });
+        this.addEventListener('icegatheringstatechange', (e) => {
+            if (this.onicegatheringstatechange) this.onicegatheringstatechange(e);
+        });
+        this.addEventListener('datachannel', (e) => {
+            if (this.ondatachannel) this.ondatachannel(e);
+        });
+        this.addEventListener('icecandidate', (e) => {
+            if (this.onicecandidate) this.onicecandidate(e);
+        });
+    }
+
+    get canTrickleIceCandidates() {
+        return this.#canTrickleIceCandidates;
+    }
+
+    get connectionState() {
+        return this.#peerConnection.state();
+    }
+
+    get iceConnectionState() {
+        return this.#peerConnection.iceState();
+    }
+
+    get iceGatheringState() {
+        return this.#peerConnection.gatheringState();
+    }
+
+    get currentLocalDescription() {
+        return new RTCSessionDescription(this.#peerConnection.localDescription());
+    }
+
+    get currentRemoteDescription() {
+        return new RTCSessionDescription(this.#peerConnection.remoteDescription());
+    }
+
+    get localDescription() {
+        return new RTCSessionDescription(this.#peerConnection.localDescription());
+    }
+
+    get pendingLocalDescription() {
+        return new RTCSessionDescription(this.#peerConnection.localDescription());
+    }
+
+    get pendingRemoteDescription() {
+        return new RTCSessionDescription(this.#peerConnection.remoteDescription());
+    }
+
+    get remoteDescription() {
+        return new RTCSessionDescription(this.#peerConnection.remoteDescription());
+    }
+
+    get sctp() {
+        return this.#sctp;
+    }
+
+    get signalingState() {
+        return this.#peerConnection.signalingState();
+    }
+
+    static generateCertificate(keygenAlgorithm) {
+        throw new DOMException('Not implemented');
+    }
+
+    async addIceCandidate(candidate) {
+        if (candidate == null || candidate.candidate == null) {
+            throw new DOMException('Candidate invalid');
+        }
+
+        this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid || '0');
+    }
+
+    addTrack(track, ...streams) {
+        throw new DOMException('Not implemented');
+    }
+
+    addTransceiver(trackOrKind, init) {
+        throw new DOMException('Not implemented');
+    }
+
+    close() {
+        // close all channels before shutting down
+        this.#dataChannels.forEach((channel) => {
+            channel.close();
+        });
+
+        this.#peerConnection.close();
+    }
+
+    createAnswer() {
+        return this.#localAnswer;
+    }
+
+    createDataChannel(label, opts = {}) {
+        const channel = this.#peerConnection.createDataChannel(label, opts);
+        const dataChannel = new RTCDataChannel(channel, opts);
+
+        // ensure we can close all channels when shutting down
+        this.#dataChannels.add(dataChannel);
+        dataChannel.addEventListener('close', () => {
+            this.#dataChannels.delete(dataChannel);
+        });
+
+        return dataChannel;
+    }
+
+    createOffer() {
+        return this.#localOffer;
+    }
+
+    getConfiguration() {
+        return this.#config;
+    }
+
+    getReceivers() {
+        throw new DOMException('Not implemented');
+    }
+
+    getSenders() {
+        throw new DOMException('Not implemented');
+    }
+
+    getStats() {
+        return new Promise((resolve) => {
+            let report = new Map();
+            let cp = this.#peerConnection.getSelectedCandidatePair();
+            let bytesSent = this.#peerConnection.bytesSent();
+            let bytesReceived = this.#peerConnection.bytesReceived();
+            let rtt = this.#peerConnection.rtt();
+
+            let localIdRs = getRandomString(8);
+            let localId = 'RTCIceCandidate_' + localIdRs;
+            report.set(localId, {
+                id: localId,
+                type: 'localcandidate',
+                timestamp: Date.now(),
+                candidateType: cp.local.type,
+                ip: cp.local.address,
+                port: cp.local.port,
+            });
+
+            let remoteIdRs = getRandomString(8);
+            let remoteId = 'RTCIceCandidate_' + remoteIdRs;
+            report.set(remoteId, {
+                id: remoteId,
+                type: 'remotecandidate',
+                timestamp: Date.now(),
+                candidateType: cp.remote.type,
+                ip: cp.remote.address,
+                port: cp.remote.port,
+            });
+
+            let candidateId = 'RTCIceCandidatePair_' + localIdRs + '_' + remoteIdRs;
+            report.set(candidateId, {
+                id: candidateId,
+                type: 'candidate-pair',
+                timestamp: Date.now(),
+                localCandidateId: localId,
+                remoteCandidateId: remoteId,
+                state: 'succeeded',
+                nominated: true,
+                writable: true,
+                bytesSent: bytesSent,
+                bytesReceived: bytesReceived,
+                totalRoundTripTime: rtt,
+                currentRoundTripTime: rtt,
+            });
+
+            let transportId = 'RTCTransport_0_1';
+            report.set(transportId, {
+                id: transportId,
+                timestamp: Date.now(),
+                type: 'transport',
+                bytesSent: bytesSent,
+                bytesReceived: bytesReceived,
+                dtlsState: 'connected',
+                selectedCandidatePairId: candidateId,
+                selectedCandidatePairChanges: 1,
+            });
+
+            return resolve(report);
+        });
+    }
+
+    getTransceivers() {
+        return []; // throw new DOMException('Not implemented');
+    }
+
+    removeTrack() {
+        throw new DOMException('Not implemented');
+    }
+
+    restartIce() {
+        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') {
+            // any other type causes libdatachannel to throw
+            return;
+        }
+        this.#peerConnection.setLocalDescription(description.type);
+    }
+
+    async setRemoteDescription(description) {
+        if (description.sdp == null) {
+            throw new DOMException('Remote SDP must be set');
+        }
+
+        this.#peerConnection.setRemoteDescription(description.sdp, description.type);
+    }
+}
+
+function createDeferredPromise() {
+    let resolve, reject;
+
+    let promise = new Promise(function (_resolve, _reject) {
+        resolve = _resolve;
+        reject = _reject;
+    });
+
+    promise.resolve = resolve;
+    promise.reject = reject;
+    return promise;
+}
+
+function getRandomString(length) {
+    return Math.random()
+        .toString(36)
+        .substring(2, 2 + length);
+}

package/polyfill/RTCSctpTransport.d.ts

@@ -0,0 +1,10 @@
+/// <reference lib="dom" />
+
+export default class _RTCSctpTransport extends EventTarget implements RTCSctpTransport {
+    readonly maxChannels: number | null;
+    readonly maxMessageSize: number;
+    readonly transport: RTCDtlsTransport;
+    readonly state: RTCSctpTransportState;
+
+    onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
+}

package/polyfill/RTCSctpTransport.js

@@ -0,0 +1,34 @@
+export default class _RTCSctpTransport extends EventTarget {
+    #maxChannels = null;
+    #maxMessageSize = null;
+    #state = null;
+    #transport = null;
+
+    onstatechange = createEmptyFunction();
+
+    constructor(init = {}) {
+        super();
+    }
+
+    get maxChannels() {
+        return this.#maxChannels;
+    }
+
+    get maxMessageSize() {
+        return this.#maxMessageSize;
+    }
+
+    get state() {
+        return this.#state;
+    }
+
+    get transport() {
+        return this.#transport;
+    }
+}
+
+function createEmptyFunction() {
+    return () => {
+        /** */
+    };
+}

package/polyfill/RTCSessionDescription.d.ts

@@ -0,0 +1,7 @@
+/// <reference lib="dom" />
+
+export default class _RTCSessionDescription implements RTCSessionDescription {
+    readonly sdp: string;
+    readonly type: RTCSdpType;
+    toJSON(): any;
+}

package/polyfill/RTCSessionDescription.js

@@ -0,0 +1,37 @@
+// https://developer.mozilla.org/docs/Web/API/RTCSessionDescription
+//
+// Example usage
+// const init = {
+//     type: 'offer',
+//     sdp: 'v=0\r\no=- 1234567890 1234567890 IN IP4 192.168.1.1\r\ns=-\r\nt=0 0\r\na=ice-ufrag:abcd\r\na=ice-pwd:efgh\r\n'
+//   };
+
+export default class _RTCSessionDescription {
+    #type;
+    #sdp;
+
+    constructor(init = {}) {
+        // Allow Empty Constructor
+        // if (!init || !init.type || !init.sdp) {
+        //     throw new DOMException('Type and sdp properties are required.');
+        // }
+
+        this.#type = init ? init.type : null;
+        this.#sdp = init ? init.sdp : null;
+    }
+
+    get type() {
+        return this.#type;
+    }
+
+    get sdp() {
+        return this.#sdp;
+    }
+
+    toJSON() {
+        return {
+            sdp: this.#sdp,
+            type: this.#type,
+        };
+    }
+}