hsync 0.30.1 → 0.31.0

package/lib/rtc-node.js

@@ -1,48 +1,53 @@
-const debug = require('debug')('hsync:rtc-node');
-const debugError = require('debug')('errors');
+import createDebug from 'debug';
+
+const debug = createDebug('hsync:rtc-node');
+const debugError = createDebug('errors');
+
 let nodeDataChannel;
 try {
-  nodeDataChannel = require('node-datachannel');
+  nodeDataChannel = await import('node-datachannel');
+  // Handle both default export and named export
+  if (nodeDataChannel.default) {
+    nodeDataChannel = nodeDataChannel.default;
+  }
 } catch (e) {
-  debugError(e);
+  debugError('node-datachannel not installed:', e.message);
 }
 
 const rtc = {
   PeerConnection: nodeDataChannel?.PeerConnection,
 };
 
-
 const defaultOptions = { iceServers: ['stun:stun.l.google.com:19302'] };
 
 const GATHERING_TIMEOUT = 4000;
 
-function offerPeer(peer) {
-  return new Promise(async (resolve, reject) => {
-    if (!rtc.PeerConnection) {
-      reject('node-datachannel not installed');
-      return;
-    }
-  
+async function offerPeer(peer) {
+  if (!rtc.PeerConnection) {
+    throw new Error('node-datachannel not installed');
+  }
+
+  return new Promise((resolve, reject) => {
     const con = new rtc.PeerConnection('pc', defaultOptions);
     // window.rtc = rtc;
-  
+
     peer.rtcCon = con;
     peer.rtcOfferer = true;
-    
+
     let gatheringComplete = false;
-    let offerSent = false;
+    // offerSent tracking removed - not currently used
     const start = Date.now();
 
     peer.handleRtcAnswer = async (answer) => {
       debug('node handle RtcAnswer', answer.sdp.length);
       await peer.rtcCon.setRemoteDescription(answer.sdp, answer.type);
       return 'node handle RtcAnswer ok';
-    }
-  
+    };
+
     async function sendOffer() {
       const desc = con.localDescription();
       try {
-        const resp = await peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
+        const resp = await peer.methods.rtcSignal({ type: desc.type, sdp: desc.sdp });
         resolve(resp);
       } catch (e) {
         debugError('error sending offer', e);
@@ -50,7 +55,7 @@ function offerPeer(peer) {
       }
       // peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
     }
-  
+
     con.onGatheringStateChange = (state) => {
       debug('onGatheringStateChange', state);
       if (state === 'complete') {
@@ -59,8 +64,8 @@ function offerPeer(peer) {
         // We only want to provide an answer once all of our candidates have been added to the SDP.
         sendOffer();
       }
-    }
-  
+    };
+
     con.onStateChange((state) => {
       debug('offerer onStateChange: ', state);
       if (state === 'connected') {
@@ -78,12 +83,12 @@ function offerPeer(peer) {
         peer.dc = null;
       }
     });
-  
+
     con.onDataChannel((dc) => {
       debug('offerer onDataChannel', dc);
       peer.dc = dc;
     });
-  
+
     const dc = con.createDataChannel('fromofferer');
     dc.onOpen(() => {
       peer.dc = dc;
@@ -94,22 +99,20 @@ function offerPeer(peer) {
       peer.rtcEvents.emit('dcOpen', dc);
       debug('keys', Object.keys(dc));
     });
-  
+
     dc.onMessage((msg) => {
       debug('node offerer received msg:', msg.length);
       peer.rtcEvents.emit('packet', msg);
     });
-  
+
     con.setLocalDescription();
-  
+
     setTimeout(() => {
       if (!gatheringComplete) {
         debug('didnt finish gathering');
         sendOffer();
-        offerSent = true;
       }
     }, GATHERING_TIMEOUT);
-
   });
 }
 
@@ -121,10 +124,10 @@ async function answerPeer(peer, offer) {
   const con = new rtc.PeerConnection('pc', defaultOptions);
   peer.rtcCon = con;
   peer.answerer = true;
-  
+
   function sendAnswer() {
     const desc = con.localDescription();
-    peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
+    peer.methods.rtcSignal({ type: desc.type, sdp: desc.sdp });
   }
 
   con.onStateChange((state) => {
@@ -157,7 +160,7 @@ async function answerPeer(peer, offer) {
   con.setLocalDescription();
 
   con.onDataChannel((dc) => {
-    debug("answerer onDataChannel", dc.getLabel());
+    debug('answerer onDataChannel', dc.getLabel());
     dc.onMessage((msg) => {
       debug('node answerer Received Msg:', msg.length);
       peer.rtcEvents.emit('packet', msg);
@@ -171,11 +174,9 @@ async function answerPeer(peer, offer) {
     };
     peer.rtcEvents.emit('dcOpen', dc);
   });
-
 }
 
 rtc.offerPeer = offerPeer;
 rtc.answerPeer = answerPeer;
 
-
-module.exports = rtc;
+export default rtc;

package/lib/rtc-web.js

@@ -1,36 +1,37 @@
-const debug = require('debug')('hsync:rtc-web');
-const debugError = require('debug')('errors');
+import createDebug from 'debug';
+
+const debug = createDebug('hsync:rtc-web');
+const debugError = createDebug('errors');
 
 const rtc = {
   PeerConnection: RTCPeerConnection,
 };
 
-
 const defaultOptions = {
   // Recommended for libdatachannel
   // bundlePolicy: "max-bundle",
-  iceServers: [{ 'urls': 'stun:stun.l.google.com:19302' }] 
+  iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
 };
 
 const GATHERING_TIMEOUT = 4000;
 
 async function offerPeer(peer) {
-  return new Promise(async (resolve, reject) => {
-    const con = new RTCPeerConnection(defaultOptions);
-    // window.rtc = rtc;
+  const con = new RTCPeerConnection(defaultOptions);
+  // window.rtc = rtc;
 
-    peer.rtcCon = con;
-    peer.rtcOfferer = true;
-    
-    let gatheringComplete = false;
-    let offerSent = false;
-    const start = Date.now();
+  peer.rtcCon = con;
+  peer.rtcOfferer = true;
 
+  let gatheringComplete = false;
+  let offerSent = false;
+  const start = Date.now();
+
+  return new Promise((resolve, reject) => {
     async function sendOffer(alreadySent) {
       debug('send offer', alreadySent);
       const desc = con.localDescription;
       try {
-        const resp = await peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp, alreadySent});
+        const resp = await peer.methods.rtcSignal({ type: desc.type, sdp: desc.sdp, alreadySent });
         resolve(resp);
       } catch (e) {
         debugError('error sending offer', e);
@@ -38,15 +39,15 @@ async function offerPeer(peer) {
       }
     }
 
-    con.onicegatheringstatechange = (state) => {
-        debug('state change', con.iceGatheringState);
-        if (con.iceGatheringState === 'complete') {
-          debug('icegathering done', Date.now() - start);
-          gatheringComplete = true;
-          // We only want to provide an answer once all of our candidates have been added to the SDP.
-          sendOffer(offerSent);
-        }
-    }
+    con.onicegatheringstatechange = (_state) => {
+      debug('state change', con.iceGatheringState);
+      if (con.iceGatheringState === 'complete') {
+        debug('icegathering done', Date.now() - start);
+        gatheringComplete = true;
+        // We only want to provide an answer once all of our candidates have been added to the SDP.
+        sendOffer(offerSent);
+      }
+    };
 
     con.onicecandidate = (ice) => {
       debug('ice candidate', ice);
@@ -54,7 +55,7 @@ async function offerPeer(peer) {
 
     con.onconnectionstatechange = (event) => {
       debug('offerer connection state', con.connectionState, event);
-      if(con.connectionState === 'connected') {
+      if (con.connectionState === 'connected') {
         peer.connected = true;
         peer.rtcEvents.emit('connected', con);
       } else if (con.connectionState === 'disconnected') {
@@ -78,11 +79,11 @@ async function offerPeer(peer) {
     const dc = con.createDataChannel('from web');
 
     peer.dc = dc;
-    dc.onmessage = (event) => { 
+    dc.onmessage = (event) => {
       debug('dc.onmessage', event.data);
       peer.rtcEvents.emit('packet', event.data);
     };
-    dc.onopen = (event) => { 
+    dc.onopen = (_event) => {
       peer.dcOpen = true;
       peer.dc = dc;
       peer.rtcSend = (packet) => {
@@ -92,61 +93,64 @@ async function offerPeer(peer) {
       peer.rtcEvents.emit('dcOpen', dc);
       // dc.send('yo waddup from the browser');
     };
-    
-    try {
-      const offer = await con.createOffer({offerToReceiveAudio:true, offerToReceiveVideo:true});
-      await con.setLocalDescription(offer);
-
-      setTimeout(() => {
-        if (!gatheringComplete) {
-          debug('didnt finish gathering');
-          sendOffer();
-          offerSent = true;
-        }
-      }, GATHERING_TIMEOUT);
-
-      peer.handleRtcAnswer = async (answer) => {
-        debug('web handle RtcAnswer', answer.sdp.length);
-        await con.setRemoteDescription(answer);
-        return 'web handle RtcAnswer ok';
-      };
-    } catch (e) {
-      debugError('error creating data channel', e);
-      reject(e);
-    }
+
+    con
+      .createOffer({ offerToReceiveAudio: true, offerToReceiveVideo: true })
+      .then((offer) => {
+        return con.setLocalDescription(offer);
+      })
+      .then(() => {
+        setTimeout(() => {
+          if (!gatheringComplete) {
+            debug('didnt finish gathering');
+            sendOffer();
+            offerSent = true;
+          }
+        }, GATHERING_TIMEOUT);
+
+        peer.handleRtcAnswer = async (answer) => {
+          debug('web handle RtcAnswer', answer.sdp.length);
+          await con.setRemoteDescription(answer);
+          return 'web handle RtcAnswer ok';
+        };
+      })
+      .catch((e) => {
+        debugError('error creating data channel', e);
+        reject(e);
+      });
   });
 }
 
 async function answerPeer(peer, offer) {
-  const options = {...defaultOptions, bundlePolicy: "max-bundle"};
+  const options = { ...defaultOptions, bundlePolicy: 'max-bundle' };
   const con = new RTCPeerConnection(options);
   // window.rtc = rtc;
 
   peer.rtcCon = con;
   peer.answerer = true;
-  
+
   let gatheringComplete = false;
   const start = Date.now();
 
   async function sendAnswer() {
     const desc = con.localDescription;
     try {
-      await peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
+      await peer.methods.rtcSignal({ type: desc.type, sdp: desc.sdp });
     } catch (e) {
       debugError('error sending answer', e);
     }
   }
 
-  con.onicegatheringstatechange = (state) => {
+  con.onicegatheringstatechange = (_state) => {
     if (con.iceGatheringState === 'complete') {
       gatheringComplete = true;
       debug('answerer icegathering done', Date.now() - start);
       sendAnswer();
     }
-  }
+  };
   await con.setRemoteDescription(offer);
 
-  let answer = await con.createAnswer();
+  const answer = await con.createAnswer();
   await con.setLocalDescription(answer);
 
   con.onicecandidate = (ice) => {
@@ -155,7 +159,7 @@ async function answerPeer(peer, offer) {
 
   con.onconnectionstatechange = (event) => {
     debug('answerer connection state', con.connectionState, event);
-    if(con.connectionState === 'connected') {
+    if (con.connectionState === 'connected') {
       peer.connected = true;
       peer.rtcEvents.emit('connected', con);
     } else if (con.connectionState === 'disconnected') {
@@ -201,11 +205,9 @@ async function answerPeer(peer, offer) {
       sendAnswer();
     }
   }, GATHERING_TIMEOUT);
-
 }
 
-
 rtc.offerPeer = offerPeer;
 rtc.answerPeer = answerPeer;
 
-module.exports = rtc;
+export default rtc;

package/lib/socket-listeners.js

@@ -1,24 +1,25 @@
-const b64id = require('b64id');
-const debug = require('debug')('hsync:listener');
-const debugError = require('debug')('hsync:error');
+import b64id from 'b64id';
+import createDebug from 'debug';
+import { sockets } from './socket-map.js';
 
-const { sockets } = require('./socket-map');
+const debug = createDebug('hsync:listener');
+const debugError = createDebug('hsync:error');
+
+debugError.color = 1;
 
 let net;
 
-function setNet(netImpl) {
+export function setNet(netImpl) {
   net = netImpl;
 }
 
-debugError.color = 1;
-
-function initListeners(hsyncClient) {
+export function initListeners(hsyncClient) {
   const socketListeners = {};
 
   function getSocketListeners() {
     const hKeys = Object.keys(socketListeners);
     debug('getSocketListeners', hKeys);
-    let retVal = hKeys.map((hk) => {
+    const retVal = hKeys.map((hk) => {
       const l = socketListeners[hk];
       return {
         port: l.port,
@@ -46,11 +47,10 @@ function initListeners(hsyncClient) {
     if (cleanHost !== targetHost) {
       debug('targetHost cleaned UP', targetHost, cleanHost);
     }
-    
+
     const rpcPeer = hsyncClient.getRPCPeer({ hostName: cleanHost });
 
     const socketServer = net.createServer(async (socket) => {
-
       if (!rpcPeer.rtcCon) {
         try {
           debug('initiating connectRTC from socket listener');
@@ -106,7 +106,7 @@ function initListeners(hsyncClient) {
         // }
         sendData(data);
       });
-    
+
       socket.on('close', (a, b, c) => {
         debug('listener socket closed', port, socket.socketId, a, b, c);
         if (sockets[socket.socketId]) {
@@ -120,14 +120,14 @@ function initListeners(hsyncClient) {
           }
         }
       });
-    
+
       socket.on('error', (error) => {
         debug('socket error', targetHost, socket.socketId, error);
         if (sockets[socket.socketId]) {
           delete sockets[socket.socketId];
         }
       });
-    
+
       try {
         debug('connecting remotely', socket.socketId, targetPort, rpcPeer.hostName, targetHost);
         const result = await rpcPeer.methods.connectSocket({
@@ -137,7 +137,7 @@ function initListeners(hsyncClient) {
         });
         debug('connect result', result);
         socket.peerConnected = true;
-        dataQueue.forEach(sendData);      
+        dataQueue.forEach(sendData);
       } catch (e) {
         debugError('cant connect remotely', targetHost, targetPort, e);
         if (sockets[socket.socketId]) {
@@ -157,8 +157,7 @@ function initListeners(hsyncClient) {
             sockets[sk].end();
             delete sockets[sk];
           }
-        }
-        catch(e) {
+        } catch (e) {
           debug('error closing socket', e);
         }
       });
@@ -189,8 +188,3 @@ function initListeners(hsyncClient) {
     getSocketListeners,
   };
 }
-
-module.exports = { 
-  initListeners,
-  setNet,
-};

package/lib/socket-map.js

@@ -1,4 +1,7 @@
-const debug = require('debug')('hsync:socket-map');
+import createDebug from 'debug';
+
+const debug = createDebug('hsync:socket-map');
+
 const sockets = {};
 
 function handleSocketPacket(packet) {
@@ -13,7 +16,4 @@ function handleSocketPacket(packet) {
   }
 }
 
-module.exports = {
-  sockets,
-  handleSocketPacket,
-};
+export { sockets, handleSocketPacket };

package/lib/socket-relays.js

@@ -1,22 +1,24 @@
-const debug = require('debug')('hsync:relay');
-const debugError = require('debug')('hsync:error');
-const { sockets } = require('./socket-map');
+import createDebug from 'debug';
+import { sockets } from './socket-map.js';
+
+const debug = createDebug('hsync:relay');
+const debugError = createDebug('hsync:error');
 
 debugError.color = 1;
 
 let net;
 
-function setNet(netImpl) {
+export function setNet(netImpl) {
   net = netImpl;
 }
 
-function initRelays(hsyncClient) {
+export function initRelays(hsyncClient) {
   const cachedRelays = {};
 
   function getSocketRelays() {
     const hKeys = Object.keys(cachedRelays);
     debug('getSocketListeners', hKeys);
-    let retVal = hKeys.map((hk) => {
+    const retVal = hKeys.map((hk) => {
       const l = cachedRelays[hk];
       return {
         port: l.port,
@@ -58,7 +60,7 @@ function initRelays(hsyncClient) {
       sockets[socketId] = socket;
       socket.connect(relay.targetPort, relay.targetHost, () => {
         debug(`CONNECTED TO LOCAL SERVER`, socket.socketId, socket.hostName, port);
-        resolve({socketId, targetHost: relay.targetHost, targetPort: relay.targetPort});
+        resolve({ socketId, targetHost: relay.targetHost, targetPort: relay.targetPort });
       });
 
       socket.on('data', async (data) => {
@@ -74,7 +76,7 @@ function initRelays(hsyncClient) {
         debug(`LOCAL CONNECTION CLOSED`, socket.socketId);
         if (sockets[socket.socketId]) {
           try {
-            await peer.notifiers.closeListenerSocket({socketId});
+            await peer.notifiers.closeListenerSocket({ socketId });
           } catch (e) {
             debug('error closing socket', e);
           }
@@ -87,12 +89,10 @@ function initRelays(hsyncClient) {
         delete sockets[socket.socketId];
         reject(e);
       });
-    
     });
-
   }
 
-  function addSocketRelay({whitelist, blacklist, port, targetPort, targetHost}) {
+  function addSocketRelay({ whitelist, blacklist, port, targetPort, targetHost }) {
     targetPort = targetPort || port;
     targetHost = targetHost || 'localhost';
     debug('creating relay', whitelist, blacklist, port, targetPort, targetHost);
@@ -112,7 +112,7 @@ function initRelays(hsyncClient) {
   hsyncClient.addSocketRelay = addSocketRelay;
   hsyncClient.getSocketRelays = getSocketRelays;
   hsyncClient.connectSocket = connectSocket;
-  
+
   return {
     // receiveListenerData,
     getSocketRelays,
@@ -120,8 +120,3 @@ function initRelays(hsyncClient) {
     addSocketRelay,
   };
 }
-
-module.exports = {
-  initRelays,
-  setNet,
-};

package/lib/web-handler.js

@@ -1,16 +1,17 @@
-const debug = require('debug')('hsync:web');
-const debugError = require('debug')('hsync:error');
+import createDebug from 'debug';
+
+const debug = createDebug('hsync:web');
+const debugError = createDebug('hsync:error');
 
 debugError.color = 1;
 
 let net;
 
-function setNet(netImpl) {
+export function setNet(netImpl) {
   net = netImpl;
 }
 
-function createWebHandler({myHostName, localHost, port, mqConn}) {
-
+export function createWebHandler({ myHostName, localHost, port, mqConn }) {
   const sockets = {};
 
   function handleWebRequest(hostName, socketId, action, message) {
@@ -39,7 +40,7 @@ function createWebHandler({myHostName, localHost, port, mqConn}) {
           } else {
             debug(`→ ${socket.socketId}`, data.length, '↑');
           }
-          
+
           mqConn.publish(`reply/${myHostName}/${socketId}`, data);
         });
         socket.on('close', () => {
@@ -62,7 +63,6 @@ function createWebHandler({myHostName, localHost, port, mqConn}) {
       debug('←', socketId, message.length);
       socket.write(message);
     }
-
   }
 
   function end() {
@@ -71,8 +71,7 @@ function createWebHandler({myHostName, localHost, port, mqConn}) {
       try {
         sockets[sk].end();
         delete sockets[sk];
-      }
-      catch(e) {
+      } catch (e) {
         debug('error closing socket', e);
       }
     });
@@ -84,8 +83,3 @@ function createWebHandler({myHostName, localHost, port, mqConn}) {
     end,
   };
 }
-
-module.exports = { 
-  createWebHandler,
-  setNet,
-};