@lng2004/node-datachannel 0.31.0-20251228

package/src/polyfill/Events.ts

@@ -0,0 +1,82 @@
+import RTCDataChannel from './RTCDataChannel';
+import RTCError from './RTCError';
+
+export class RTCPeerConnectionIceEvent
+  extends Event
+  implements globalThis.RTCPeerConnectionIceEvent
+{
+  #candidate: globalThis.RTCIceCandidate;
+
+  constructor(candidate: globalThis.RTCIceCandidate) {
+    super('icecandidate');
+
+    this.#candidate = candidate;
+  }
+
+  get candidate(): globalThis.RTCIceCandidate {
+    return this.#candidate;
+  }
+
+  get url(): string {
+    return '';
+  }
+}
+
+export class RTCDataChannelEvent extends Event implements globalThis.RTCDataChannelEvent {
+  #channel: RTCDataChannel;
+
+  constructor(type: string = 'datachannel', eventInitDict: globalThis.RTCDataChannelEventInit) {
+    super(type);
+
+    if (arguments.length === 0)
+      throw new TypeError(
+        `Failed to construct 'RTCDataChannelEvent': 2 arguments required, but only ${arguments.length} present.`,
+      );
+    if (typeof eventInitDict !== 'object')
+      throw new TypeError(
+        "Failed to construct 'RTCDataChannelEvent': The provided value is not of type 'RTCDataChannelEventInit'.",
+      );
+    if (!eventInitDict.channel)
+      throw new TypeError(
+        "Failed to construct 'RTCDataChannelEvent': Failed to read the 'channel' property from 'RTCDataChannelEventInit': Required member is undefined.",
+      );
+    if (eventInitDict.channel.constructor !== RTCDataChannel)
+      throw new TypeError(
+        "Failed to construct 'RTCDataChannelEvent': Failed to read the 'channel' property from 'RTCDataChannelEventInit': Failed to convert value to 'RTCDataChannel'.",
+      );
+
+    this.#channel = eventInitDict?.channel;
+  }
+
+  get channel(): RTCDataChannel {
+    return this.#channel;
+  }
+}
+
+export class RTCErrorEvent extends Event implements globalThis.RTCErrorEvent {
+  #error: RTCError;
+  constructor(type: string, init: globalThis.RTCErrorEventInit) {
+    if (arguments.length < 2)
+      throw new TypeError(
+        `Failed to construct 'RTCErrorEvent': 2 arguments required, but only ${arguments.length} present.`,
+      );
+    if (typeof init !== 'object')
+      throw new TypeError(
+        "Failed to construct 'RTCErrorEvent': The provided value is not of type 'RTCErrorEventInit'.",
+      );
+    if (!init.error)
+      throw new TypeError(
+        "Failed to construct 'RTCErrorEvent': Failed to read the 'error' property from 'RTCErrorEventInit': Required member is undefined.",
+      );
+    if (init.error.constructor !== RTCError)
+      throw new TypeError(
+        "Failed to construct 'RTCErrorEvent': Failed to read the 'error' property from 'RTCErrorEventInit': Failed to convert value to 'RTCError'.",
+      );
+    super(type || 'error');
+    this.#error = init.error;
+  }
+
+  get error(): RTCError {
+    return this.#error;
+  }
+}

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/README.md

@@ -0,0 +1,41 @@
+# WebRTC Polyfills
+
+WebRTC polyfills to be used for libraries like `simple-peer`.
+
+# web-platform-tests
+
+Please check actual situation [here](/test/wpt-tests/)
+
+## 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/src/polyfill/RTCCertificate.ts

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

package/src/polyfill/RTCDataChannel.ts

