node-datachannel 0.4.3 → 0.5.0

package/polyfill/README.md

@@ -0,0 +1,41 @@
+# WebRTC Polyfills
+
+> This part is ongoing work and is considered to be in beta phase.
+
+> Any feedback and contributions are welcomed.
+
+WebRTC polyfills to be used for libraries like `simple-peer`.
+
+## Example Usage
+
+> For a native usage example please check test folder.
+
+`simple-peer` usage example
+
+```js
+import Peer from 'simple-peer';
+import nodeDatachannelPolyfill from 'node-datachannel/polyfill';
+
+var peer1 = new Peer({ initiator: true, wrtc: nodeDatachannelPolyfill });
+var peer2 = new Peer({ wrtc: nodeDatachannelPolyfill });
+
+peer1.on('signal', (data) => {
+    // when peer1 has signaling data, give it to peer2 somehow
+    peer2.signal(data);
+});
+
+peer2.on('signal', (data) => {
+    // when peer2 has signaling data, give it to peer1 somehow
+    peer1.signal(data);
+});
+
+peer1.on('connect', () => {
+    // wait for 'connect' event before using the data channel
+    peer1.send('hey peer2, how is it going?');
+});
+
+peer2.on('data', (data) => {
+    // got a data channel message
+    console.log('got a message from peer1: ' + data);
+});
+```

package/polyfill/RTCCertificate.d.ts

@@ -0,0 +1,7 @@
+/// <reference lib="dom" />
+
+export default class RTCCertificate implements RTCCertificate {
+    constructor();
+    readonly expires: number;
+    getFingerprints(): RTCDtlsFingerprint[];
+}

package/polyfill/RTCCertificate.js

@@ -0,0 +1,17 @@
+export default class RTCCertificate {
+    #expires;
+    #fingerprints;
+
+    constructor() {
+        this.#expires = null;
+        this.#fingerprints = [];
+    }
+
+    get expires() {
+        return this.#expires;
+    }
+
+    getFingerprints() {
+        return this.#fingerprints;
+    }
+}

package/polyfill/RTCDataChannel.d.ts

@@ -0,0 +1,35 @@
+/// <reference lib="dom" />
+
+import NodeDataChannel from '../lib';
+
+export default class _RTCDataChannel extends EventTarget implements RTCDataChannel {
+    constructor(dataChannel: NodeDataChannel.DataChannel, opts: RTCDataChannelInit);
+
+    // events
+    onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onclosing: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
+    onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
+    onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
+
+    // props
+    binaryType: BinaryType;
+    bufferedAmountLowThreshold: number;
+    readonly bufferedAmount: number;
+    readonly id: number | null;
+    readonly label: string;
+    readonly maxPacketLifeTime: number | null;
+    readonly maxRetransmits: number | null;
+    readonly negotiated: boolean;
+    readonly ordered: boolean;
+    readonly protocol: string;
+    readonly readyState: RTCDataChannelState;
+
+    // methods
+    close(): void;
+    send(data: string): void;
+    send(data: ArrayBuffer): void;
+    send(data: ArrayBufferView): void;
+    send(data: Blob): void;
+}

package/polyfill/RTCDataChannel.js

