@yz-social/webrtc 0.1.2 → 0.1.4

package/browser-wrtc.js

@@ -0,0 +1 @@
+export default globalThis;

package/index.js

@@ -1,4 +1,4 @@
-//import wrtc from '#wrtc'; // fixme
+// import wrtc from '#wrtc';
 const wrtc = (typeof(process) === 'undefined') ? globalThis : (await import('#wrtc')).default;
 
 export class WebRTC {
@@ -80,7 +80,9 @@ export class WebRTC {
     // Do not try to close or wait for data channels. It confuses Safari.
     const pc = this.pc;
     if (!pc) return null;
-    pc.close();
+    const state = pc.connectionState;
+    if (state === 'connected' || state === 'failed') pc.close();
+    else this.flog("WebRTC close in unexpected state", state);
     this.closed.resolve(pc); // We do not automatically receive 'connectionstatechange' when our side explicitly closes. (Only if the other does.)
     this.cleanup();
     return this.closed;
@@ -233,7 +235,8 @@ export class WebRTC {
     this.log('setupChannel:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
     const kind = isTheirs ? 'Theirs' : 'Ours';
     dc.webrtc = this;
-    dc.onopen = async () => { // Idempotent (except for logging), if we do not bash dataChannePromises[label] multiple times.
+    dc.onopen = () => { // Idempotent (except for logging), if we do not bash dataChannePromises[label] multiple times.
+      dc.onopen = null;
       this.log('channel onopen:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
       this[this.restrictablePromiseKey()][label]?.resolve(dc);
       this[this.restrictablePromiseKey(kind)][label]?.resolve(dc);
@@ -246,7 +249,6 @@ export class WebRTC {
     // This our chance to setupChannel, just as if we had called createChannel
     this.log('ondatachannel:', dc.label, dc.id, dc.readyState, dc.negotiated);
     this.setupChannel(dc);
-    dc.onopen(); // It had been opened before we setup, so invoke handler now.
   }
   channelId = 128; // Non-negotiated channel.id get assigned at open by the peer, starting with 0. This avoids conflicts.
   createChannel(name = 'data', {negotiated = false, id = this.channelId++, ...options} = {}) { // Explicitly create channel and set it up.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/webrtc",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Streamlined portable webrtc management of p2p and client2server.",
   "keywords": [
     "webrtc",
@@ -12,22 +12,23 @@
   "imports": {
     "#wrtc": {
       "node": "@roamhq/wrtc",
-      "default": "./lib/browser-wrtc.js"
+      "default": "./browser-wrtc.js"
     }
   },
   "exports": {
-    ".": "./index.js",
-    "./router": "./routes/index.js"
+    ".": "./index.js"
   },
   "scripts": {
-    "test": "npx jasmine"
+    "test": "npx jasmine",
+    "testServer": "node spec/portal.js"
   },
   "dependencies": {
     "@roamhq/wrtc": "^0.9.1"
   },
   "devDependencies": {
     "express": "^5.2.1",
-    "jasmine": "^5.12.0"
+    "jasmine": "^5.12.0",
+    "morgan": "^1.10.1"
   },
   "repository": {
     "type": "git",

package/spec/portal.js

@@ -1,6 +1,7 @@
 import process from 'node:process';
 import cluster from 'node:cluster';
 import express from 'express';
+import logger from 'morgan';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { WebRTC } from '../index.js';
@@ -26,6 +27,7 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
     });
   }
   const workers = Object.values(cluster.workers);
+  app.use(logger(':date[iso] :status :method :url :res[content-length] - :response-time ms'));
   app.use(express.json());
   app.use(express.static(path.resolve(__dirname, '..'))); // Serve files needed for testing browsers.
   app.post('/join/:to', async (req, res, next) => { // Handler for JSON POST requests that provide an array of signals and get signals back.

package/spec/test.html

@@ -9,7 +9,7 @@
     <script src="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot1.js"></script>
     <script type="module">
       import './webrtcSpec.js';
-      import './webrtcCapacitySpec.js';      
+      import './webrtcCapacitySpec.js';
     </script>
   </head>
 </html>

package/spec/webrtcSpec.js

@@ -5,7 +5,7 @@ describe("WebRTC", function () {
   const isBrowser = typeof(process) === 'undefined';
   let connections = [];
   describe("direct in-process signaling", function () {
-    function makePair({debug = false, delay = 0, index = 0} = {}) {
+    async function makePair({debug = false, delay = 0, index = 0} = {}) {
       //const configuration = { iceServers: [] };
       const configuration = { iceServers: WebRTC.iceServers };
       const A = new WebRTC({name: `A (impolite) ${index}`, polite: false, debug, configuration});
@@ -64,7 +64,7 @@ describe("WebRTC", function () {
 	promises.push(B.getDataChannelPromise('data', 'Theirs').then(sendingSetup));
       }
 	
-      const direct = true; // Does signal work direct/one-sided to the other? False makes a request that waits for a response.
+      const direct = false; // 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);
@@ -72,6 +72,7 @@ describe("WebRTC", function () {
 	A.transferSignals = messages => B.respond(messages);
 	B.transferSignals = messages => A.respond(messages);
       }
+      await WebRTC.delay(1); // TODO: This is crazy, but without out, the FIRST connection in chrome hangs!
       return connections[index] = {A, B, bothOpen: Promise.all(promises)};
     }
     function standardBehavior(setup, {includeConflictCheck = isBrowser, includeSecondChannel = false} = {}) {
@@ -94,11 +95,12 @@ describe("WebRTC", function () {
         const start = Date.now();
         console.log(new Date(), 'start setup', nPairs, 'pairs');
         for (let index = 0; index < nPairs; index++) {
+	  console.log('setup', index);
           await setup({index});
         }
 	//await Promise.all(connections.map(connection => connection.bothOpen));
         console.log('end setup', Date.now() - start);
-      }, nPairs * 1e3);
+      }, nPairs * 2e3);
       for (let index = 0; index < nPairs; index++) {
         it(`connects ${index}.`, function () {
           const {A, B} = connections[index];
@@ -169,7 +171,7 @@ describe("WebRTC", function () {
       describe('non-negotiated', function () {
 	beforeAll(function () {console.log('one-sided non-negotiated'); });
         standardBehavior(async function ({index}) {
-          const {A, B, bothOpen} = makePair({index});
+          const {A, B, bothOpen} = await makePair({index});
           A.createChannel('data', {negotiated: false});
           await bothOpen;
         }, {includeConflictCheck: false, includeSecondChannel: false});
@@ -177,7 +179,7 @@ describe("WebRTC", function () {
       describe("negotiated on first signal", function () {
 	beforeAll(function () {console.log('one-sided negotiated'); });
         standardBehavior(async function ({index}) {
-          const {A, B, bothOpen} = makePair({index});
+          const {A, B, bothOpen} = await makePair({index});
           // There isn't really a direct, automated way to have one side open another with negotiated:true,
           // because the receiving RTCPeerConnection does not fire 'datachannel' when the sender was negotiated:true.
           // However, what the app can do is wake up and create an explicit createChannel when it first receives an
@@ -201,7 +203,7 @@ describe("WebRTC", function () {
         describe("impolite first", function () {
 	  beforeAll(function () {console.log('two-sided negotiated impolite-first'); });
           standardBehavior(async function ({index}) {
-            const {A, B, bothOpen} = makePair({index});     
+            const {A, B, bothOpen} = await makePair({index});
             A.createChannel("data", {negotiated: true});
             B.createChannel("data", {negotiated: true});
             await bothOpen;
@@ -210,7 +212,8 @@ 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});
+            const {A, B, bothOpen} = await makePair({index,});
+	    //await WebRTC.delay(1); // TODO: Why is this needed?
             B.createChannel("data", {negotiated: true});
             A.createChannel("data", {negotiated: true});
             await bothOpen;
@@ -223,7 +226,8 @@ describe("WebRTC", function () {
         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, debug});
+            const {A, B, bothOpen} = await makePair({delay, index, debug});
+	    //await WebRTC.delay(1); // TODO: Why is this needed?
             A.createChannel("data", {negotiated: false});
             B.createChannel("data", {negotiated: false});
             await bothOpen;
@@ -232,7 +236,7 @@ describe("WebRTC", function () {
         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, debug});
+            const {A, B, bothOpen} = await makePair({delay, index, debug});
             B.createChannel("data", {negotiated: false});
             A.createChannel("data", {negotiated: false});
             await bothOpen;

package/routes/index.js

@@ -1,27 +0,0 @@
-import express from 'express';
-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('/data/echo/:tag', async (req, res, next) => { // Test endpoint for WebRTC.
-  const {params, body} = req;
-  const tag = params.tag;
-  let incomingSignals = body;
-  let connection = testConnections[tag];
-  if (!connection) {
-    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 => {
-      dataChannel.onclose = () => {
-	clearTimeout(timer);
-	connection.close();
-	delete testConnections[tag];
-      };
-      dataChannel.onmessage = event => dataChannel.send(event.data); // Just echo what we are given.
-    });
-  }
-  res.send(await connection.respond(incomingSignals));
-});
-