@yz-social/webrtc 0.1.0 → 0.1.1

package/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI/CD Build and Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch: # Allows manual running
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest # Uses the latest Ubuntu runner
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v5 # Action to check out your repository code
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4 # Action to set up Node.js environment
+        with:
+          node-version: '22.x'
+
+      - name: Install Dependencies
+        run: npm i # Some folks recommend 'npm ci', but I don't like the required package lock.
+
+      - name: Run Tests
+        run: npm test # Executes the 'test' script defined in your package.json

package/index.js

@@ -181,40 +181,44 @@ export class WebRTC {
     if (!this.transferSignals) return; // Just keep collecting until the next call to respond();
     this.sendPending();
   }
-  followupTimer = null;
+  //followupTimer = null;
   sendPending(force = false) { // Send over any signals we have, and process the response.
     this.lastOutboundSignal = Date.now();
-    clearTimeout(this.followupTimer);
+    //clearTimeout(this.followupTimer);
     this.transferSerializer = this.transferSerializer.then(() => {
       const signals = this.collectPendingSignals();
       if (!force && !signals.length) return null; // A stack of pending signals got rolled together and pending is now empty.
       this.lastOutboundSend = Date.now();
       this.log('sending', signals.length, 'signals');
       return this.transferSignals(signals).then(async response => {
-	clearTimeout(this.followupTimer);
+	//clearTimeout(this.followupTimer);
 	this.lastResponse = Date.now();
 	await this.onSignals(response);
-	if (this.pc.connectionState === 'connected') return;
-	this.followupTimer = setTimeout(() => { // We may have sent everything we had, but still need to poke in order to get more ice from them.
-	  if (this.pc.connectionState === 'connected') return;
-	  this.log('************** nothing new to send', this.pc.connectionState, ' ************************');
-	  this.sendPending(true);
-	}, 500);
+	// if (this.pc.connectionState === 'connected') return;
+	// this.followupTimer = setTimeout(() => { // We may have sent everything we had, but still need to poke in order to get more ice from them.
+	//   if (this.pc.connectionState === 'connected') return;
+	// Note: if we bring this back, stop after closed!
+	//   this.log('************** nothing new to send', this.pc.connectionState, ' ************************');
+	//   this.sendPending(true);
+	// }, 500);
       });
     });
   }
   transferSerializer = Promise.resolve();
 
