hsync 0.30.2 → 0.32.0

package/dist/hsync.min.js.LICENSE.txt

@@ -5,7 +5,17 @@
  * @license  MIT
  */
 
-/*! For license information please see mqtt.browser.js.LICENSE.txt */
+/*! Bundled license information:
+
+@jspm/core/nodelibs/browser/chunk-DtuTasat.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+@babel/runtime/helpers/regenerator.js:
+  (*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE *)
+*/
 
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 

package/eslint.config.js

@@ -0,0 +1,26 @@
+import js from '@eslint/js';
+import prettierConfig from 'eslint-config-prettier';
+import globals from 'globals';
+
+export default [
+  { ignores: ['node_modules/**', 'dist/**'] },
+  js.configs.recommended,
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      globals: { ...globals.node, ...globals.browser },
+    },
+    rules: {
+      'no-unused-vars': [
+        'warn',
+        { argsIgnorePattern: '^_', varsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' },
+      ],
+      'no-console': 'off',
+      'prefer-const': 'error',
+      'no-var': 'error',
+    },
+  },
+  prettierConfig,
+];

package/hsync-web.js

@@ -1,21 +1,23 @@
-const mqtt = require('precompiled-mqtt');
-const buffer = require('buffer');
-const net = require('net-web');
-const { createHsync, setNet, setMqtt } = require('./connection');
-const { setRTC } = require('./lib/peers');
-const rtc = require('./lib/rtc-web');
-const config = require('./config');
-
+import mqtt from 'mqtt';
+import { Buffer } from 'buffer';
+import net from 'net-web';
+import { createHsync, setNet, setMqtt } from './connection.js';
+import { setRTC } from './lib/peers.js';
+import rtc from './lib/rtc-web.js';
+import config from './config.js';
 
 // TODO need to make this work with web/service workers
