node-datachannel 0.27.0 → 0.29.0

package/src/lib/websocket.ts

@@ -2,25 +2,25 @@ 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;
+  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;
+  // 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
+  new (config?: WebSocketServerConfiguration): WebSocket;
+} = nodeDataChannel.WebSocket;

package/src/polyfill/Events.ts

@@ -1,29 +1,82 @@
-export class RTCPeerConnectionIceEvent extends Event implements globalThis.RTCPeerConnectionIceEvent {
-    #candidate: globalThis.RTCIceCandidate;
+import RTCDataChannel from './RTCDataChannel';
+import RTCError from './RTCError';
 
-    constructor(candidate: globalThis.RTCIceCandidate) {
-        super('icecandidate');
+export class RTCPeerConnectionIceEvent
+  extends Event
+  implements globalThis.RTCPeerConnectionIceEvent
+{
+  #candidate: globalThis.RTCIceCandidate;
 
-        this.#candidate = candidate;
-    }
+  constructor(candidate: globalThis.RTCIceCandidate) {
+    super('icecandidate');
 
-    get candidate(): globalThis.RTCIceCandidate {
-        return this.#candidate;
-    }
+    this.#candidate = candidate;
+  }
+
+  get candidate(): globalThis.RTCIceCandidate {
+    return this.#candidate;
+  }
+
+  get url(): string {
+    return '';
+  }
 }
 
 export class RTCDataChannelEvent extends Event implements globalThis.RTCDataChannelEvent {
-    #channel: globalThis.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 globalThis.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(): globalThis.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 '';
+  }
 }