@@ -0,0 +1,225 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as exceptions from './Exception';
+import { DataChannel } from '../lib/index';
+import { RTCErrorEvent } from './Events';
+
+export default class RTCDataChannel extends EventTarget implements globalThis.RTCDataChannel {
+  #dataChannel: DataChannel;
+  #readyState: globalThis.RTCDataChannelState;
+  #bufferedAmountLowThreshold: number;
+  #binaryType: BinaryType;
+  #maxPacketLifeTime: number | null;
+  #maxRetransmits: number | null;
+  #negotiated: boolean;
+  #ordered: boolean;
+  #id: number;
+  #label: string;
+  #protocol: string;
+
+  #closeRequested = false;
+
+  // events
+  onbufferedamountlow: globalThis.RTCDataChannel['onbufferedamountlow'] = null;
+  onclose: globalThis.RTCDataChannel['onclose'] = null;
+  onclosing: globalThis.RTCDataChannel['onclosing'] = null;
+  onerror: globalThis.RTCDataChannel['onerror'] = null;
+  onmessage: globalThis.RTCDataChannel['onmessage'] = null;
+  onopen: globalThis.RTCDataChannel['onopen'] = null;
+
+  constructor(dataChannel: DataChannel, opts: globalThis.RTCDataChannelInit = {}) {
+    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;
+    this.#id = this.#dataChannel.getId();
+    this.#label = this.#dataChannel.getLabel();
+    this.#protocol = this.#dataChannel.getProtocol();
+
+    // forward dataChannel events
+    this.#dataChannel.onOpen(() => {
+      this.#readyState = 'open';
+      this.dispatchEvent(new Event('open', {}));
+    });
+
+    this.#dataChannel.onClosed(() => {
+      // Simulate closing event
+      if (!this.#closeRequested) {
+        this.#readyState = 'closing';
+        this.dispatchEvent(new Event('closing'));
+      }
+
+      setImmediate(() => {
+        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((message) => {
+      if (typeof message === 'string') {
+        this.dispatchEvent(new MessageEvent('message', { data: message }));
+        return;
+      }
+
+      let data: Blob | ArrayBuffer;
+
+      if (message instanceof ArrayBuffer) {
+        data = message;
+      } else {
+        data = message.buffer;
+
+        if (message.byteOffset !== 0 || message.byteLength !== message.buffer.byteLength) {
+          // message is view on underlying buffer, must create new
+          // ArrayBuffer that only contains message data
+          data = new ArrayBuffer(message.byteLength);
+          new Uint8Array(data, 0, message.byteLength).set(message);
+        }
+      }
+
+      if (this.#binaryType === 'blob') {
+        data = new Blob([data]);
+      }
+
+      this.dispatchEvent(new MessageEvent('message', { data }));
+    });
+
+    // forward events to properties
+    this.addEventListener('message', (e) => {
+      if (this.onmessage) this.onmessage(e as MessageEvent);
+    });
+    this.addEventListener('bufferedamountlow', (e) => {
+      if (this.onbufferedamountlow) this.onbufferedamountlow(e);
+    });
+    this.addEventListener('error', (e) => {
+      if (this.onerror) this.onerror(e as RTCErrorEvent);
+    });
+    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(): BinaryType {
+    return this.#binaryType;
+  }
+
+  get bufferedAmount(): number {
+    return this.#dataChannel.bufferedAmount();
+  }
+
+  get bufferedAmountLowThreshold(): number {
+    return this.#bufferedAmountLowThreshold;
+  }
+
+  set bufferedAmountLowThreshold(value) {
+    const number = Number(value) || 0;
+    this.#bufferedAmountLowThreshold = number;
+    this.#dataChannel.setBufferedAmountLowThreshold(number);
+  }
+
+  get id(): number | null {
+    return this.#id;
+  }
+
+  get label(): string {
+    return this.#label;
+  }
+
+  get maxPacketLifeTime(): number | null {
+    return this.#maxPacketLifeTime;
+  }
+
+  get maxRetransmits(): number | null {
+    return this.#maxRetransmits;
+  }
+
+  get negotiated(): boolean {
+    return this.#negotiated;
+  }
+
+  get ordered(): boolean {
+    return this.#ordered;
+  }
+
+  get protocol(): string {
+    return this.#protocol;
+  }
+
+  get readyState(): globalThis.RTCDataChannelState {
+    return this.#readyState;
+  }
+
+  send(data): void {
+    if (this.#readyState !== 'open') {
+      throw new exceptions.InvalidStateError(
+        "Failed to execute 'send' on 'RTCDataChannel': RTCDataChannel.readyState is not 'open'",
+      );
+    }
+
+    // Needs network error, type error implemented
+    if (typeof data === 'string') {
+      this.#dataChannel.sendMessage(data);
+    } else if (data instanceof Blob) {
+      data.arrayBuffer().then((ab) => {
+        if (process?.versions?.bun) {
+          this.#dataChannel.sendMessageBinary(Buffer.from(ab));
+        } else {
+          this.#dataChannel.sendMessageBinary(new Uint8Array(ab));
+        }
+      });
+    } else if (data instanceof Uint8Array) {
+      this.#dataChannel.sendMessageBinary(data);
+    } else {
+      if (process?.versions?.bun) {
+        this.#dataChannel.sendMessageBinary(Buffer.from(data));
+      } else {
+        this.#dataChannel.sendMessageBinary(new Uint8Array(data));
+      }
+    }
+  }
+
+  close(): void {
+    this.#closeRequested = true;
+    setImmediate(() => {
+      this.#dataChannel.close();
+    });
+  }
+}

package/src/polyfill/RTCDtlsTransport.ts

@@ -0,0 +1,46 @@
+/* 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: globalThis.RTCDtlsTransport['onstatechange'] = null;
+  onerror: globalThis.RTCDtlsTransport['onstatechange'] = null;
+
+  constructor(init: { pc: RTCPeerConnection }) {
+    super();
+    this.#pc = init.pc;
+
+    this.#iceTransport = new RTCIceTransport({
+      pc: init.pc,
+    });
+
+    // forward peerConnection events
+    this.#pc.addEventListener('connectionstatechange', () => {
+      const e = new Event('statechange');
+      this.dispatchEvent(e);
+      this.onstatechange?.(e);
+    });
+  }
+
+  get iceTransport(): globalThis.RTCIceTransport {
+    return this.#iceTransport;
+  }
+
+  get state(): globalThis.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,78 @@
+export default class RTCError extends DOMException implements globalThis.RTCError {
+  #errorDetail: globalThis.RTCErrorDetailType;
+  #receivedAlert: number | null;
+  #sctpCauseCode: number | null;
+  #sdpLineNumber: number | null;
+  #sentAlert: number | null;
+  #httpRequestStatusCode: 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;
+    this.#httpRequestStatusCode = init.httpRequestStatusCode ?? 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 httpRequestStatusCode(): number | null {
+    return this.#httpRequestStatusCode;
+  }
+
+  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');
+  }
+}

package/src/polyfill/RTCIceCandidate.ts

@@ -0,0 +1,128 @@
+// 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
+
+export default class RTCIceCandidate implements globalThis.RTCIceCandidate {
+  #address: string | null;
+  #candidate: string;
+  #component: globalThis.RTCIceComponent | null;
+  #foundation: string | null;
+  #port: number | null;
+  #priority: number | null;
+  #protocol: globalThis.RTCIceProtocol | null;
+  #relatedAddress: string | null;
+  #relatedPort: number | null;
+  #sdpMLineIndex: number | null;
+  #sdpMid: string | null;
+  #tcpType: globalThis.RTCIceTcpCandidateType | null;
+  #type: globalThis.RTCIceCandidateType | null;
+  #usernameFragment: string | null;
+
+  constructor({
+    candidate,
+    sdpMLineIndex,
+    sdpMid,
+    usernameFragment,
+  }: globalThis.RTCIceCandidateInit) {
+    if (sdpMLineIndex == null && sdpMid == null)
+      throw new TypeError('At least one of sdpMLineIndex or sdpMid must be specified');
+
+    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]!.replace('candidate:', ''); // remove text candidate:
+      this.#component = fields[1] == '1' ? 'rtp' : 'rtcp';
+      this.#protocol = fields[2] as globalThis.RTCIceProtocol;
+      this.#priority = parseInt(fields[3], 10);
+      this.#address = fields[4];
+      this.#port = parseInt(fields[5], 10);
+      this.#type = fields[7] as globalThis.RTCIceCandidateType;
+      this.#tcpType = null;
+      this.#relatedAddress = null;
+      this.#relatedPort = null;
+
+      // Parse the candidate string to extract relatedPort and relatedAddress
+      for (let i = 8; i < fields.length; i++) {
+        const field = fields[i];
+        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] as globalThis.RTCIceTcpCandidateType;
+        }
+      }
+    }
+  }
+
+  get address(): string | null {
+    return this.#address ?? null;
+  }
+
+  get candidate(): string {
+    return this.#candidate;
+  }
+
+  get component(): globalThis.RTCIceComponent | null {
+    return this.#component;
+  }
+
+  get foundation(): string | null {
+    return this.#foundation ?? null;
+  }
+
+  get port(): number | null {
+    return this.#port ?? null;
+  }
+
+  get priority(): number | null {
+    return this.#priority ?? null;
+  }
+
+  get protocol(): globalThis.RTCIceProtocol | null {
+    return this.#protocol ?? null;
+  }
+
+  get relatedAddress(): string | null {
+    return this.#relatedAddress;
+  }
+
+  get relatedPort(): number | null {
+    return this.#relatedPort ?? null;
+  }
+
+  get sdpMLineIndex(): number | null {
+    return this.#sdpMLineIndex;
+  }
+
+  get sdpMid(): string | null {
+    return this.#sdpMid;
+  }
+
+  get tcpType(): globalThis.RTCIceTcpCandidateType | null {
+    return this.#tcpType;
+  }
+
+  get type(): globalThis.RTCIceCandidateType | null {
+    return this.#type ?? null;
+  }
+
+  get usernameFragment(): string | null {
+    return this.#usernameFragment;
+  }
+
+  toJSON(): globalThis.RTCIceCandidateInit {
+    return {
+      candidate: this.#candidate,
+      sdpMLineIndex: this.#sdpMLineIndex,
+      sdpMid: this.#sdpMid,
+      usernameFragment: this.#usernameFragment,
+    };
+  }
+}