node-datachannel 0.12.0 → 0.20.0-alpha.1

package/src/lib/types.ts

@@ -0,0 +1,126 @@
+export interface Channel {
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+
+export interface WebSocketServerConfiguration {
+    port?: number; // default 8080
+    enableTls?: boolean; // default = false;
+    certificatePemFile?: string;
+    keyPemFile?: string;
+    keyPemPass?: string;
+    bindAddress?: string;
+    connectionTimeout?: number; // milliseconds
+    maxMessageSize?: number;
+}
+
+// Enum in d.ts is tricky
+export type LogLevel = 'Verbose' | 'Debug' | 'Info' | 'Warning' | 'Error' | 'Fatal';
+
+// SCTP Settings
+export interface SctpSettings {
+    recvBufferSize?: number;
+    sendBufferSize?: number;
+    maxChunksOnQueue?: number;
+    initialCongestionWindow?: number;
+    congestionControlModule?: number;
+    delayedSackTime?: number;
+}
+
+// Proxy Server
+export type ProxyServerType = 'Socks5' | 'Http';
+export interface ProxyServer {
+    type: ProxyServerType;
+    ip: string;
+    port: number;
+    username?: string;
+    password?: string;
+}
+
+export const enum RelayType {
+    TurnUdp = 'TurnUdp',
+    TurnTcp = 'TurnTcp',
+    TurnTls = 'TurnTls',
+}
+
+export interface IceServer {
+    hostname: string;
+    port: number;
+    username?: string;
+    password?: string;
+    relayType?: RelayType;
+}
+
+export type TransportPolicy = 'all' | 'relay';
+
+export interface RtcConfig {
+    iceServers: (string | IceServer)[];
+    proxyServer?: ProxyServer;
+    bindAddress?: string;
+    enableIceTcp?: boolean;
+    enableIceUdpMux?: boolean;
+    disableAutoNegotiation?: boolean;
+    forceMediaTransport?: boolean;
+    portRangeBegin?: number;
+    portRangeEnd?: number;
+    maxMessageSize?: number;
+    mtu?: number;
+    iceTransportPolicy?: TransportPolicy;
+}
+
+// Lowercase to match the description type string from libdatachannel
+export enum DescriptionType {
+    Unspec = 'unspec',
+    Offer = 'offer',
+    Answer = 'answer',
+    Pranswer = 'pranswer',
+    Rollback = 'rollback',
+}
+
+export type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';
+
+export type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
+export type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
+export type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
+export type RTCIceGathererState = "complete" | "gathering" | "new";
+export type RTCIceGatheringState = "complete" | "gathering" | "new";
+export type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
+
+
+export interface DataChannelInitConfig {
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    unordered?: boolean; // Reliability
+    maxPacketLifeTime?: number; // Reliability
+    maxRetransmits?: number; // Reliability
+}
+
+export interface SelectedCandidateInfo {
+    address: string;
+    port: number;
+    type: string;
+    transportType: string;
+    candidate: string;
+    mid: string;
+    priority: number;
+}
+
+// Must be same as rtc enum class Direction
+export const enum Direction {
+    SendOnly = 'SendOnly',
+    RecvOnly = 'RecvOnly',
+    SendRecv = 'SendRecv',
+    Inactive = 'Inactive',
+    Unknown = 'Unknown',
+}

package/{lib/websocket-server.js → src/lib/websocket-server.ts}

@@ -1,11 +1,13 @@
 import { EventEmitter } from 'events';
-import nodeDataChannel from './node-datachannel.js';
+import nodeDataChannel from './node-datachannel';
+import { WebSocketServerConfiguration } from './types';
+import { WebSocket } from './websocket';
 
-export default class WebSocketServer extends EventEmitter {
-    #server;
-    #clients = [];
+export class WebSocketServer extends EventEmitter {
+    #server: any;
+    #clients: WebSocket[] = [];
 
-    constructor(options) {
+    constructor(options: WebSocketServerConfiguration) {
         super();
         this.#server = new nodeDataChannel.WebSocketServer(options);
 
@@ -15,11 +17,11 @@ export default class WebSocketServer extends EventEmitter {
         });
     }
 
-    port() {
+    port(): number {
         return this.#server?.port() || 0;
     }
 
-    stop() {
+    stop(): void {
         this.#clients.forEach((client) => {
             client?.close();
         });
@@ -28,7 +30,7 @@ export default class WebSocketServer extends EventEmitter {
         this.removeAllListeners();
     }
 
-    onClient(cb) {
+    onClient(cb: (clientSocket: WebSocket) => void): void {
         if (this.#server) this.on('client', cb);
     }
 }

package/src/lib/websocket.ts

@@ -0,0 +1,26 @@
+import nodeDataChannel from './node-datachannel';
+import { Channel, WebSocketServerConfiguration } from './types';
+
+export interface WebSocket extends Channel {
+    open(url: string): void;
+    forceClose(): void;
+    remoteAddress(): string | undefined;
+    path(): string | undefined;
+
+    // Channel implementation
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+export const WebSocket: {
+    new(config?: WebSocketServerConfiguration): WebSocket
+} = nodeDataChannel.WebSocket

package/src/polyfill/Events.ts

@@ -0,0 +1,33 @@
+import RTCDataChannel from './RTCDataChannel';
+import RTCIceCandidate from './RTCIceCandidate';
+
+
+export class RTCPeerConnectionIceEvent extends Event implements globalThis.RTCPeerConnectionIceEvent {
+    #candidate: RTCIceCandidate;
+
+    constructor(candidate: RTCIceCandidate) {
+        super('icecandidate');
+
+        this.#candidate = candidate;
+    }
+
+    get candidate(): RTCIceCandidate {
+        return this.#candidate;
+    }
+}
+
+export class RTCDataChannelEvent extends Event implements globalThis.RTCDataChannelEvent {
+    #channel: RTCDataChannel;
+
+    constructor(type: string, eventInitDict: globalThis.RTCDataChannelEventInit) {
+        super(type);
+
+        if (type && !eventInitDict.channel) throw new TypeError('channel member is required');
+
+        this.#channel = eventInitDict?.channel as RTCDataChannel;
+    }
+
+    get channel(): RTCDataChannel {
+        return this.#channel;
+    }
+}

package/src/polyfill/Exception.ts

@@ -0,0 +1,37 @@
+/// <reference lib="dom" />
+
+export class InvalidStateError extends DOMException {
+    constructor(msg: string) {
+        super(msg, 'InvalidStateError');
+    }
+};
+
+export class TypeError extends DOMException {
+    constructor(msg: string) {
+        super(msg, 'TypeError');
+    }
+};
+
+export class OperationError extends DOMException {
+    constructor(msg: string) {
+        super(msg, 'OperationError');
+    }
+};
+
+export class NotFoundError extends DOMException {
+    constructor(msg: string) {
+        super(msg, 'NotFoundError');
+    }
+};
+
+export class InvalidAccessError extends DOMException {
+    constructor(msg: string) {
+        super(msg, 'InvalidAccessError');
+    }
+};
+
+export class SyntaxError extends DOMException {
+    constructor(msg: string) {
+        super(msg, 'SyntaxError');
+    }
+};

package/src/polyfill/RTCCertificate.ts

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

package/{polyfill/RTCDataChannel.js → src/polyfill/RTCDataChannel.ts}

@@ -1,26 +1,29 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import 'node-domexception';
-import * as exceptions from './Exception.js';
-
-export default class _RTCDataChannel extends EventTarget {
-    #dataChannel;
-    #readyState;
-    #bufferedAmountLowThreshold;
-    #binaryType;
-    #maxPacketLifeTime;
-    #maxRetransmits;
-    #negotiated;
-    #ordered;
+import * as exceptions from './Exception';
+import { DataChannel } from '../lib/index';
+
+export default class RTCDataChannel extends EventTarget implements globalThis.RTCDataChannel {
+    #dataChannel: DataChannel;
+    #readyState: RTCDataChannelState;
+    #bufferedAmountLowThreshold: number;
+    #binaryType: BinaryType;
+    #maxPacketLifeTime: number | null;
+    #maxRetransmits: number | null;
+    #negotiated: boolean;
+    #ordered: boolean;
 
     #closeRequested = false;
 
-    onbufferedamountlow;
-    onclose;
-    onclosing;
-    onerror;
-    onmessage;
-    onopen;
+    // 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;
 
-    constructor(dataChannel, opts = {}) {
+    constructor(dataChannel: DataChannel, opts: globalThis.RTCDataChannelInit = {}) {
         super();
 
         this.#dataChannel = dataChannel;
@@ -35,25 +38,25 @@ export default class _RTCDataChannel extends EventTarget {
         // forward dataChannel events
         this.#dataChannel.onOpen(() => {
             this.#readyState = 'open';
-            this.dispatchEvent(new Event('open', { channel: this }));
+            this.dispatchEvent(new Event('open', {}));
         });
 
         this.#dataChannel.onClosed(() => {
             // Simulate closing event
             if (!this.#closeRequested) {
                 this.#readyState = 'closing';
-                this.dispatchEvent(new Event('closing', { channel: this }));
+                this.dispatchEvent(new Event('closing'));
             }
 
             setImmediate(() => {
                 this.#readyState = 'closed';
-                this.dispatchEvent(new Event('close', { channel: this }));
+                this.dispatchEvent(new Event('close'));
             });
         });
 
         this.#dataChannel.onError((msg) => {
             this.dispatchEvent(
-                new RTCErrorEvent('error', {
+                new globalThis.RTCErrorEvent('error', {
                     error: new RTCError(
                         {
                             errorDetail: 'data-channel-failure',
@@ -65,20 +68,20 @@ export default class _RTCDataChannel extends EventTarget {
         });
 
         this.#dataChannel.onBufferedAmountLow(() => {
-            this.dispatchEvent(new Event('bufferedamountlow', { channel: this }));
+            this.dispatchEvent(new Event('bufferedamountlow'));
         });
 
         this.#dataChannel.onMessage((data) => {
             if (ArrayBuffer.isView(data)) {
-                data = data.buffer;
+                data = Buffer.from(data.buffer);
             }
 
-            this.dispatchEvent(new MessageEvent('message', { data, channel: this }));
+            this.dispatchEvent(new MessageEvent('message', { data }));
         });
 
         // forward events to properties
         this.addEventListener('message', (e) => {
-            if (this.onmessage) this.onmessage(e);
+            if (this.onmessage) this.onmessage(e as MessageEvent);
         });
         this.addEventListener('bufferedamountlow', (e) => {
             if (this.onbufferedamountlow) this.onbufferedamountlow(e);
@@ -107,15 +110,15 @@ export default class _RTCDataChannel extends EventTarget {
         this.#binaryType = type;
     }
 
-    get binaryType() {
+    get binaryType(): BinaryType {
         return this.#binaryType;
     }
 
-    get bufferedAmount() {
+    get bufferedAmount(): number {
         return this.#dataChannel.bufferedAmount();
     }
 
-    get bufferedAmountLowThreshold() {
+    get bufferedAmountLowThreshold(): number {
         return this.#bufferedAmountLowThreshold;
     }
 
@@ -125,41 +128,41 @@ export default class _RTCDataChannel extends EventTarget {
         this.#dataChannel.setBufferedAmountLowThreshold(number);
     }
 
-    get id() {
+    get id(): number | null {
         return this.#dataChannel.getId();
     }
 
-    get label() {
+    get label(): string {
         return this.#dataChannel.getLabel();
     }
 
-    get maxPacketLifeTime() {
+    get maxPacketLifeTime(): number | null {
         return this.#maxPacketLifeTime;
     }
 
-    get maxRetransmits() {
+    get maxRetransmits(): number | null {
         return this.#maxRetransmits;
     }
 
-    get negotiated() {
+    get negotiated(): boolean {
         return this.#negotiated;
     }
 
-    get ordered() {
+    get ordered(): boolean {
         return this.#ordered;
     }
 
-    get protocol() {
+    get protocol(): string {
         return this.#dataChannel.getProtocol();
     }
 
-    get readyState() {
+    get readyState(): globalThis.RTCDataChannelState {
         return this.#readyState;
     }
 
-    send(data) {
+    send(data): void {
         if (this.#readyState !== 'open') {
-            throw exceptions.InvalidStateError(
+            throw new exceptions.InvalidStateError(
                 "Failed to execute 'send' on 'RTCDataChannel': RTCDataChannel.readyState is not 'open'",
             );
         }
@@ -176,7 +179,7 @@ export default class _RTCDataChannel extends EventTarget {
         }
     }
 
-    close() {
+    close(): void {
         this.#closeRequested = true;
         this.#dataChannel.close();
     }

package/src/polyfill/RTCDtlsTransport.ts

@@ -0,0 +1,47 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import RTCIceTransport from './RTCIceTransport';
+import RTCPeerConnection from './RTCPeerConnection';
+
+export default class RTCDtlsTransport extends EventTarget implements globalThis.RTCDtlsTransport {
+    #pc: RTCPeerConnection = null;
+    #iceTransport = null;
+
+    onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null = null;
+    onerror: ((this: RTCDtlsTransport, ev: Event) => any) | null = null;
+
+    constructor(init: { pc: RTCPeerConnection, extraFunctions }) {
+        super();
+        this.#pc = init.pc;
+
+        this.#iceTransport = new RTCIceTransport({ pc: init.pc, extraFunctions: init.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(): RTCIceTransport {
+        return this.#iceTransport;
+    }
+
+    get state(): RTCDtlsTransportState {
+        // 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 = 'closed';
+        }
+        return state;
+    }
+
+    getRemoteCertificates(): ArrayBuffer[] {
+        // TODO: implement
+        return [new ArrayBuffer(0)];
+    }
+}

package/src/polyfill/RTCError.ts

@@ -0,0 +1,71 @@
+export default class RTCError extends DOMException implements globalThis.RTCError {
+    #errorDetail: RTCErrorDetailType;
+    #receivedAlert: number | null;
+    #sctpCauseCode: number | null;
+    #sdpLineNumber: number | null;
+    #sentAlert: number | null;
+
+    constructor(init: globalThis.RTCErrorInit, message?: string) {
+        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(): globalThis.RTCErrorDetailType {
+        return this.#errorDetail;
+    }
+
+    set errorDetail(_value) {
+        throw new TypeError('Cannot set errorDetail, it is read-only');
+    }
+
+    get receivedAlert(): number | null {
+        return this.#receivedAlert;
+    }
+
+    set receivedAlert(_value) {
+        throw new TypeError('Cannot set receivedAlert, it is read-only');
+    }
+
+    get sctpCauseCode(): number | null {
+        return this.#sctpCauseCode;
+    }
+
+    set sctpCauseCode(_value) {
+        throw new TypeError('Cannot set sctpCauseCode, it is read-only');
+    }
+
+    get sdpLineNumber(): number | null {
+        return this.#sdpLineNumber;
+    }
+
+    set sdpLineNumber(_value) {
+        throw new TypeError('Cannot set sdpLineNumber, it is read-only');
+    }
+
+    get sentAlert(): number | null {
+        return this.#sentAlert;
+    }
+
+    set sentAlert(_value) {
+        throw new TypeError('Cannot set sentAlert, it is read-only');
+    }
+}