-window.Buffer = buffer.Buffer;
+if (typeof window !== 'undefined') {
+  window.Buffer = Buffer;
+}
+globalThis.Buffer = Buffer;
 
 setRTC(rtc);
 setNet(net);
 setMqtt(mqtt);
 
 async function dynamicConnect(configObj = { useLocalStorage: true }) {
-  const fullConfig = {...config, ...configObj};
+  const fullConfig = { ...config, ...configObj };
   fullConfig.dynamicHost = fullConfig.dynamicHost || fullConfig.defaultDynamicHost;
   if (fullConfig.net) {
     setNet(fullConfig.net);
@@ -25,16 +27,16 @@ async function dynamicConnect(configObj = { useLocalStorage: true }) {
     const localConfigStr = localStorage.getItem('hsyncConfig');
     if (localConfigStr) {
       const localConfig = JSON.parse(localConfigStr);
-      if ((Date.now() - localConfig.created) < (localConfig.timeout * 0.66)) {
+      if (Date.now() - localConfig.created < localConfig.timeout * 0.66) {
         fullConfig.hsyncSecret = localConfig.hsyncSecret;
         fullConfig.hsyncServer = localConfig.hsyncServer;
       } else {
         localStorage.removeItem('hsyncConfig');
       }
     }
-  
+
     con = await createHsync(fullConfig);
-  
+
     if (!fullConfig.hsyncSecret) {
       const storeConfig = {
         hsyncSecret: con.hsyncSecret,
@@ -51,15 +53,13 @@ async function dynamicConnect(configObj = { useLocalStorage: true }) {
   con = await createHsync(fullConfig);
 
   return con;
-  
 }
 
 function createConnection(configObj = {}) {
-  const fullConfig = {...config, ...configObj};
+  const fullConfig = { ...config, ...configObj };
   return createHsync(fullConfig);
 }
 
-
 const hsync = globalThis.hsync || {
   createConnection,
   dynamicConnect,
@@ -68,4 +68,5 @@ const hsync = globalThis.hsync || {
 };
 globalThis.hsync = hsync;
 
-module.exports = hsync;
+export default hsync;
+export { createConnection, dynamicConnect, config };

package/hsync.js

@@ -1,10 +1,12 @@
-const net = require('net');
-const mqtt = require('mqtt');
-const debugError = require('debug')('errors');
-const { createHsync, setNet, setMqtt } = require('./connection');
-const config = require('./config');
-const { setRTC } = require('./lib/peers');
-const rtc = require('./lib/rtc-node');
+import net from 'net';
+import mqtt from 'mqtt';
+import createDebug from 'debug';
+import { createHsync, setNet, setMqtt } from './connection.js';
+import config from './config.js';
+import { setRTC } from './lib/peers.js';
+import rtc from './lib/rtc-node.js';
+
+const debugError = createDebug('errors');
 
 setRTC(rtc);
 setNet(net);
@@ -13,28 +15,22 @@ setMqtt(mqtt);
 process.on('unhandledRejection', (reason, p) => {
   debugError(reason, 'Unhandled Rejection at Promise', p, reason.stack, p.stack);
 });
-process.on('uncaughtException', err => {
+process.on('uncaughtException', (err) => {
   debugError(err, 'Uncaught Exception thrown', err.stack);
 });
 
 async function dynamicConnect(configObj = {}) {
-  const fullConfig = {...config, ...configObj};
-  let con;
+  const fullConfig = { ...config, ...configObj };
 
   fullConfig.dynamicHost = fullConfig.dynamicHost || fullConfig.defaultDynamicHost;
-  con = await createHsync(fullConfig);
+  const con = await createHsync(fullConfig);
 
   return con;
 }
 
 function createConnection(configObj = {}) {
-  const fullConfig = {...config, ...configObj};
+  const fullConfig = { ...config, ...configObj };
   return createHsync(fullConfig);
 }
 
-module.exports = {
-  createConnection,
-  dynamicConnect,
-  config,
-};
-
+export { createConnection, dynamicConnect, config };

package/index.js

@@ -1,5 +1,5 @@
-const config = require('./config');
-const { createConnection } = require('./hsync');
+import config from './config.js';
+import { createConnection } from './hsync.js';
 
 const [defaultCon] = config.connections;
 if (!defaultCon.hsyncServer && !defaultCon.dynamicHost) {
@@ -7,5 +7,5 @@ if (!defaultCon.hsyncServer && !defaultCon.dynamicHost) {
 }
 
 config.connections.forEach((conConfig) => {
-  const con = createConnection(conConfig);
+  createConnection(conConfig);
 });

package/lib/fetch.js

@@ -1,5 +1,3 @@
-const fetch = require('isomorphic-fetch');
-
 function getContent(res) {
   const contentType = res.headers.get('content-type');
   if (contentType.startsWith('application/json')) {
@@ -30,7 +28,7 @@ function apiFetch(path, options = {}) {
   }
   if (options.query) {
     if (Object.keys(options.query).length) {
-      qs = `?${(new URLSearchParams(options.query)).toString()}`;
+      qs = `?${new URLSearchParams(options.query).toString()}`;
     }
   }
   Object.assign(options, { credentials: 'include' });
@@ -53,4 +51,4 @@ apiFetch.del = (path, body = {}) => {
   return apiFetch(path, { method: 'DELETE', body });
 };
 
-module.exports = apiFetch;
+export default apiFetch;

package/lib/peers.js

@@ -1,18 +1,19 @@
-const rawr = require('rawr');
-const b64id = require('b64id');
-const debug = require('debug')('hsync:peers');
-const EventEmitter = require('events').EventEmitter;
-const buffer = require('buffer');
-const mqttPacket = require('mqtt-packet-web');
+import rawr from 'rawr';
+import b64id from 'b64id';
+import createDebug from 'debug';
+import { EventEmitter } from 'events';
+import { Buffer } from 'buffer';
+import mqttPacket from 'mqtt-packet';
+import { handleSocketPacket } from './socket-map.js';
+import fetch from './fetch.js';
 
-globalThis.Buffer = buffer.Buffer;
+const debug = createDebug('hsync:peers');
 
-const { handleSocketPacket } = require('./socket-map');
-const fetch = require('./fetch');
+globalThis.Buffer = Buffer;
 
 function createPacket(topic, payload) {
-  let payloadStr = payload;
-  const packet =  mqttPacket.generate({
+  const payloadStr = payload;
+  const packet = mqttPacket.generate({
     qos: 0,
     cmd: 'publish',
     topic,
@@ -30,22 +31,21 @@ function parsePacket(packet) {
   });
 }
 
-
 let rtc;
 
-function setRTC(rtcImpl) {
+export function setRTC(rtcImpl) {
   rtc = rtcImpl;
 }
 
-function initPeers(hsyncClient) {
+export function initPeers(hsyncClient) {
   const cachedPeers = {};
   const peerLib = new EventEmitter();
   function getRPCPeer(options = {}) {
-    const { hostName, temporary, timeout = 10000, hsyncClient } = options;
+    const { hostName, temporary, timeout = 10000 } = options;
     let peer = cachedPeers[hostName];
     if (!peer) {
       debug('CREATING peer', hostName);
-      peer = createRPCPeer({hostName, hsyncClient: this, timeout});
+      peer = createRPCPeer({ hostName, hsyncClient: this, timeout });
       peerLib.emit('peerCreated', peer);
       peer.myAuth = b64id.generateId();
       if (temporary) {
@@ -55,7 +55,7 @@ function initPeers(hsyncClient) {
     }
     return peer;
   }
-  
+
   function createRPCPeer(options = {}) {
     const { hostName, timeout = 10000, useRTC = true } = options;
     if (!hostName) {
@@ -66,18 +66,24 @@ function initPeers(hsyncClient) {
     }
     const myAuth = b64id.generateId();
     const transport = new EventEmitter();
-    const peer = rawr({transport, methods: Object.assign({}, hsyncClient.peerMethods), timeout, idGenerator: b64id.generateId});
+    const peer = rawr({
+      transport,
+      methods: Object.assign({}, hsyncClient.peerMethods),
+      timeout,
+      idGenerator: b64id.generateId,
+    });
     debug('createRPCPeer rawr', peer);
-    
+
     peer.hostName = hostName;
     peer.rtcEvents = new EventEmitter();
     peer.localMethods = Object.assign({}, hsyncClient.peerMethods);
     peer.sockets = {};
-  
+
     peer.localMethods.rtcSignal = async (peerInfo, signal) => {
       debug('rtcSignal', signal.type);
-      try{
-        if (signal.type === 'offer') { // && !peer.rtcCon && !signal.alreadySent) {
+      try {
+        if (signal.type === 'offer') {
+          // && !peer.rtcCon && !signal.alreadySent) {
           peer.rtcStatus = 'connecting';
           await rtc.answerPeer(peer, signal);
         } else if (signal.type === 'answer') {
@@ -87,10 +93,10 @@ function initPeers(hsyncClient) {
         debug('error handling rtcSignal', e, signal);
         return e.message;
       }
-      
+
       return `rtcSignal ${signal.type} handled ok`;
-    }
-  
+    };
+
     peer.rtcEvents.on('packet', async (packet) => {
       debug('↓ on packet', packet);
       let toParse = packet;
@@ -99,7 +105,7 @@ function initPeers(hsyncClient) {
           toParse = await packet.arrayBuffer();
         }
         const msg = await parsePacket(toParse);
-        const [p1, p2, p3] = msg.topic.split('/');
+        const [p1] = msg.topic.split('/');
         if (p1 === 'rpc') {
           const rpcMsg = JSON.parse(msg.payload.toString());
           debug('↓ peer RTC rpc', rpcMsg);
@@ -125,7 +131,7 @@ function initPeers(hsyncClient) {
         debug('bad packet', e, packet);
       }
     });
-  
+
     peer.rtcEvents.on('dcOpen', () => {
       debug(peer.answerer ? 'answerer' : 'offerer', 'dcOpen');
       peer.packAndSend = (topic, payload) => {
@@ -134,16 +140,16 @@ function initPeers(hsyncClient) {
           debug('sending test packet', packet);
         }
         peer.rtcSend(packet);
-      }
+      };
       // firefox is weird about the first bit of data, so send a test packet
       peer.packAndSend('test', 'test');
     });
-  
+
     peer.rtcEvents.on('closed', () => {
       peer.dcOpen = false;
       delete peer.packAndSend;
       debug('rtc closed');
-      for (s in peer.sockets) {
+      for (const s in peer.sockets) {
         try {
           debug('closing socket', s);
           peer.sockets[s].destroy();
@@ -153,12 +159,12 @@ function initPeers(hsyncClient) {
         }
       }
     });
-  
+
     peer.rtcEvents.on('disconnected', () => {
       peer.dcOpen = false;
       delete peer.packAndSend;
       debug('rtc disconnected');
-      for (s in peer.sockets) {
+      for (const s in peer.sockets) {
         try {
           debug('closing socket', s);
           peer.sockets[s].destroy();
@@ -168,26 +174,26 @@ function initPeers(hsyncClient) {
         }
       }
     });
-  
+
     peer.connectRTC = async () => {
       debug('connectRTC');
       peer.rtcStatus = 'connecting';
       peer.rtcEvents.emit('connecting');
-      return new Promise(async (resolve, reject) => {
-        try {
-          const offer = await rtc.offerPeer(peer);
-          debug('offer', offer);
+      try {
+        const offer = await rtc.offerPeer(peer);
+        debug('offer', offer);
+        return new Promise((resolve) => {
           peer.rtcEvents.once('dcOpen', () => {
             peer.rtcStatus = 'connected';
             debug('offerer dcOpen!');
             resolve(offer);
           });
-        } catch (e) {
-          debug('error connecting to rtc', e);
-          peer.rtcStatus = 'error';
-          reject(e);
-        }
-      });
+        });
+      } catch (e) {
+        debug('error connecting to rtc', e);
+        peer.rtcStatus = 'error';
+        throw e;
+      }
     };
 
     peer.sendJSONMsg = (msg) => {
@@ -200,7 +206,7 @@ function initPeers(hsyncClient) {
       const payload = JSON.stringify(msg);
       peer.packAndSend('jsonMsg', payload);
     };
-  
+
     transport.send = async (msg) => {
       const fullMsg = {
         msg,
@@ -208,21 +214,21 @@ function initPeers(hsyncClient) {
         toHost: hostName,
         fromHost: hsyncClient.webUrl,
       };
-  
+
       debug('↑ peer rpc', peer.dcOpen ? 'RTC' : 'REST', `${hostName}/_hs/rpc`, msg.method);
-  
+
       let msgObj = msg;
       if (typeof msg !== 'object') {
         try {
           msgObj = JSON.parse(msg);
-        } catch (e) {
-          msgObj = {error: 'invalid JSON'};
+        } catch (_e) {
+          msgObj = { error: 'invalid JSON' };
         }
       }
 
       // sometimes it takes a while for RTC do detect a disconnect
       // do not rtcSignal messages over the RTC connection
-      if (peer.dcOpen && (msgObj.method !== 'rtcSignal')) {
+      if (peer.dcOpen && msgObj.method !== 'rtcSignal') {
         let payload = msg;
         if (typeof msg === 'object') {
           payload = JSON.stringify(payload);
@@ -231,32 +237,32 @@ function initPeers(hsyncClient) {
         peer.rtcSend(packet);
         return;
       }
-  
+
       try {
         const path = `${hostName}/_hs/rpc`;
         debug('fetching', path, fullMsg, useRTC);
         const result = await fetch.post(path, fullMsg);
         debug('fetch result', result);
         if (msg.id) {
-          transport.receiveData({id: msg.id, result, jsonrpc: msg.jsonrpc});
+          transport.receiveData({ id: msg.id, result, jsonrpc: msg.jsonrpc });
         }
-      } catch(e) {
+      } catch (e) {
         debug('error sending peer RPC request', e);
-        if (msg.id) { // only send error if it's a request, not a notification
+        if (msg.id) {
+          // only send error if it's a request, not a notification
           transport.receiveData({
             id: msg.id,
             error: e.message,
             method: msg.method,
-            jsonrpc: msg.jsonrpc
+            jsonrpc: msg.jsonrpc,
           });
         }
       }
-    
     };
-  
+
     transport.receiveData = (msg) => {
       debug('↓ transport.receiveData', msg);
-      if(typeof msg === 'string') {
+      if (typeof msg === 'string') {
         msg = JSON.parse(msg);
       }
       debug('↓ peer rpc receivedData', msg);
@@ -267,16 +273,16 @@ function initPeers(hsyncClient) {
       transport.emit('rpc', msg);
       // debug('transport emitted', msg);
     };
-  
+
     peer.myAuth = myAuth;
     peer.hostName = hostName;
     return peer;
   }
-  
+
   function createServerPeer(hsyncClient, methods) {
     const transport = new EventEmitter();
     transport.send = (msg) => {
-      if(typeof msg === 'object') {
+      if (typeof msg === 'object') {
         msg = JSON.stringify(msg);
       }
       const topic = `srpc/${hsyncClient.myHostName}`;
@@ -284,19 +290,19 @@ function initPeers(hsyncClient) {
       hsyncClient.mqConn.publish(topic, Buffer.from(msg));
     };
     transport.receiveData = (msg) => {
-      if(msg) {
+      if (msg) {
         msg = JSON.parse(msg);
       }
       debug('↓ server rpc inbound', msg);
       transport.emit('rpc', msg);
     };
-    const peer = rawr({transport, methods, timeout: 5000});
+    const peer = rawr({ transport, methods, timeout: 5000 });
     return peer;
   }
 
   hsyncClient.cachedPeers = cachedPeers;
   hsyncClient.getRPCPeer = getRPCPeer;
-  hsyncClient.createServerPeer  = createServerPeer;
+  hsyncClient.createServerPeer = createServerPeer;
   hsyncClient.createRPCPeer = createRPCPeer;
 
   peerLib.cachedPeers = cachedPeers;
@@ -306,8 +312,3 @@ function initPeers(hsyncClient) {
 
   return peerLib;
 }
-
-module.exports = {
-  initPeers,
-  setRTC,
-};