@@ -0,0 +1,175 @@
+import DOMException from 'node-domexception';
+
+export default class _RTCDataChannel extends EventTarget {
+    #dataChannel;
+    #readyState;
+    #bufferedAmountLowThreshold;
+    #binaryType;
+    #maxPacketLifeTime;
+    #maxRetransmits;
+    #negotiated;
+    #ordered;
+
+    onbufferedamountlow;
+    onclose;
+    onclosing;
+    onerror;
+    onmessage;
+    onopen;
+
+    constructor(dataChannel, opts = {}) {
+        super();
+
+        this.#dataChannel = dataChannel;
+        this.#binaryType = 'arraybuffer';
+        this.#readyState = this.#dataChannel.isOpen() ? 'open' : 'connecting';
+        this.#bufferedAmountLowThreshold = 0;
+        this.#maxPacketLifeTime = opts.maxPacketLifeTime || null;
+        this.#maxRetransmits = opts.maxRetransmits || null;
+        this.#negotiated = opts.negotiated || false;
+        this.#ordered = opts.ordered || true;
+
+        // forward dataChannel events
+        this.#dataChannel.onOpen(() => {
+            this.#readyState = 'open';
+            this.dispatchEvent(new Event('open'));
+        });
+
+        this.#dataChannel.onClosed(() => {
+            this.#readyState = 'closed';
+            this.dispatchEvent(new Event('close'));
+        });
+
+        this.#dataChannel.onError((msg) => {
+            this.dispatchEvent(
+                new RTCErrorEvent('error', {
+                    error: new RTCError(
+                        {
+                            errorDetail: 'data-channel-failure',
+                        },
+                        msg,
+                    ),
+                }),
+            );
+        });
+
+        this.#dataChannel.onBufferedAmountLow(() => {
+            this.dispatchEvent(new Event('bufferedamountlow'));
+        });
+
+        this.#dataChannel.onMessage((data) => {
+            if (ArrayBuffer.isView(data)) {
+                data = data.buffer;
+            }
+
+            this.dispatchEvent(new MessageEvent('message', { data }));
+        });
+
+        // forward events to properties
+        this.addEventListener('message', (e) => {
+            if (this.onmessage) this.onmessage(e);
+        });
+        this.addEventListener('bufferedamountlow', (e) => {
+            if (this.onbufferedamountlow) this.onbufferedamountlow(e);
+        });
+        this.addEventListener('error', (e) => {
+            if (this.onerror) this.onerror(e);
+        });
+        this.addEventListener('close', (e) => {
+            if (this.onclose) this.onclose(e);
+        });
+        this.addEventListener('closing', (e) => {
+            if (this.onclosing) this.onclosing(e);
+        });
+        this.addEventListener('open', (e) => {
+            if (this.onopen) this.onopen(e);
+        });
+    }
+
+    set binaryType(type) {
+        if (type !== 'blob' && type !== 'arraybuffer') {
+            throw new DOMException(
+                "Failed to set the 'binaryType' property on 'RTCDataChannel': Unknown binary type : " + type,
+                'TypeMismatchError',
+            );
+        }
+        this.#binaryType = type;
+    }
+
+    get binaryType() {
+        return this.#binaryType;
+    }
+
+    get bufferedAmount() {
+        return this.#dataChannel.bufferedAmount();
+    }
+
+    get bufferedAmountLowThreshold() {
+        return this.#bufferedAmountLowThreshold;
+    }
+
+    set bufferedAmountLowThreshold(value) {
+        const number = Number(value) || 0;
+        this.#bufferedAmountLowThreshold = number;
+        this.#dataChannel.setBufferedAmountLowThreshold(number);
+    }
+
+    get id() {
+        return this.#dataChannel.getId();
+    }
+
+    get label() {
+        return this.#dataChannel.getLabel();
+    }
+
+    get maxPacketLifeTime() {
+        return this.#maxPacketLifeTime;
+    }
+
+    get maxRetransmits() {
+        return this.#maxRetransmits;
+    }
+
+    get negotiated() {
+        return this.#negotiated;
+    }
+
+    get ordered() {
+        return this.#ordered;
+    }
+
+    get protocol() {
+        return this.#dataChannel.getProtocol();
+    }
+
+    get readyState() {
+        return this.#readyState;
+    }
+
+    send(data) {
+        if (this.#readyState !== 'open') {
+            throw new DOMException(
+                "Failed to execute 'send' on 'RTCDataChannel': RTCDataChannel.readyState is not 'open'",
+                'InvalidStateError',
+            );
+        }
+
+        // Needs network error, type error implemented
+        if (typeof data === 'string') {
+            this.#dataChannel.sendMessage(data);
+        } else if (data instanceof Blob) {
+            data.arrayBuffer().then((ab) => {
+                this.#dataChannel.sendMessageBinary(new Uint8Array(ab));
+            });
+        } else {
+            this.#dataChannel.sendMessageBinary(new Uint8Array(data));
+        }
+    }
+
+    close() {
+        this.#readyState = 'closing';
+        this.dispatchEvent(new Event('closing'));
+
+        this.#dataChannel.close();
+    }
+}

package/polyfill/RTCDtlsTransport.d.ts

@@ -0,0 +1,10 @@
+/// <reference lib="dom" />
+
+export default class _RTCDtlsTransport extends EventTarget implements RTCDtlsTransport {
+    readonly iceTransport: RTCIceTransport;
+    readonly state: RTCDtlsTransportState;
+    getRemoteCertificates(): ArrayBuffer[];
+
+    onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
+    onerror: ((this: RTCDtlsTransport, ev: Event) => any) | null;
+}

package/polyfill/RTCDtlsTransport.js

