node-datachannel 0.26.0 → 0.28.0

package/src/polyfill/Events.ts

@@ -1,33 +1,79 @@
 import RTCDataChannel from './RTCDataChannel';
-import RTCIceCandidate from './RTCIceCandidate';
-
+import RTCError from './RTCError';
 
 export class RTCPeerConnectionIceEvent extends Event implements globalThis.RTCPeerConnectionIceEvent {
-    #candidate: RTCIceCandidate;
+  #candidate: globalThis.RTCIceCandidate;
+
+  constructor(candidate: globalThis.RTCIceCandidate) {
+    super('icecandidate');
 
-    constructor(candidate: RTCIceCandidate) {
-        super('icecandidate');
+    this.#candidate = candidate;
+  }
 
-        this.#candidate = candidate;
-    }
+  get candidate(): globalThis.RTCIceCandidate {
+    return this.#candidate;
+  }
 
-    get candidate(): RTCIceCandidate {
-        return this.#candidate;
-    }
+  get url(): string {
+    return '';
+  }
 }
 
 export class RTCDataChannelEvent extends Event implements globalThis.RTCDataChannelEvent {
-    #channel: RTCDataChannel;
+  #channel: RTCDataChannel;
+
+  constructor(type: string = 'datachannel', eventInitDict: globalThis.RTCDataChannelEventInit) {
+    super(type);
 
-    constructor(type: string, 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'.",
+      );
 
-        if (type && !eventInitDict.channel) throw new TypeError('channel member is required');
+    this.#channel = eventInitDict?.channel;
+  }
+
+  get channel(): RTCDataChannel {
+    return this.#channel;
+  }
+}
 
-        this.#channel = eventInitDict?.channel as RTCDataChannel;
-    }
+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 channel(): RTCDataChannel {
-        return this.#channel;
-    }
+  get error(): RTCError {
+    return this.#error;
+  }
 }

package/src/polyfill/Exception.ts

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

package/src/polyfill/README.md

@@ -20,22 +20,22 @@ 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);
+  // 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);
+  // 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?');
+  // 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);
+  // got a data channel message
+  console.log('got a message from peer1: ' + data);
 });
 ```

package/src/polyfill/RTCCertificate.ts

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

package/src/polyfill/RTCDataChannel.ts

@@ -1,200 +1,206 @@
 /* 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: RTCDataChannelState;
-    #bufferedAmountLowThreshold: number;
-    #binaryType: BinaryType;
-    #maxPacketLifeTime: number | null;
-    #maxRetransmits: number | null;
-    #negotiated: boolean;
-    #ordered: boolean;
-
-    #closeRequested = false;
-
-    // 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: 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',
-            );
-        }
-        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);
+  #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 = '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;
+    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((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 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();
+    });
+  }
 }