-  dataChannels = {};
-  setupChannel(dc) { // Given an open or connecting channel, set it up in a unform way.
-    this.log('setup:', dc.label, dc.id, dc.readyState, 'negotiated:', dc.negotiated, 'exists:', !!this[dc.label]);
-    this[dc.label] = this.dataChannels[dc.label] = dc;
+  setupChannel(dc) { // Arrange for the data channel promise to resolve open, and do other setup.
+    // Called by explicit createChannel ('ours' opened) and also by ondatachannel ('theirs' opened).
+    const { label, readyState } = dc;
+    const isTheirs = readyState === 'open'; // Came via ondatachannel.
+    this.log('setupChannel:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
+    const kind = isTheirs ? 'Theirs' : 'Ours';
     dc.webrtc = this;
-    dc.onopen = async () => {
-      this.log('channel onopen:', dc.label, dc.id, dc.readyState, 'negotiated:', dc.negotiated);
-      this.dataChannelPromises[dc.label]?.resolve(this[dc.label]);
+    dc.onopen = async () => { // Idempotent (except for logging), if we do not bash dataChannePromises[label] multiple times.
+      this.log('channel onopen:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
+      this[this.restrictablePromiseKey()][label]?.resolve(dc);
+      this[this.restrictablePromiseKey(kind)][label]?.resolve(dc);
     };
-    if (dc.readyState === 'open') dc.onopen();
+    if (isTheirs) dc.onopen();
     return dc;
   }
   ondatachannel(dc) {
@@ -229,10 +233,18 @@ export class WebRTC {
     return this.setupChannel(this.pc.createDataChannel(name, {negotiated, id, ...options}));
   }
   dataChannelPromises = {};
-  getDataChannelPromise(name = 'data') { // Promise to resolve when opened, WITHOUT actually creating one.
+  dataChannelOursPromises = {};
+  dataChannelTheirsPromises = {};  
+  restrictablePromiseKey(restriction = '') { // The property in which store dataChannel promises of the specified restriction.
+    return `dataChannel${restriction}Promises`;
+  }
+  getDataChannelPromise(name = 'data', restriction = '') { // Promise to resolve when opened, WITHOUT actually creating one.
+    // The application can restrict this to being only a channel of 'ours' or 'theirs' (see setupChannel), which is useful for
+    // non-negotiated channels.
+    const key = this.restrictablePromiseKey(restriction);
     const {promise, resolve, reject} = Promise.withResolvers();
     Object.assign(promise, {resolve, reject});
-    return this.dataChannelPromises[name] = promise;
+    return this[key][name] = promise;
   }
 
   async reportConnection(doLogging = false) { // Update self with latest wrtc stats (and log them if doLogging true). See Object.assign for properties.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/webrtc",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Streamlined portable webrtc management of p2p and client2server.",
   "keywords": [
     "webrtc",

package/spec/webrtcSpec.js

@@ -3,11 +3,6 @@ import { WebRTC } from '../index.js';
 
 describe("WebRTC", function () {
   const isBrowser = typeof(process) === 'undefined';
-  // maximums
-  // 1 channel pair, without negotiated on first signal: nodejs:83, firefox:150+, safari:85+ but gets confused with closing, chrome/edge:50(?)
-  // 50 works across the board with one channel pair
-  // On Safari (only), anything more than 32 pair starts to loose messages on the SECOND channel.
-  const nPairs = 32; //32;
   let connections = [];
   describe("direct in-process signaling", function () {
     function makePair({debug = false, delay = 0, index = 0} = {}) {
@@ -15,25 +10,13 @@ describe("WebRTC", function () {
       const configuration = { iceServers: WebRTC.iceServers };
       const A = new WebRTC({name: `A (impolite) ${index}`, polite: false, debug, configuration});
       const B = new WebRTC({name: `B (polite) ${index}`, polite: true, debug, configuration});
-      async function sendingSetup(dc) { // Given an open channel, set up to receive a message and then send a test message.
-        const webrtc = dc.webrtc;
-        webrtc.receivedMessageCount = webrtc.sentMessageCount = 0;
-	webrtc.gotData = new Promise(resolve => {
-          dc.onmessage = e => {
-            webrtc.receivedMessageCount++;
-            webrtc.log('got message on', dc.label, dc.id, e.data);
-	    resolve(e.data);
-          };
-	});
-        webrtc.sentMessageCount++;
-
         // Subtle:
         //
         // An explicit createChannel() arranges for the promise created by getDataChannelPromise() of the same name to
         // resolve on that side of the connection when the channel is open. The other side will internally receive a
         // datachannel event and we arrange for that side to then also resolve a getDataChannelPromise for that name.
         //
-        // If only wide side creates the channel, things work out smoothly. Each side ends up resolving the promise for a
+        // If only one side creates the channel, things work out smoothly. Each side ends up resolving the promise for a
         // channel of the given name. The id is as defaulted or specified if negotiated:true, else an internally determined
         // unique id is used.
         //
@@ -41,24 +24,47 @@ describe("WebRTC", function () {
         // are overlappaing offers. One side backs down and there ends up being one channel with the specified id. (The default
         // id will be the same on both sides IFF any multiple data channels are created in the same order on both sides.)
         //
-        // However, when negotiated:false, and both sides call createChannel simultaneously, things get complex. Counterintuitively,
-        // RTCPeerConnection arranges for the internall determined id to be unique between the two sides, so both get
+        // However, when negotiated:FALSE, and both sides call createChannel with a delay in betwen, things get complex. Counterintuitively,
+        // RTCPeerConnection arranges for the internally determined id to be unique between the two sides, so both get
         // two channels with the same name and different id. There will be two internal open events on each side: first for the
-        // channel that it created, and second for one that the other side created. There isn't any reason to do this (as
+        // channel that it created, and second for one that the other side created. (There likely isn't any reason to do this, as
         // opposed to specifying negotiated:true, unless the application needs each side to listen on one channel and send
-        // on the other. However, getDataChannelPromise return a promise based on the specified name alone, and it only
-        // resolves once. For compatibility with the single-sided case, we resolve the first channel (on each side, which
-        // are different ids). Thus we must attach onmessage to one channel and send on the other. On both sides, the
-        // first channel is what the promise resolves to, but after a delay, the second channel is available on webrtc[channelName].
-
-        if (!delay) return dc.send(`Hello from ${webrtc.name}`);
+        // on the other.)
+      async function receivingSetup(dc) {
+        const webrtc = dc.webrtc;
+        webrtc.log('got open recieving channel', dc.label, dc.id);
+	webrtc.ours = dc;
+	webrtc.receivedMessageCount = 0;
+	webrtc.gotData = new Promise(resolve => webrtc.gotDataResolver = resolve);
+        dc.onmessage = e => {
+          webrtc.receivedMessageCount++;
+          webrtc.log('got message on', dc.label, dc.id, e.data);
+	  webrtc.gotDataResolver(e.data);
+	};
+	return dc;
+      }
+      async function sendingSetup(dc) {
+        const webrtc = dc.webrtc;
+	webrtc.log('got open sending channel', dc.label, dc.id);
+	webrtc.theirs = dc;
+        webrtc.sentMessageCount ||= 0;
+	webrtc.sentMessageCount++;
         await WebRTC.delay(delay);
-        webrtc.data.send(`Hello from ${webrtc.name}`);
-        return null;
+	dc.send(`Hello from ${webrtc.name}`);
+	return dc;
+      }
+      const promises = [];
+      if (!delay) {
+	promises.push(A.getDataChannelPromise('data').then(receivingSetup).then(sendingSetup));
+	promises.push(B.getDataChannelPromise('data').then(receivingSetup).then(sendingSetup));
+      } else {
+	promises.push(A.getDataChannelPromise('data', 'Ours').then(receivingSetup));
+	promises.push(B.getDataChannelPromise('data', 'Ours').then(receivingSetup));
+	promises.push(A.getDataChannelPromise('data', 'Theirs').then(sendingSetup));
+	promises.push(B.getDataChannelPromise('data', 'Theirs').then(sendingSetup));
       }
-      const aOpen = A.getDataChannelPromise('data').then(sendingSetup);
-      const bOpen = B.getDataChannelPromise('data').then(sendingSetup);
-      const direct = false; // Does signal work direct/one-sided to the other? False makes a request that waits for a response.
+	
+      const direct = true; // Does signal work direct/one-sided to the other? False makes a request that waits for a response.
       if (direct) {
 	A.signal = message => B.onSignal(message);
 	B.signal = message => A.onSignal(message);
@@ -66,12 +72,17 @@ describe("WebRTC", function () {
 	A.transferSignals = messages => B.respond(messages);
 	B.transferSignals = messages => A.respond(messages);
       }
-      return connections[index] = {A, B, bothOpen: Promise.all([aOpen, bOpen])};
+      return connections[index] = {A, B, bothOpen: Promise.all(promises)};
     }
-    function standardBehavior(setup, {includeConflictCheck = isBrowser, includeSecondChannel = true} = {}) {
+    function standardBehavior(setup, {includeConflictCheck = isBrowser, includeSecondChannel = false} = {}) {
+      // maximums
+      // 1 channel pair, without negotiated on first signal: nodejs:83, firefox:150+, safari:85+ but gets confused with closing, chrome/edge:50(?)
+      // 50 works across the board with one channel pair
+      // On Safari (only), anything more than 32 pair starts to loose messages on the SECOND channel.
+      const nPairs = includeSecondChannel ? 32 : 62; //32;
       beforeAll(async function () {
         const start = Date.now();
-        console.log('start setup');
+        console.log(new Date(), 'start setup', nPairs, 'pairs');
         for (let index = 0; index < nPairs; index++) {
           await setup({index});
         }
@@ -81,8 +92,10 @@ describe("WebRTC", function () {
       for (let index = 0; index < nPairs; index++) {
         it(`connects ${index}.`, function () {
           const {A, B} = connections[index];
-          expect(A.data.readyState).toBe('open');
-          expect(B.data.readyState).toBe('open');
+          expect(A.ours.readyState).toBe('open');
+          expect(B.ours.readyState).toBe('open');
+          expect(A.theirs.readyState).toBe('open');
+          expect(B.theirs.readyState).toBe('open');
         });
         it(`receives ${index}.`, async function () {
           const {A, B} = connections[index];    
@@ -143,6 +156,7 @@ describe("WebRTC", function () {
     }
     describe("one side opens", function () {
       describe('non-negotiated', function () {
+	beforeAll(function () {console.log('one-sided non-negotiated'); });
         standardBehavior(async function ({index}) {
           const {A, B, bothOpen} = makePair({index});
           A.createChannel('data', {negotiated: false});
@@ -150,6 +164,7 @@ describe("WebRTC", function () {
         }, {includeConflictCheck: false, includeSecondChannel: false});
       });
       describe("negotiated on first signal", function () {
+	beforeAll(function () {console.log('one-sided negotiated'); });
         standardBehavior(async function ({index}) {
           const {A, B, bothOpen} = makePair({index});
           // There isn't really a direct, automated way to have one side open another with negotiated:true,
@@ -173,6 +188,7 @@ describe("WebRTC", function () {
     describe("simultaneous two-sided", function () {
       describe("negotiated single full-duplex-channel", function () {
         describe("impolite first", function () {
+	  beforeAll(function () {console.log('two-sided negotiated impolite-first'); });
           standardBehavior(async function ({index}) {
             const {A, B, bothOpen} = makePair({index});     
             A.createChannel("data", {negotiated: true});
@@ -181,6 +197,7 @@ describe("WebRTC", function () {
           });
         });
         describe("polite first", function () {
+	  beforeAll(function () {console.log('two-sided negotiated polite-first');});
           standardBehavior(async function ({index}) {
             const {A, B, bothOpen} = makePair({index});
             B.createChannel("data", {negotiated: true});
@@ -190,18 +207,21 @@ describe("WebRTC", function () {
         });
       });
       describe("non-negotiated dual half-duplex channels", function () {
-        const delay = 10;
+        const delay = 200;
+	const debug = false;
         describe("impolite first", function () {
+	  beforeAll(function () {console.log('two-sided non-negotiated impolite-first');});
           standardBehavior(async function ({index}) {
-            const {A, B, bothOpen} = makePair({delay, index});
+            const {A, B, bothOpen} = makePair({delay, index, debug});
             A.createChannel("data", {negotiated: false});
             B.createChannel("data", {negotiated: false});
             await bothOpen;
           });
         });
         describe("polite first", function () {
+	  beforeAll(function () {console.log('two-sided non-negotiated polite-first');});
           standardBehavior(async function ({index}) {
-            const {A, B, bothOpen} = makePair({delay, index});
+            const {A, B, bothOpen} = makePair({delay, index, debug});
             B.createChannel("data", {negotiated: false});
             A.createChannel("data", {negotiated: false});
             await bothOpen;