node-datachannel 0.27.0 → 0.29.0

package/src/polyfill/RTCDataChannel.ts

@@ -1,200 +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;
-
-    #closeRequested = false;
-
-    // events
-    onbufferedamountlow: ((this: globalThis.RTCDataChannel, ev: Event) => any) | null;
-    onclose: ((this: globalThis.RTCDataChannel, ev: Event) => any) | null;
-    onclosing: ((this: globalThis.RTCDataChannel, ev: Event) => any) | null;
-    onerror: ((this: globalThis.RTCDataChannel, ev: Event) => any) | null;
-    onmessage: ((this: globalThis.RTCDataChannel, ev: MessageEvent) => any) | null;
-    onopen: ((this: globalThis.RTCDataChannel, ev: Event) => any) | null;
-
-    constructor(dataChannel: DataChannel, opts: globalThis.RTCDataChannelInit = {}) {
-        super();
-
-        this.#dataChannel = dataChannel;
-        this.#binaryType = 'blob';
-        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(() => {
-            // 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 globalThis.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)) {
-                if (this.binaryType == 'arraybuffer')
-                    data = data.buffer;
-                else
-                    data = Buffer.from(data.buffer);
-            }
-
-            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);
-        });
-        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',
-            );
+  #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);
         }
-        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.#dataChannel.getId();
-    }
-
-    get label(): string {
-        return this.#dataChannel.getLabel();
-    }
-
-    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.#dataChannel.getProtocol();
-    }
-
-    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);
+      }
+
+      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 {
-            if (process?.versions?.bun) {
-                this.#dataChannel.sendMessageBinary(Buffer.from(data));
-            } else {
-                this.#dataChannel.sendMessageBinary(new Uint8Array(data));
-            }
+          this.#dataChannel.sendMessageBinary(new Uint8Array(ab));
         }
-    }
-
-    close(): void {
-        this.#closeRequested = true;
-        setImmediate(() => {
-            this.#dataChannel.close();
-        });
-    }
+      });
+    } 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

@@ -1,46 +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: globalThis.RTCPeerConnection = null;
-    #iceTransport = null;
-
-    onstatechange: ((this: globalThis.RTCDtlsTransport, ev: Event) => any) | null = null;
-    onerror: ((this: globalThis.RTCDtlsTransport, ev: Event) => any) | null = null;
-
-    constructor(init: { pc: globalThis.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);
-        });
+  #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;
+  }
 
-    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)];
-    }
+  getRemoteCertificates(): ArrayBuffer[] {
+    // TODO: implement
+    return [new ArrayBuffer(0)];
+  }
 }

package/src/polyfill/RTCError.ts

@@ -1,71 +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;
+  #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');
+  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');
+    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.#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;
-    }
+  get errorDetail(): globalThis.RTCErrorDetailType {
+    return this.#errorDetail;
+  }
 
-    set errorDetail(_value) {
-        throw new TypeError('Cannot set errorDetail, it is read-only');
-    }
+  set errorDetail(_value) {
+    throw new TypeError('Cannot set errorDetail, it is read-only');
+  }
 
-    get receivedAlert(): number | null {
-        return this.#receivedAlert;
-    }
+  get receivedAlert(): number | null {
+    return this.#receivedAlert;
+  }
 
-    set receivedAlert(_value) {
-        throw new TypeError('Cannot set receivedAlert, it is read-only');
-    }
+  set receivedAlert(_value) {
+    throw new TypeError('Cannot set receivedAlert, it is read-only');
+  }
 
-    get sctpCauseCode(): number | null {
-        return this.#sctpCauseCode;
-    }
+  get sctpCauseCode(): number | null {
+    return this.#sctpCauseCode;
+  }
 
-    set sctpCauseCode(_value) {
-        throw new TypeError('Cannot set sctpCauseCode, it is read-only');
-    }
+  set sctpCauseCode(_value) {
+    throw new TypeError('Cannot set sctpCauseCode, it is read-only');
+  }
 
-    get sdpLineNumber(): number | null {
-        return this.#sdpLineNumber;
-    }
+  get httpRequestStatusCode(): number | null {
+    return this.#httpRequestStatusCode;
+  }
 
-    set sdpLineNumber(_value) {
-        throw new TypeError('Cannot set sdpLineNumber, it is read-only');
-    }
+  get sdpLineNumber(): number | null {
+    return this.#sdpLineNumber;
+  }
 
-    get sentAlert(): number | null {
-        return this.#sentAlert;
-    }
+  set sdpLineNumber(_value) {
+    throw new TypeError('Cannot set sdpLineNumber, it is read-only');
+  }
 
-    set sentAlert(_value) {
-        throw new TypeError('Cannot set sentAlert, it is read-only');
-    }
+  get sentAlert(): number | null {
+    return this.#sentAlert;
+  }
+
+  set sentAlert(_value) {
+    throw new TypeError('Cannot set sentAlert, it is read-only');
+  }
 }