@leofcoin/peernet 0.11.20 → 0.11.23

package/dist/browser/peernet.js

@@ -287,11 +287,8 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
-const messageQue = {};
-
 class Peer {
   #connection
-  #ready = false
   #connecting = false
   #connected = false
   #channelReady = false
@@ -304,10 +301,14 @@ class Peer {
   #remoteStreams = []
   #pendingCandidates = []
   #senderMap = new Map()
+  #messageQue = []
+  #chunksQue = {}
   #iceCompleteTimer
   #channel
   #peerId
-  #chunkSize = 16384
+  #chunkSize = 16 * 1024 // 16384
+  #queRunning = false
+  #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024
 
   get connection() {
     return this.#connection
@@ -366,7 +367,7 @@ class Peer {
      return new Promise((resolve, reject) => {
        const splitMessage = () => {
          const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
-         offset += offset + this.#chunkSize;
+         offset += this.#chunkSize;
          chunks.push(chunk);
          if (offset < size) return splitMessage()
          else resolve({chunks, size});
@@ -376,27 +377,53 @@ class Peer {
      })
    }
 
-   async send(message, id) {
-     const { chunks, size } = await this.splitMessage(message);
+   async #runQue() {
+     this.#queRunning = true;
+     if (this.#messageQue.length > 0 && this.channel.bufferedAmount + this.#messageQue[0]?.length < this.#MAX_BUFFERED_AMOUNT) {
+       const message = this.#messageQue.shift();
+
+       switch (this.channel?.readyState) {
+         case 'open':
+          await this.channel.send(message);
+          if (this.#messageQue.length > 0) return this.#runQue()
+          else this.#queRunning = false;
+         break;
+         case 'closed':
+         case 'closing':
+          this.#messageQue = [];
+          this.#queRunning = false;
+          debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+         break;
+         case undefined:
+          this.#messageQue = [];
+          this.#queRunning = false;
+          debug(`trying to send before a channel is created`);
+         break;
+       }
+
+
+     } else {
+       return setTimeout(() => this.#runQue(), 50)
+     }
+   }
+
+   #trySend({ size, id, chunks }) {
      let offset = 0;
+
      for (const chunk of chunks) {
-        const start = offset;
-        const end = offset + chunk.length;
-        const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
-        switch (this.channel?.readyState) {
-          case 'open':
-           this.bw.up += message.length || message.byteLength;
-           this.channel.send(message);
-          break;
-          case 'closed':
-          case 'closing':
-           debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-          break;
-          case undefined:
-          debug(`trying to send before a channel is created`);
-          break;
-        }
-      }
+       const start = offset;
+       const end = offset + chunk.length;
+
+       const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+       this.#messageQue.push(message);
+     }
+
+     if (!this.queRunning) return this.#runQue()
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message);
+     return this.#trySend({ size, id, chunks })
    }
 
    request(data) {
@@ -482,20 +509,22 @@ class Peer {
      message = JSON.parse(new TextDecoder().decode(message.data));
      // allow sharding (multiple peers share data)
      pubsub.publish('peernet:shard', message);
-     if (!messageQue[message.id]) messageQue[message.id] = [];
+     const { id } = message;
 
-     if (message.size > messageQue[message.id].length || message.size === messageQue[message.id].length) {
+     if (!this.#chunksQue[id]) this.#chunksQue[id] = [];
+
+     if (message.size > this.#chunksQue[id].length || message.size === this.#chunksQue[id].length) {
        for (const value of Object.values(message.chunk)) {
-         messageQue[message.id].push(value);
+         this.#chunksQue[id].push(value);
        }
      }
 
-     if (message.size === messageQue[message.id].length) {
-       pubsub.publish('peer:data', {id: message.id, data: new Uint8Array(Object.values(messageQue[message.id]))});
-       delete messageQue[message.id];
+     if (message.size === this.#chunksQue[id].length) {
+       const data = new Uint8Array(Object.values(this.#chunksQue[id]));
+       delete this.#chunksQue[id];
+       pubsub.publish('peer:data', { id, data });
      }
      this.bw.down += message.byteLength || message.length;
-
    }
 
    _sendMessage(message) {

package/dist/commonjs/{http-62c5b155.js → http-547d8100.js}

@@ -10,7 +10,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var PubSub__default = /*#__PURE__*/_interopDefaultLegacy(PubSub);
 var Koa__default = /*#__PURE__*/_interopDefaultLegacy(Koa);
 
-var version = "0.11.19";
+var version = "0.11.22";
 
 var api$1 = {
   version: ({send}) => send({client: '@peernet/api/http', version}),

package/dist/commonjs/peernet.js

@@ -285,11 +285,8 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
-const messageQue = {};
-
 class Peer {
   #connection
-  #ready = false
   #connecting = false
   #connected = false
   #channelReady = false
@@ -302,10 +299,14 @@ class Peer {
   #remoteStreams = []
   #pendingCandidates = []
   #senderMap = new Map()
+  #messageQue = []
+  #chunksQue = {}
   #iceCompleteTimer
   #channel
   #peerId
-  #chunkSize = 16384
+  #chunkSize = 16 * 1024 // 16384
+  #queRunning = false
+  #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024
 
   get connection() {
     return this.#connection
@@ -364,7 +365,7 @@ class Peer {
      return new Promise((resolve, reject) => {
        const splitMessage = () => {
          const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
-         offset += offset + this.#chunkSize;
+         offset += this.#chunkSize;
          chunks.push(chunk);
          if (offset < size) return splitMessage()
          else resolve({chunks, size});
@@ -374,27 +375,53 @@ class Peer {
      })
    }
 
-   async send(message, id) {
-     const { chunks, size } = await this.splitMessage(message);
+   async #runQue() {
+     this.#queRunning = true;
+     if (this.#messageQue.length > 0 && this.channel.bufferedAmount + this.#messageQue[0]?.length < this.#MAX_BUFFERED_AMOUNT) {
+       const message = this.#messageQue.shift();
+
+       switch (this.channel?.readyState) {
+         case 'open':
+          await this.channel.send(message);
+          if (this.#messageQue.length > 0) return this.#runQue()
+          else this.#queRunning = false;
+         break;
+         case 'closed':
+         case 'closing':
+          this.#messageQue = [];
+          this.#queRunning = false;
+          debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+         break;
+         case undefined:
+          this.#messageQue = [];
+          this.#queRunning = false;
+          debug(`trying to send before a channel is created`);
+         break;
+       }
+
+
+     } else {
+       return setTimeout(() => this.#runQue(), 50)
+     }
+   }
+
+   #trySend({ size, id, chunks }) {
      let offset = 0;
+
      for (const chunk of chunks) {
-        const start = offset;
-        const end = offset + chunk.length;
-        const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
-        switch (this.channel?.readyState) {
-          case 'open':
-           this.bw.up += message.length || message.byteLength;
-           this.channel.send(message);
-          break;
-          case 'closed':
-          case 'closing':
-           debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-          break;
-          case undefined:
-          debug(`trying to send before a channel is created`);
-          break;
-        }
-      }
+       const start = offset;
+       const end = offset + chunk.length;
+
+       const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+       this.#messageQue.push(message);
+     }
+
+     if (!this.queRunning) return this.#runQue()
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message);
+     return this.#trySend({ size, id, chunks })
    }
 
    request(data) {
@@ -480,20 +507,22 @@ class Peer {
      message = JSON.parse(new TextDecoder().decode(message.data));
      // allow sharding (multiple peers share data)
      pubsub.publish('peernet:shard', message);
-     if (!messageQue[message.id]) messageQue[message.id] = [];
+     const { id } = message;
 
-     if (message.size > messageQue[message.id].length || message.size === messageQue[message.id].length) {
+     if (!this.#chunksQue[id]) this.#chunksQue[id] = [];
+
+     if (message.size > this.#chunksQue[id].length || message.size === this.#chunksQue[id].length) {
        for (const value of Object.values(message.chunk)) {
-         messageQue[message.id].push(value);
+         this.#chunksQue[id].push(value);
        }
      }
 
-     if (message.size === messageQue[message.id].length) {
-       pubsub.publish('peer:data', {id: message.id, data: new Uint8Array(Object.values(messageQue[message.id]))});
-       delete messageQue[message.id];
+     if (message.size === this.#chunksQue[id].length) {
+       const data = new Uint8Array(Object.values(this.#chunksQue[id]));
+       delete this.#chunksQue[id];
+       pubsub.publish('peer:data', { id, data });
      }
      this.bw.down += message.byteLength || message.length;
-
    }
 
    _sendMessage(message) {
@@ -1850,7 +1879,7 @@ class Peernet {
 					protocol: 'peernet-v0.1.0', host: '127.0.0.1', port: options.port
 				});
 			} else {
-				const http = await Promise.resolve().then(function () { return require('./http-62c5b155.js'); });
+				const http = await Promise.resolve().then(function () { return require('./http-547d8100.js'); });
 	      if (environment !== 'browser') http.default(options);
 	    }
 

package/dist/module/peernet.js

@@ -241,11 +241,8 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
-const messageQue = {};
-
 class Peer {
   #connection
-  #ready = false
   #connecting = false
   #connected = false
   #channelReady = false
@@ -258,10 +255,14 @@ class Peer {
   #remoteStreams = []
   #pendingCandidates = []
   #senderMap = new Map()
+  #messageQue = []
+  #chunksQue = {}
   #iceCompleteTimer
   #channel
   #peerId
-  #chunkSize = 16384
+  #chunkSize = 16 * 1024 // 16384
+  #queRunning = false
+  #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024
 
   get connection() {
     return this.#connection
@@ -320,7 +321,7 @@ class Peer {
      return new Promise((resolve, reject) => {
        const splitMessage = () => {
          const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
-         offset += offset + this.#chunkSize;
+         offset += this.#chunkSize;
          chunks.push(chunk);
          if (offset < size) return splitMessage()
          else resolve({chunks, size});
@@ -330,27 +331,53 @@ class Peer {
      })
    }
 
-   async send(message, id) {
-     const { chunks, size } = await this.splitMessage(message);
+   async #runQue() {
+     this.#queRunning = true;
+     if (this.#messageQue.length > 0 && this.channel.bufferedAmount + this.#messageQue[0]?.length < this.#MAX_BUFFERED_AMOUNT) {
+       const message = this.#messageQue.shift();
+
+       switch (this.channel?.readyState) {
+         case 'open':
+          await this.channel.send(message);
+          if (this.#messageQue.length > 0) return this.#runQue()
+          else this.#queRunning = false;
+         break;
+         case 'closed':
+         case 'closing':
+          this.#messageQue = [];
+          this.#queRunning = false;
+          debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+         break;
+         case undefined:
+          this.#messageQue = [];
+          this.#queRunning = false;
+          debug(`trying to send before a channel is created`);
+         break;
+       }
+
+
+     } else {
+       return setTimeout(() => this.#runQue(), 50)
+     }
+   }
+
+   #trySend({ size, id, chunks }) {
      let offset = 0;
+
      for (const chunk of chunks) {
-        const start = offset;
-        const end = offset + chunk.length;
-        const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
-        switch (this.channel?.readyState) {
-          case 'open':
-           this.bw.up += message.length || message.byteLength;
-           this.channel.send(message);
-          break;
-          case 'closed':
-          case 'closing':
-           debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-          break;
-          case undefined:
-          debug(`trying to send before a channel is created`);
-          break;
-        }
-      }
+       const start = offset;
+       const end = offset + chunk.length;
+
+       const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+       this.#messageQue.push(message);
+     }
+
+     if (!this.queRunning) return this.#runQue()
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message);
+     return this.#trySend({ size, id, chunks })
    }
 
    request(data) {
@@ -436,20 +463,22 @@ class Peer {
      message = JSON.parse(new TextDecoder().decode(message.data));
      // allow sharding (multiple peers share data)
      pubsub.publish('peernet:shard', message);
-     if (!messageQue[message.id]) messageQue[message.id] = [];
+     const { id } = message;
 
-     if (message.size > messageQue[message.id].length || message.size === messageQue[message.id].length) {
+     if (!this.#chunksQue[id]) this.#chunksQue[id] = [];
+
+     if (message.size > this.#chunksQue[id].length || message.size === this.#chunksQue[id].length) {
        for (const value of Object.values(message.chunk)) {
-         messageQue[message.id].push(value);
+         this.#chunksQue[id].push(value);
        }
      }
 
-     if (message.size === messageQue[message.id].length) {
-       pubsub.publish('peer:data', {id: message.id, data: new Uint8Array(Object.values(messageQue[message.id]))});
-       delete messageQue[message.id];
+     if (message.size === this.#chunksQue[id].length) {
+       const data = new Uint8Array(Object.values(this.#chunksQue[id]));
+       delete this.#chunksQue[id];
+       pubsub.publish('peer:data', { id, data });
      }
      this.bw.down += message.byteLength || message.length;
-
    }
 
    _sendMessage(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.11.20",
+  "version": "0.11.23",
   "description": "",
   "main": "dist/commonjs/peernet.js",
   "module": "dist/module/peernet.js",
@@ -25,7 +25,7 @@
   "dependencies": {
     "@leofcoin/generate-account": "^1.0.2",
     "@leofcoin/multi-wallet": "^2.1.2",
-    "@leofcoin/peernet-swarm": "^0.1.21",
+    "@leofcoin/peernet-swarm": "^0.2.1",
     "@leofcoin/storage": "^2.3.0",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",