@@ -0,0 +1,47 @@
+import RTCIceTransport from './RTCIceTransport.js';
+
+export default class _RTCDtlsTransport extends EventTarget {
+    #pc = null;
+    #extraFunctions = null;
+    #iceTransport = null;
+
+    onerror = null;
+    onstatechange = null;
+
+    constructor({ pc, extraFunctions }) {
+        super();
+        this.#pc = pc;
+        this.#extraFunctions = extraFunctions;
+
+        this.#iceTransport = new RTCIceTransport({ pc, extraFunctions });
+
+        // forward peerConnection events
+        this.#pc.addEventListener('connectionstatechange', () => {
+            this.dispatchEvent(new Event('statechange'));
+        });
+
+        // forward events to properties
+        this.addEventListener('statechange', (e) => {
+            if (this.onstatechange) this.onstatechange(e);
+        });
+    }
+
+    get iceTransport() {
+        return this.#iceTransport;
+    }
+
+    get state() {
+        // reduce state from new, connecting, connected, disconnected, failed, closed, unknown
+        // to RTCDtlsTRansport states new, connecting, connected, closed, failed
+        let state = this.#pc ? this.#pc.connectionState : 'new';
+        if (state === 'disconnected' || state === 'unknown') {
+            state = 'closed';
+        }
+        return state;
+    }
+
+    getRemoteCertificates() {
+        // TODO: implement
+        return new ArrayBuffer(0);
+    }
+}

package/polyfill/RTCIceCandidate.d.ts

@@ -0,0 +1,20 @@
+/// <reference lib="dom" />
+
+export default class _RTCIceCandidate implements RTCIceCandidate {
+    constructor(init: RTCIceCandidateInit);
+    readonly address: string | null;
+    readonly candidate: string;
+    readonly component: RTCIceComponent | null;
+    readonly foundation: string | null;
+    readonly port: number | null;
+    readonly priority: number | null;
+    readonly protocol: RTCIceProtocol | null;
+    readonly relatedAddress: string | null;
+    readonly relatedPort: number | null;
+    readonly sdpMLineIndex: number | null;
+    readonly sdpMid: string | null;
+    readonly tcpType: RTCIceTcpCandidateType | null;
+    readonly type: RTCIceCandidateType | null;
+    readonly usernameFragment: string | null;
+    toJSON(): RTCIceCandidateInit;
+}

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] == '1' ? 'rtp' : 'rtcp';
+            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,82 @@
+import RTCIceCandidate from './RTCIceCandidate.js';
+
+export default class _RTCIceTransport extends EventTarget {
+    #pc = null;
+    #extraFunctions = null;
+
+    ongatheringstatechange = null;
+    onselectedcandidatepairchange = null;
+    onstatechange = null;
+
+    constructor({ pc, extraFunctions }) {
+        super();
+        this.#pc = pc;
+        this.#extraFunctions = extraFunctions;
+
+        // forward peerConnection events
+        this.#pc.addEventListener('icegatheringstatechange', () => {
+            this.dispatchEvent(new Event('gatheringstatechange'));
+        });
+        this.#pc.addEventListener('iceconnectionstatechange', () => {
+            console.log('*********');
+            this.dispatchEvent(new Event('statechange'));
+        });
+
+        // forward events to properties
+        this.addEventListener('gatheringstatechange', (e) => {
+            if (this.ongatheringstatechange) this.ongatheringstatechange(e);
+        });
+        this.addEventListener('statechange', (e) => {
+            if (this.onstatechange) this.onstatechange(e);
+        });
+    }
+
+    get component() {
+        let cp = this.getSelectedCandidatePair();
+        if (!cp) return null;
+        return cp.local.component;
+    }
+
+    get gatheringState() {
+        return this.#pc ? this.#pc.iceGatheringState : 'new';
+    }
+
+    get role() {
+        return this.#pc.localDescription.type == 'offer' ? 'controlling' : 'controlled';
+    }
+
+    get state() {
+        return this.#pc ? this.#pc.iceConnectionState : 'new';
+    }
+
+    getLocalCandidates() {
+        return this.#pc ? this.#extraFunctions.localCandidates() : [];
+    }
+
+    getLocalParameters() {
+        /** */
+    }
+
+    getRemoteCandidates() {
+        return this.#pc ? this.#extraFunctions.remoteCandidates() : [];
+    }
+
+    getRemoteParameters() {
+        /** */
+    }
+
+    getSelectedCandidatePair() {
+        let cp = this.#extraFunctions.selectedCandidatePair();
+        if (!cp) return null;
+        return {
+            local: new RTCIceCandidate({
+                candidate: cp.local.candidate,
+                sdpMid: cp.local.mid,
+            }),
+            remote: new RTCIceCandidate({
+                candidate: cp.remote.candidate,
+                sdpMid: cp.remote.mid,
+            }),
+        };
+    }
+}

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>;
+}