feat: accept preconfigured PeerConnection as polyfill arg

There are cases where we need to use methods on `PeerConnection` that
are not available on `RTCPeerConnection`, but then we wish to pass
the `RTCPeerConnection` on to other code for it to use in a polmorphic
node/browser way.

Add an option to the polyfilled `RTCPeerConnection` to pass a
preconfigured `PeerConnection` instance in, instead of always creating
one.

Author: achingbrain

polyfill/RTCPeerConnection.d.ts

@@ -1,7 +1,13 @@
 /// <reference lib="dom" />
 
+import { PeerConnection } from '../lib/index.js';
+
+export interface _RTCConfiguration extends RTCConfiguration {
+    peerConnection?: PeerConnection;
+}
+
 export default class _RTCPeerConnection extends EventTarget implements RTCPeerConnection {
-    constructor(config?: RTCConfiguration);
+    constructor(config?: _RTCConfiguration);
 
     // events
     onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;

polyfill/RTCPeerConnection.js

@@ -41,23 +41,25 @@ export default class _RTCPeerConnection extends EventTarget {
         this.#dataChannels = new Set();
         this.#canTrickleIceCandidates = null;
 
-        this.#peerConnection = new NodeDataChannel.PeerConnection(init?.peerIdentity ?? `peer-${getRandomString(7)}`, {
-            ...init,
-            iceServers:
-                init?.iceServers
-                    ?.map((server) => {
-                        const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
-
-                        return urls.map((url) => {
-                            if (server.username && server.credential) {
-                                const [protocol, rest] = url.split(/:(.*)/);
-                                return `${protocol}:${server.username}:${server.credential}@${rest}`;
-                            }
-                            return url;
-                        });
-                    })
-                    .flat() ?? [],
-        });
+        this.#peerConnection =
+            init.peerConnection ??
+            new NodeDataChannel.PeerConnection(init?.peerIdentity ?? `peer-${getRandomString(7)}`, {
+                ...init,
+                iceServers:
+                    init?.iceServers
+                        ?.map((server) => {
+                            const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
+
+                            return urls.map((url) => {
+                                if (server.username && server.credential) {
+                                    const [protocol, rest] = url.split(/:(.*)/);
+                                    return `${protocol}:${server.username}:${server.credential}@${rest}`;
+                                }
+                                return url;
+                            });
+                        })
+                        .flat() ?? [],
+            });
 
         // forward peerConnection events
         this.#peerConnection.onStateChange(() => {

test/jest-tests/polyfill.test.js

@@ -1,10 +1,33 @@
-import { expect } from '@jest/globals';
+import { expect, jest } from '@jest/globals';
 import polyfill from '../../polyfill/index.js';
+import { PeerConnection } from '../../lib';
 
 describe('polyfill', () => {
     test('generateCertificate should throw', () => {
         expect(async () => {
             await polyfill.RTCPeerConnection.generateCertificate({});
         }).rejects.toEqual(new DOMException('Not implemented'));
     });
+
+    test('it should accept a preconfigured PeerConnection', () => {
+        const peerConnection = new PeerConnection('Peer', {
+            iceServers: [],
+        });
+
+        // have to override write-only method in order to spy on it
+        const originalFunc = peerConnection.state.bind(peerConnection);
+        Object.defineProperty(peerConnection, 'state', {
+            value: originalFunc,
+            writable: true,
+            enumerable: true,
+        });
+
+        const spy = jest.spyOn(peerConnection, 'state');
+        const rtcPeerConnection = new polyfill.RTCPeerConnection({
+            peerConnection,
+        });
+        const connectionState = rtcPeerConnection.connectionState;
+        expect(spy).toHaveBeenCalled();
+        expect(connectionState).toEqual(originalFunc());
+    });
 });