@yz-social/webrtc 0.0.1 → 0.0.3

package/index.js

@@ -1,3 +1,2 @@
+export { WebRTCBase } from './lib/webrtcbase.js';
 export { WebRTC } from './lib/webrtc.js';
-export { PromiseWebRTC } from './lib/promisewebrtc.js';
-export { TrickleWebRTC } from './lib/tricklewebrtc.js';

package/lib/webrtc.js

@@ -1,42 +1,56 @@
-import { WebRTCDataChannels } from './datachannels.js';
+import { WebRTCBase } from './webrtcbase.js';
 
-// Basics.
-export class WebRTC extends WebRTCDataChannels {
-  static connections = new Map();
-  static ensure({serviceLabel, multiplex = true, ...rest}) { // Answer the named connection, creating it if there isn't already a CONNECTED one by this name.
-    // The serviceLabel is used as the log label throughout.
-    // E.g., if a node has connections to many other nodes, but with multiple channels on each connection, then it is
-    // convenient to name the shared connection with the id of the other side.
-    //
-    // If running both ends in the same Javascript, be sure to give them different names!
+export class WebRTC extends WebRTCBase {
 
-    let connection = this.connections.get(serviceLabel);
-    // It is possible that we were backgrounded before we had a chance to act on a closing connection and remove it.
-    if (connection) {
-      const {connectionState, signalingState} = connection.peer;
-      if ((connectionState === 'new') || (connectionState === 'closed') || (signalingState === 'closed')) connection = null;
-    }
-    if (!connection) {
-      connection = new this({label: serviceLabel, multiplex, ...rest});
-      if (multiplex) this.connections.set(serviceLabel, connection);
-    }
-    return connection;
+  async respond(signals) { // When a peer sends an offer or ice, this can be used to respond.
+    this.signals = signals;
+    await this.signalsReady;
+    return this.signals;
+  }
+  async connectVia(responder) { // Resolves when connected to the peer signaled via responder.
+    // Use like this (see test suite):
+    // let promise = this.signalsReady;
+    // let dataChannelPromise = this.ensureDataChannel(channelName); // Or something else that triggers negotiation.
+    // const aSignals = await promise;
+    // await this.connectVia(somethingThatCreatesPeerAndExchangesSigansl)); // Typically through peer.respond(signals).
+    
+    const returning = await responder(this.signals); // this.signals might be an empty list.
+    if (!returning?.length) return;
+    this.signals = returning;
+    await this.connectVia(responder); // Keep "long-polling" the other side until it has nothing left to say.
+  }
+  
+  sending = [];
+  get signals() { // Answer the signals that have fired on this end since the last time this.signals was asked for.
+    let pending = this.sending;
+    this.sending = [];
+    return pending;
+  }
+  set signals(data) { // Set with the signals received from the other end.
+    data.forEach(([type, message]) => this[type](message));
   }
 
-  // Handlers for signal messages from the peer.
-  // Note that one peer will receive offer(), and the other will receive answer(). Both receive icecandidate.
-  offer(offer) { // Handler for receiving an offer from the other user (who started the signaling process).
-    // Note that during signaling, we will receive negotiationneeded/answer, or offer, but not both, depending
-    // on whether we were the one that started the signaling process.
-    this.peer.setRemoteDescription(offer)
-      .then(_ => this.peer.createAnswer())
-      .then(answer => this.peer.setLocalDescription(answer)) // promise does not resolve to answer
-      .then(_ => this.signal('answer', this.peer.localDescription));
+  signalResolvers = [];
+  resetAndResolveSignals() { // Any pending.
+    let resolvers = this.signalResolvers; // Reset and resolve all pending resolvers.
+    this.signalResolvers = [];
+    for (const resolve of resolvers) resolve(null);
+  }    
+  get signalsReady() { // Return a promise that resolves as soon as there any ready.
+    // Each time that a client calls get signalsReady, a new promise is generated.
+    if (this.sending.length) return Promise.resolve(null);
+    const { promise, resolve } = Promise.withResolvers();
+    this.signalResolvers.push(resolve);
+    return promise;
   }
-  answer(answer) { // Handler for finishing the signaling process that we started.
-    this.peer.setRemoteDescription(answer);
+
+  signal(type, message) { // Handle signals being generated on this side, by accumulating them for get signals
+    super.signal(type, message);
+    this.sending.push([type, message]);
+    this.resetAndResolveSignals();
   }
-  icecandidate(iceCandidate) { // Handler for a new candidate received from the other end through signaling.
-    this.peer.addIceCandidate(iceCandidate).catch(error => this.icecandidateError(error));
+  connectionStateChange(state) { // When we connect, resetAndResolveSignals.
+    super.connectionStateChange(state);
+    if ('connected' === state) this.resetAndResolveSignals();
   }
 }

package/lib/webrtcbase.js

@@ -0,0 +1,42 @@
+import { WebRTCDataChannels } from './datachannels.js';
+
+// Basics.
+export class WebRTCBase extends WebRTCDataChannels {
+  static connections = new Map();
+  static ensure({serviceLabel, multiplex = true, ...rest}) { // Answer the named connection, creating it if there isn't already a CONNECTED one by this name.
+    // The serviceLabel is used as the log label throughout.
+    // E.g., if a node has connections to many other nodes, but with multiple channels on each connection, then it is
+    // convenient to name the shared connection with the id of the other side.
+    //
+    // If running both ends in the same Javascript, be sure to give them different names!
+
+    let connection = this.connections.get(serviceLabel);
+    // It is possible that we were backgrounded before we had a chance to act on a closing connection and remove it.
+    if (connection) {
+      const {connectionState, signalingState} = connection.peer;
+      if ((connectionState === 'new') || (connectionState === 'closed') || (signalingState === 'closed')) connection = null;
+    }
+    if (!connection) {
+      connection = new this({label: serviceLabel, multiplex, ...rest});
+      if (multiplex) this.connections.set(serviceLabel, connection);
+    }
+    return connection;
+  }
+
+  // Handlers for signal messages from the peer.
+  // Note that one peer will receive offer(), and the other will receive answer(). Both receive icecandidate.
+  offer(offer) { // Handler for receiving an offer from the other user (who started the signaling process).
+    // Note that during signaling, we will receive negotiationneeded/answer, or offer, but not both, depending
+    // on whether we were the one that started the signaling process.
+    this.peer.setRemoteDescription(offer)
+      .then(_ => this.peer.createAnswer())
+      .then(answer => this.peer.setLocalDescription(answer)) // promise does not resolve to answer
+      .then(_ => this.signal('answer', this.peer.localDescription));
+  }
+  answer(answer) { // Handler for finishing the signaling process that we started.
+    this.peer.setRemoteDescription(answer);
+  }
+  icecandidate(iceCandidate) { // Handler for a new candidate received from the other end through signaling.
+    this.peer.addIceCandidate(iceCandidate).catch(error => this.icecandidateError(error));
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/webrtc",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Streamlined portable webrtc management of p2p and client2server.",
   "keywords": [
     "webrtc",
@@ -16,13 +16,14 @@
     }
   },
   "exports": {
-    ".": "./index.mjs",
-    "./router": "./lib/router.js"
+    ".": "./index.js",
+    "./router": "./routes/index.js"
   },
   "scripts": {
-    "test": "npx jasmine",
-    "testServer": "node testServer.js",
-    "stopServer": "pkill webrtcTestServer"
+    "test": "(npm run test-server &); npm run test-only; npm run stop-server",
+    "test-only": "npx jasmine",
+    "test-server": "node testServer.js",
+    "stop-server": "pkill webrtcTestServer"
   },
   "dependencies": {
     "@roamhq/wrtc": "^0.9.1"
@@ -33,7 +34,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kilroy-code/flexstore.git"
+    "url": "git+https://github.com/YZ-social/webrtc.git"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/routes/index.js

@@ -1,47 +1,19 @@
 import express from 'express';
-import { PromiseWebRTC, TrickleWebRTC } from '../index.js';
+import { WebRTC } from '../index.js';
 export const router = express.Router();
-
-const testConnections = {}; // Is it really necessary to keep these around, against garbage collection?
-router.post('/promise/echo/:tag', async (req, res, next) => { // Test endpoint for WebRTC.
-  // Client posts collected signal data to us.
-  // We create a WebRTC connection here with the given tag, and answer our response signals.
-  // We also create message handler on the channel that just sends back whatever comes over
-  // from the other side.
+ 
+ const testConnections = {}; // Is it really necessary to keep these around, against garbage collection?
+router.post('/data/echo/:tag', async (req, res, next) => { // Test endpoint for WebRTC.
   const {params, body} = req;
   const tag = params.tag;
-  const signals = body;
-  const connection = testConnections[tag] = new PromiseWebRTC({label: tag});
-  const timer = setTimeout(() => connection.close(), 15e3);
-  const dataPromise = connection.getDataChannelPromise('echo');
-  dataPromise.then(dataChannel => {
-    dataChannel.onclose = () => {
-      clearTimeout(timer);
-      connection.close();
-      delete testConnections[tag];
-    };
-    dataChannel.onmessage = event => dataChannel.send(event.data); // Just echo what we are given.
-  });
-  connection.signals = signals; // Convey the posted offer+ice signals to our connection.
-  res.send(await connection.signals); // Send back our signalling answer+ice.
-});
-router.post('/trickle/echo/:tag', async (req, res, next) => { // Test endpoint for WebRTC.
-  // Same as above, but using trickle ice. The server "peer" is created first and given
-  // the initial offer as above. But then the client reposts (long polling) to give
-  // ice candidates and the server waits until there are any to give back (or connection).
-  const {params, body} = req;
-  const tag = params.tag;
-  const incomingSignals = body;
+  let incomingSignals = body;
   let connection = testConnections[tag];
-  console.log('post connection:', !!connection, 'incoming:', incomingSignals.map(s => s[0]));
   if (!connection) {
-    connection = testConnections[tag] = TrickleWebRTC.ensure({serviceLabel: tag});
-    const timer = setTimeout(() => connection.close(), 15e3);
-    console.log('created connection and applying', incomingSignals.map(s => s[0]));
-    connection.next = connection.signals;
+    connection = testConnections[tag] = new WebRTC({label: tag});
+    const timer = setTimeout(() => connection.close(), 15e3); // Enough to complete test, then cleanup.
     const dataPromise = connection.dataChannelPromise = connection.ensureDataChannel('echo', {}, incomingSignals);
+    incomingSignals = [];
     dataPromise.then(dataChannel => {
-      connection.reportConnection(true);
       dataChannel.onclose = () => {
 	clearTimeout(timer);
 	connection.close();
@@ -49,13 +21,7 @@ router.post('/trickle/echo/:tag', async (req, res, next) => { // Test endpoint f
       };
       dataChannel.onmessage = event => dataChannel.send(event.data); // Just echo what we are given.
     });
-  } else {
-    console.log('applying incoming signals');
-    connection.signals = incomingSignals;
   }
-  console.log('awaiting response');
-  const responseSignals = await Promise.race([connection.next, connection.dataChannelPromise]);
-  connection.next = connection.signals;
-  console.log('responding', responseSignals.map(s => s[0]));
-  res.send(responseSignals); // Send back our signalling answer+ice.
+  res.send(await connection.respond(incomingSignals));
 });
+

package/spec/webrtcSpec.js

@@ -1,7 +1,7 @@
 const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach} = globalThis; // For linters.
-import { WebRTC, PromiseWebRTC, TrickleWebRTC } from '../index.js';
+import { WebRTC, WebRTCBase } from '../index.js';
 
-class DirectSignaling extends WebRTC {
+class DirectSignaling extends WebRTCBase {
   signal(type, message) { // Just invoke the method directly on the otherSide.
     this.otherSide[type](message);
   }
@@ -18,162 +18,26 @@ async function fetchSignals(url, signalsToSend) {
   });
   return await response.json();
 }
-function map(signals) { return signals?.map?.(s => s[0]); }
 
 describe("WebRTC", function () {
-  describe("connection to server", function () {
-    describe("using PromiseWebRTC", function () {
-      let connection, dataChannel;
-      beforeAll(async function () {
-	connection = PromiseWebRTC.ensure({serviceLabel: 'PromiseClient'});
-	const dataChannelPromise = connection.ensureDataChannel('echo');
-	connection.signals = await fetchSignals("http://localhost:3000/test/promise/echo/foo", await connection.signals);
-	dataChannel = await dataChannelPromise;
-	connection.reportConnection(true);
-      });
-      afterAll(function () {
-	connection.close();
-      });
-      it("sends and receives data", async function () {
-	const echoPromise = new Promise(resolve => dataChannel.onmessage = event => resolve(event.data));
-	dataChannel.send('hello');
-	expect(await echoPromise).toBe('hello');
-      });
-    });
-    describe("using trickle ICE", function () {
-      let connection, dataChannel;
-      beforeAll(async function () {
-	connection = TrickleWebRTC.ensure({serviceLabel: 'Client'});
-	const dataChannelPromise = connection.ensureDataChannel('echo');
-	await connection.signals;
-	async function exchange() {
-	  if (connection.peer.iceGatheringState !== 'gathering') return;
-	  const sending = connection.sending;
-	  connection.sending = [];
-
-	  console.log('client sending', map(sending));
-	  const returning = await fetchSignals("http://localhost:3000/test/trickle/echo/foo", sending);
-
-	  if (!returning?.length) return;
-	  //if (a.connection.peer.iceGatheringState !== 'gathering') return;
-	  console.log('client', 'received', map(returning), connection.peer.iceGatheringState);
-	  connection.signals = returning;
-	  exchange();
-	}
-	exchange();
 	
-	dataChannel = await dataChannelPromise;
-	connection.reportConnection(true);
-      });
-      afterAll(function () {
-	connection.close();
-      });
-      it("sends and receives data", async function () {
-	const echoPromise = new Promise(resolve => dataChannel.onmessage = event => resolve(event.data));
-	dataChannel.send('hello');
-	expect(await echoPromise).toBe('hello');
-      });
-    });    
-  });
-
-  describe('connection between two peers on the same computer', function () {
-    function test(Kind) {
+  describe("connection between two peers on the same computer", function () {
+    const channelName = 'test';
+    function test(Kind, connect) {
       describe(Kind.name, function () {
 	let a = {}, b = {};
-	const channelName = 'test';
-	const channelOptions = {};
 	beforeAll(async function () {
 	  const debug = false;
 	  a.connection = Kind.ensure({serviceLabel: 'A'+Kind.name, debug});
 	  b.connection = Kind.ensure({serviceLabel: 'B'+Kind.name, debug});
 
-	  // Required only for DirectSignaling signal(), above. Ignored for others.
-	  a.connection.otherSide = b.connection;
-	  b.connection.otherSide = a.connection;    
+	  await connect(a, b);
 
-	  let aPromise = a.connection.signals;
-	  a.dataChannelPromise = a.connection.ensureDataChannel(channelName, channelOptions);
-	  const aSignals = await aPromise;
-	  a.connection.sending = [];
-	  //console.log(Kind.name, 'aSignals:', map(aSignals));
-
-	  // The second peer on the initial negotiation must specify a non-empty signals --
-	  // either an empty list for trickle-ice, or a list of the actual signals from the PromiseWebRTC.
-
-	  b.next = b.connection.signals;
-	  // let bPromise = b.connection.signals;
-	  // aPromise = a.connection.signals;
-	  b.dataChannelPromise = b.connection.ensureDataChannel(channelName, channelOptions, aSignals);
-	  // const bSignals = await bPromise;
-	  // console.log(Kind.name, 'bSignals:', map(bSignals));
-
-	  // bPromise = b.connection.signals;
-	  // a.connection.signals = bSignals;
-
-	  async function exchange() {
-	    if (a.connection.peer.iceGatheringState !== 'gathering') return;
-	    const sending = a.connection.sending;
-	    a.connection.sending = [];
-
-	    console.log(Kind.name, 'sending', map(sending), b.connection.peer.iceGatheringState);
-	    b.connection.signals = sending;
-	    const returning = await Promise.race([b.next, b.dataChannelPromise]);
-	    b.next = b.connection.signals;
-
-	    if (!returning?.length) return;
-	    //if (a.connection.peer.iceGatheringState !== 'gathering') return;
-	    console.log(Kind.name, 'received', map(returning), a.connection.peer.iceGatheringState);
-	    a.connection.signals = returning;
-	    exchange();
-	  }
-	  exchange();
-
-	  // Only needed in the trickle ice case. Harmless otherwise.
-	  async function conveySignals(from, to, promise) {
-	    const state = from.peer.iceGatheringState;
-	    if (state !== 'gathering') {
-	      console.log(Kind.name, from.label, state, 'skipping');
-	      return;
-	    }
-	    console.log(Kind.name, from.label, state, from.peer.iceConnectionState, from.peer.connectionState, from.peer.signalingState, 'waiting');
-	    const signals = await Promise.race([promise,
-						from === a.connection ? a.dataChannelPromise : b.dataChannelPromise,
-					       ]); // 7     |      f
-	    console.log(Kind.name, from.label, 'resolved:', map(signals));
-	    const next = from.signals;     // 8     |      g
-	    if (!signals?.length) return;
-	    to.signals = signals;          // d     |       h
-	    conveySignals(from, to, next);
-	  }
-	  // conveySignals(a.connection, b.connection, aNext); //6.5
-	  // conveySignals(b.connection, a.connection, bNext);
-
-	  async function push() { // Await signals in a and send them to b.
-	    if (a.connection.peer.iceGatheringState !== 'gathering') return;
-	    const signals = await Promise.race([aPromise, a.dataChannelPromise]);
-	    aPromise = a.connection.signals;
-	    if (!signals.length) return;
-	    console.log(Kind.name, 'pushing', map(signals));
-	    b.connection.signals = signals;
-	    push();
-	  }
-	  async function pull(promise) { // Request signals from b, setting whatever we get.
-	    if (a.connection.peer.iceGatheringState !== 'gathering') return;	    
-	    const signals = await Promise.race([bPromise, b.dataChannelPromise]);
-	    bPromise = b.connection.signals;
-	    if (!signals.length) return;
-	    console.log(Kind.name, 'pulling', map(signals));
-	    a.connection.signals = signals;
-	    pull();
-	  }
-	  //push();
-	  //pull();
-	  
 	  a.testChannel = await a.dataChannelPromise;
 	  b.testChannel = await b.dataChannelPromise;
 
-	  await a.connection.reportConnection(true);
-	  await b.connection.reportConnection(true);
+	  await a.connection.reportConnection();
+	  await b.connection.reportConnection();
 	});
 	afterAll(async function () {
 	  a.connection.close();
@@ -204,8 +68,8 @@ describe("WebRTC", function () {
 	describe("second channel", function () {
 	  beforeAll(async function () {
 	    const name2 = 'channel2';
-	    a.promise2 = a.connection.ensureDataChannel(name2, channelOptions);
-	    b.promise2 = b.connection.ensureDataChannel(name2, channelOptions);
+	    a.promise2 = a.connection.ensureDataChannel(name2);
+	    b.promise2 = b.connection.ensureDataChannel(name2);
 	    a.channel2 = await a.promise2;
 	    b.channel2 = await b.promise2;
 	  });
@@ -223,8 +87,68 @@ describe("WebRTC", function () {
 	});
       });
     }
-    test(DirectSignaling);
-    test(PromiseWebRTC);
-    test(TrickleWebRTC);
+    test(DirectSignaling, async (a, b) => {
+      a.connection.otherSide = b.connection;
+      b.connection.otherSide = a.connection;
+      a.dataChannelPromise = a.connection.ensureDataChannel(channelName);
+      // Give the other side an empty list of signals (else we get two offers and no answer),
+      // but yield for the a's offer to be directly transmitted.
+      b.dataChannelPromise = b.connection.ensureDataChannel(channelName, {}, await []);
+    });
+    test(WebRTC, async (a, b) => {
+      a.dataChannelPromise = a.connection.ensureDataChannel(channelName);
+      await a.connection.signalsReady; // await for offer
+      b.dataChannelPromise = b.connection.ensureDataChannel(channelName, {}, a.connection.signals);
+      await b.connection.signalsReady; // await answer
+      await a.connection.connectVia(signals => b.connection.respond(signals)); // Transmits signals back and forth.
+    });
+  });
+  
+  describe("connection to server", function () {
+    describe("using NG ICE", function () {
+      let connection, dataChannel;
+      beforeAll(async function () {
+	connection = WebRTC.ensure({serviceLabel: 'Client'});
+	const ready = connection.signalsReady;
+	const dataChannelPromise = connection.ensureDataChannel('echo');
+	await ready;
+	connection.connectVia(signals => fetchSignals("http://localhost:3000/test/data/echo/foo", signals));
+	dataChannel = await dataChannelPromise;
+      });
+      afterAll(function () {
+	connection.close();
+      });
+      it("sends and receives data", async function () {
+	const echoPromise = new Promise(resolve => dataChannel.onmessage = event => resolve(event.data));
+	dataChannel.send('hello');
+	expect(await echoPromise).toBe('hello');
+      });
+    });
+  });
+
+  describe("capacity", function () {
+    const pairs = [];
+    const nPairs = 76; // NodeJS fails after 152 webrtc peers (76 pairs) in series. In parallel, it is only up through 67 pairs.
+    beforeAll(async function () {
+      const promises = [];
+      for (let i = 0; i < nPairs; i++) {
+	const a = {}, b = {};
+	a.connection = new WebRTC({label: `initiator-${i}`});
+	b.connection = new WebRTC({label: `receiver-${i}`});
+	let aPromise = a.connection.signalsReady;
+	a.dataChannelPromise = a.connection.ensureDataChannel('capacity');
+	const aSignals = await aPromise;
+	await a.connection.connectVia(signals => b.connection.respond(signals))
+	  .then(() => pairs.push([a, b]));
+      }
+      await Promise.all(promises);
+    });
+    afterAll(async function () {
+      for (const [a] of pairs) a.connection.close();
+      await delay(2e3);
+    });
+    it("is pretty big.", function () {
+      expect(pairs.length).toBe(nPairs);
+    });
   });
 });

package/lib/promisewebrtc.js

@@ -1,58 +0,0 @@
-import { WebRTC } from './webrtc.js';
-
-export class PromiseWebRTC extends WebRTC {
-  // Extends WebRTC.signal() such that:
-  // - instance.signals answers a promise that will resolve with an array of signal messages.
-  // - instance.signals = [...signalMessages] will dispatch those messages.
-  //
-  // For example, suppose peer1 and peer2 are instances of this.
-  // 0. Something triggers negotiation on peer1 (such as calling peer1.createDataChannel()). 
-  // 1. peer1.signals resolves with <signal1>, a POJO to be conveyed to peer2.
-  // 2. Set peer2.signals = <signal1>.
-  // 3. peer2.signals resolves with <signal2>, a POJO to be conveyed to peer1.
-  // 4. Set peer1.signals = <signal2>.
-  // 5. Data flows, but each side whould grab a new signals promise and be prepared to act if it resolves.
-  //
-  constructor({iceTimeout = 2e3, ...properties}) {
-    super(properties);
-    this.iceTimeout = iceTimeout;
-  }
-  get signals() { // Returns a promise that resolve to the signal messaging when ice candidate gathering is complete.
-    return this._signalPromise ||= new Promise((resolve, reject) => this._signalReady = {resolve, reject});
-  }
-  set signals(data) { // Set with the signals received from the other end.
-    data.forEach(([type, message]) => this[type](message));
-  }
-  onLocalIceCandidate(event) {
-    // Each wrtc implementation has its own ideas as to what ice candidates to try before emitting them in icecanddiate.
-    // Most will try things that cannot be reached, and give up when they hit the OS network timeout. Forty seconds is a long time to wait.
-    // If the wrtc is still waiting after our iceTimeout (2 seconds), lets just go with what we have.
-    this.timer ||= setTimeout(() => this.onLocalEndIce(), this.iceTimeout);
-    super.onLocalIceCandidate(event);
-  }
-  clearIceTimer() {
-    clearTimeout(this.timer);
-    this.timer = null;
-  }
-  async onLocalEndIce() { // Resolve the promise with what we've been gathering.
-    this.clearIceTimer();
-    if (!this._signalPromise) {
-      //this.logError('ice', "End of ICE without anything waiting on signals."); // Not helpful when there are three ways to receive this message.
-      return;
-    }
-    this._signalReady.resolve(this.sending);
-    this.sending = [];
-  }
-  sending = [];
-  signal(type, message) {
-    super.signal(type, message);
-    this.sending.push([type, message]);
-  }
-  close() {
-    if (this.peer.connectionState === 'failed') this._signalPromise?.reject?.();
-    super.close();
-    this.clearIceTimer();
-    this._signalPromise = this._signalReady = null;
-    this.sending = [];
-  }
-}

package/lib/tricklewebrtc.js

@@ -1,49 +0,0 @@
-import { WebRTC } from './webrtc.js';
-
-export class TrickleWebRTC extends WebRTC {
-  // Same idea as PromiseWebRTC, but instead of waiting for End of Ice (or timeout), signals will resolve as soon as there
-  // are any signals ready to be picked up, and a new call to get signals will start collecting a new set of promises.
-  // Signals stops collecting new signals when we connect (even if there are more ice candidates, and even if signals is
-  // an empty array at that point).
-
-  get signals() { // Returns a promise that collects signals until the next time someone calls this.signals,
-    // but which resolves as soon as it is not empty (and continues to accumulate).
-    // Clients must be careful to no grab a new signals promise until the previous one has resolved.
-    const { xx = 0, sending } = this;
-    const { promise, resolve } = Promise.withResolvers();
-    const counter = xx;
-    Object.assign(promise, {resolve, counter});
-    this._signalPromise = promise;
-    this.sending = [];
-    this.xx = counter + 1;
-    //console.log(this.label, 'get signals', {xx, sending, promise, counter, promise, sending: this.sending});
-    return promise;
-  }
-  set signals(data) { // Set with the signals received from the other end.
-    data.forEach(([type, message]) => this[type](message));
-  }
-  // onLocalEndIce() {
-  //   console.log(this.label, 'end ice');
-  //   this.signal('icecandidate', null); // So that clients can recognize that they should not await more signals.
-  // }
-  // connectionStateChange(state) {
-  //   //console.log(this.label, 'connection state', state);    
-  //   super.connectionStateChange(state);
-  //   //this._signalPromise.resolve(this.sending);
-  // }
-  sending = [];
-  signal(type, message) {
-    super.signal(type, message);
-    this.sending.push([type, message]);
-    // Until another call to get signals (which replaces _signalPromise), we will continue to accumulate into
-    // the same sending array, and subsequent signals will re-resolve (which has no effect on the promise).
-    this._signalPromise.resolve(this.sending);
-    //console.log(this.label, 'signal', type, 'resolving', this._signalPromise);
-  }
-  // close() {
-  //   if (this.peer.connectionState === 'failed') this._signalPromise?.reject?.();
-  //   super.close();
-  //   // this._signalPromise = null;
-  //   // this.sending = [];
-  // }
-}