@leofcoin/peernet 1.1.3 → 1.1.4

package/exports/browser/client-111c93a3.js

@@ -0,0 +1,612 @@
+import { L as LittlePubSub } from './peernet-f349ddaf.js';
+import './value-157ab062.js';
+
+var clientApi = _pubsub => {
+
+  const subscribe = (topic, cb) => {
+    _pubsub.subscribe(topic, cb);
+  };
+
+  const unsubscribe = (topic, cb) => {
+    _pubsub.unsubscribe(topic, cb);
+  };
+
+  const publish = (topic, value) => {
+    _pubsub.publish(topic, value);
+  };
+
+  const connectionState = (state) => {
+    switch (state) {
+      case 0:
+        return 'connecting'
+      case 1:
+        return 'open'
+      case 2:
+        return 'closing'
+      case 3:
+        return 'closed'
+    }
+  };
+  /**
+   * @param {string} type
+   * @param {string} name
+   * @param {object} params
+   */
+  const request = (client, request) => {
+    return new Promise((resolve, reject) => {
+
+      const state = connectionState(client.readyState);
+      if (state !== 'open') return reject(`coudn't send request to ${client.id}, no open connection found.`)
+
+      request.id = Math.random().toString(36).slice(-12);
+      const handler = result => {
+        if (result && result.error) return reject(result.error)
+        resolve({result, id: request.id, handler});
+        unsubscribe(request.id, handler);
+      };
+      subscribe(request.id, handler);
+      send(client, request);
+    });
+  };
+
+  const send = async (client, request) => {
+    return client.send(JSON.stringify(request))
+  };
+
+  const pubsub = client => {
+    return {
+      publish: (topic = 'pubsub', value) => {
+        return send(client, {url: 'pubsub', params: { topic, value }})
+      },
+      subscribe: (topic = 'pubsub', cb) => {
+        subscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, subscribe: true }})
+      },
+      unsubscribe: (topic = 'pubsub', cb) => {
+        unsubscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, unsubscribe: true }})
+      },
+      subscribers: _pubsub.subscribers
+    }
+  };
+
+  const server = (client) => {
+    return {
+      uptime: async () => {
+        try {
+          const { result, id, handler } = await request(client, {url: 'uptime'});
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      ping: async () => {
+        try {
+          const now = new Date().getTime();
+          const { result, id, handler } = await request(client, {url: 'ping'});
+          unsubscribe(id, handler);
+          return (Number(result) - now)
+        } catch (e) {
+          throw e
+        }
+      }
+    }
+  };
+
+  const peernet = (client) => {
+    return {
+      join: async (params) => {
+        try {
+          params.join = true;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      leave: async (params) => {
+        try {
+          params.join = false;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      }
+    }
+  };
+
+  return { send, request, pubsub, server, subscribe, unsubscribe, publish, peernet, connectionState }
+};
+
+if (!globalThis.PubSub) globalThis.PubSub = LittlePubSub;
+if (!globalThis.pubsub) globalThis.pubsub = new LittlePubSub({verbose: false});
+
+const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry: true, timeout: 10_000, times: 10 }) => {
+  let { retry, timeout, times } = options;
+  if (retry === undefined) retry = true;
+  if (timeout === undefined) timeout = 10_000;  
+  if (times === undefined) times = 10;
+
+  const api = clientApi(pubsub);
+
+  let tries = 0;
+
+  const onerror = error => {
+    if (pubsub.subscribers['error']) {
+      pubsub.publish('error', error);
+    } else {
+      console.error(error);
+    }
+  };
+
+  const onmessage = message => {
+    const {value, url, status, id} = JSON.parse(message.data.toString());
+    const publisher = id ? id : url;
+    if (status === 200) {
+      pubsub.publish(publisher, value);
+    } else {
+      pubsub.publish(publisher, {error: value});
+    }
+  };
+
+  const clientConnection = client => {
+    const startTime = new Date().getTime();
+    return {
+      client,
+      request: async req => {
+        const { result, id, handler } = await api.request(client, req);
+        pubsub.unsubscribe(id, handler);
+        return result
+      },
+      send: req => api.send(client, req),
+      subscribe: api.subscribe,
+      unsubscribe: api.unsubscribe,
+      subscribers: api.subscribers,
+      publish: api.publish,
+      pubsub: api.pubsub(client),
+      uptime: () => {
+        const now = new Date().getTime();
+        return (now - startTime)
+      },
+      peernet: api.peernet(client),
+      server: api.server(client),
+      connectionState: () => api.connectionState(client.readyState),
+      close: exit => {
+        // client.onclose = message => {
+        //   if (exit) process.exit()
+        // }
+        client.close();
+      }
+    }
+  };
+
+  return new Promise(async (resolve, reject) => {
+    const init = async () => {
+      let ws;
+      if (typeof process === 'object' && !globalThis.WebSocket) {
+        ws = (await import('./browser-e1cd4e67.js').then(function (n) { return n.b; })).default;
+        ws = ws.w3cwebsocket;
+      } else {
+        ws = WebSocket;
+      }
+      const client = new ws(url, protocols);
+
+      client.onmessage = onmessage;
+      client.onerror = onerror;
+      
+      client.onopen = () => {
+        tries = 0;
+        resolve(clientConnection(client));
+      };
+      client.onclose = message => {
+        tries++;
+        if (!retry) return reject(options)
+        if (tries > times) {
+          console.log(`${protocols} Client Closed`);
+          console.error(`could not connect to - ${url}/`);
+          return resolve(clientConnection(client))
+        }
+        if (message.code === 1006) {
+          console.log(`Retrying in ${timeout} ms`);
+          setTimeout(() => {
+            return init();
+          }, timeout);
+        }
+      };
+    };
+    return init();
+  });
+};
+
+class Peer {
+    #connection;
+    #connected = false;
+    #messageQue = [];
+    #chunksQue = {};
+    #channel;
+    id;
+    #peerId;
+    #channelName;
+    #chunkSize = 16 * 1024; // 16384
+    #queRunning = false;
+    #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024;
+    initiator = false;
+    state;
+    #makingOffer = false;
+    get connection() {
+        return this.#connection;
+    }
+    get connected() {
+        return this.#connected;
+    }
+    get readyState() {
+        return this.#channel?.readyState;
+    }
+    get channelName() {
+        return this.#channelName;
+    }
+    /**
+     * @params {Object} options
+     * @params {string} options.channelName - this peerid : otherpeer id
+    */
+    constructor(options = {}) {
+        this._in = this._in.bind(this);
+        this.offerOptions = options.offerOptions;
+        this.initiator = options.initiator;
+        this.streams = options.streams;
+        this.socketClient = options.socketClient;
+        this.id = options.id;
+        this.to = options.to;
+        this.bw = {
+            up: 0,
+            down: 0
+        };
+        this.#channelName = options.channelName;
+        this.#peerId = options.peerId;
+        this.options = options;
+        return this.#init();
+    }
+    get peerId() {
+        return this.#peerId;
+    }
+    set socketClient(value) {
+        // this.socketClient?.pubsub.unsubscribe('signal', this._in)
+        this._socketClient = value;
+        this._socketClient.pubsub.subscribe('signal', this._in);
+    }
+    get socketClient() {
+        return this._socketClient;
+    }
+    splitMessage(message) {
+        const chunks = [];
+        message = pako.deflate(message);
+        const size = message.byteLength || message.length;
+        let offset = 0;
+        return new Promise((resolve, reject) => {
+            const splitMessage = () => {
+                const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
+                offset += this.#chunkSize;
+                chunks.push(chunk);
+                if (offset < size)
+                    return splitMessage();
+                else
+                    resolve({ chunks, size });
+            };
+            splitMessage();
+        });
+    }
+    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();
+            await this.#connection.send(message);
+            if (this.#messageQue.length > 0)
+                return this.#runQue();
+            // 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 }));
+            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) {
+        return new Promise((resolve, reject) => {
+            const id = Math.random().toString(36).slice(-12);
+            const _onData = message => {
+                if (message.id === id) {
+                    resolve(message.data);
+                    pubsub.unsubscribe(`peer:data`, _onData);
+                }
+            };
+            pubsub.subscribe(`peer:data`, _onData);
+            // cleanup subscriptions
+            // setTimeout(() => {
+            //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
+            // }, 5000);
+            this.send(data, id);
+        });
+    }
+    async #init() {
+        try {
+            if (!globalThis.pako) {
+                const importee = await import('./pako.esm-aa674ebf.js');
+                globalThis.pako = importee.default;
+            }
+            const iceServers = [{
+                    urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
+                }, {
+                    urls: "stun:openrelay.metered.ca:80",
+                }, {
+                    urls: "turn:openrelay.metered.ca:443",
+                    username: "openrelayproject",
+                    credential: "openrelayproject",
+                }, {
+                    urls: "turn:openrelay.metered.ca:443?transport=tcp",
+                    username: "openrelayproject",
+                    credential: "openrelayproject",
+                }];
+            const importee = await import('./simple-peer-743c19fe.js');
+            const SimplePeer = importee.default;
+            this.#connection = new SimplePeer({
+                channelName: this.channelName,
+                initiator: this.initiator,
+                peerId: this.peerId,
+                wrtc: globalThis.wrtc,
+                config: {
+                    iceServers
+                }
+            });
+            this.#connection.on('signal', signal => {
+                this._sendMessage({ signal });
+            });
+            this.#connection.on('connected', () => {
+                this.#connected = true;
+                pubsub.publish('peer:connected', this);
+            });
+            this.#connection.on('close', () => {
+                this.close();
+            });
+            this.#connection.on('data', data => {
+                this._handleMessage(data);
+            });
+            this.#connection.on('error', (e) => {
+                pubsub.publish('connection closed', this);
+                console.log(e);
+                this.close();
+            });
+        }
+        catch (e) {
+            console.log(e);
+        }
+        return this;
+    }
+    _handleMessage(message) {
+        console.log({ message });
+        message = JSON.parse(new TextDecoder().decode(message.data));
+        // allow sharding (multiple peers share data)
+        pubsub.publish('peernet:shard', message);
+        const { id } = message;
+        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)) {
+                this.#chunksQue[id].push(value);
+            }
+        }
+        if (message.size === this.#chunksQue[id].length) {
+            let data = new Uint8Array(Object.values(this.#chunksQue[id]));
+            delete this.#chunksQue[id];
+            data = pako.inflate(data);
+            pubsub.publish('peer:data', { id, data, from: this.peerId });
+        }
+        this.bw.down += message.byteLength || message.length;
+    }
+    _sendMessage(message) {
+        this.socketClient.send({ url: 'signal', params: {
+                to: this.to,
+                from: this.id,
+                channelName: this.channelName,
+                ...message
+            } });
+    }
+    async _in(message, data) {
+        if (message.signal)
+            return this.#connection.signal(message.signal);
+    }
+    close() {
+        //  debug(`closing ${this.peerId}`)
+        this.#connected = false;
+        // this.#channel?.close()
+        // this.#connection?.exit()
+        this.socketClient.pubsub.unsubscribe('signal', this._in);
+    }
+}
+
+class Client {
+    #peerConnection;
+    #connections = {};
+    #stars = {};
+    id;
+    networkVersion;
+    starsConfig;
+    socketClient;
+    get connections() {
+        return { ...this.#connections };
+    }
+    get peers() {
+        return Object.entries(this.#connections);
+    }
+    constructor(id, networkVersion = 'peach', stars = ['wss://peach.leofcoin.org']) {
+        this.id = id || Math.random().toString(36).slice(-12);
+        this.peerJoined = this.peerJoined.bind(this);
+        this.peerLeft = this.peerLeft.bind(this);
+        this.starLeft = this.starLeft.bind(this);
+        this.starJoined = this.starJoined.bind(this);
+        this.networkVersion = networkVersion;
+        this._init(stars);
+    }
+    async _init(stars = []) {
+        this.starsConfig = stars;
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-10ffabe1.js').then(function (n) { return n.b; })).default;
+        else
+            globalThis.wrtc = {
+                RTCPeerConnection,
+                RTCSessionDescription,
+                RTCIceCandidate
+            };
+        for (const star of stars) {
+            try {
+                this.socketClient = await socketRequestClient(star, this.networkVersion);
+                const id = await this.socketClient.request({ url: 'id', params: { from: this.id } });
+                this.socketClient.peerId = id;
+                this.#stars[id] = this.socketClient;
+            }
+            catch (e) {
+                if (stars.indexOf(star) === stars.length - 1 && !this.socketClient)
+                    throw new Error(`No star available to connect`);
+            }
+        }
+        this.setupListeners();
+        const peers = await this.socketClient.peernet.join({ id: this.id });
+        for (const id of peers) {
+            if (id !== this.id && !this.#connections[id])
+                this.#connections[id] = await new Peer({ channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
+        }
+        pubsub.subscribe('connection closed', (peer) => {
+            this.removePeer(peer.peerId);
+            setTimeout(() => {
+                this.peerJoined(peer.peerId);
+            }, 1000);
+        });
+    }
+    setupListeners() {
+        this.socketClient.subscribe('peer:joined', this.peerJoined);
+        this.socketClient.subscribe('peer:left', this.peerLeft);
+        this.socketClient.subscribe('star:left', this.starLeft);
+    }
+    starJoined(id) {
+        if (this.#stars[id]) {
+            this.#stars[id].close();
+            delete this.#stars[id];
+        }
+        console.log(`star ${id} joined`);
+    }
+    async starLeft(id) {
+        if (this.#stars[id]) {
+            this.#stars[id].close();
+            delete this.#stars[id];
+        }
+        if (this.socketClient?.peerId === id) {
+            this.socketClient.unsubscribe('peer:joined', this.peerJoined);
+            this.socketClient.unsubscribe('peer:left', this.peerLeft);
+            this.socketClient.unsubscribe('star:left', this.starLeft);
+            this.socketClient.close();
+            this.socketClient = undefined;
+            for (const star of this.starsConfig) {
+                try {
+                    this.socketClient = await socketRequestClient(star, this.networkVersion);
+                    if (!this.socketClient?.client?._connection.connected)
+                        return;
+                    const id = await this.socketClient.request({ url: 'id', params: { from: this.id } });
+                    this.#stars[id] = this.socketClient;
+                    this.socketClient.peerId = id;
+                    const peers = await this.socketClient.peernet.join({ id: this.id });
+                    this.setupListeners();
+                    for (const id of peers) {
+                        if (id !== this.id) {
+                            if (!this.#connections[id]) {
+                                if (id !== this.id)
+                                    this.#connections[id] = await new Peer({ channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    console.log(e);
+                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 && !this.socketClient)
+                        throw new Error(`No star available to connect`);
+                }
+            }
+        }
+        globalThis.debug(`star ${id} left`);
+    }
+    peerLeft(peer) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].close();
+            delete this.#connections[id];
+        }
+        globalThis.debug(`peer ${id} left`);
+    }
+    async peerJoined(peer, signal) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            if (this.#connections[id].connected)
+                this.#connections[id].close();
+            delete this.#connections[id];
+        }
+        // RTCPeerConnection
+        this.#connections[id] = await new Peer({ initiator: true, channelName: `${this.id}:${id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
+        globalThis.debug(`peer ${id} joined`);
+    }
+    removePeer(peer) {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].connected && this.#connections[id].close();
+            delete this.#connections[id];
+        }
+        globalThis.debug(`peer ${id} removed`);
+    }
+    async close() {
+        this.socketClient.unsubscribe('peer:joined', this.peerJoined);
+        this.socketClient.unsubscribe('peer:left', this.peerLeft);
+        this.socketClient.unsubscribe('star:left', this.starLeft);
+        const promises = [
+            Object.values(this.#connections).map(connection => connection.close()),
+            Object.values(this.#stars).map(connection => connection.close()),
+            this.socketClient.close()
+        ];
+        return Promise.allSettled(promises);
+    }
+}
+
+export { Client as default };

package/exports/browser/{index-4d744cf5.js → index-3d3f56ca.js}

@@ -1,4 +1,4 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-7b231fd6.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-f349ddaf.js';
 import './value-157ab062.js';
 
 /**

package/exports/browser/{messages-4a94eee0.js → messages-af41e873.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-7b231fd6.js';
+import { F as FormatInterface } from './peernet-f349ddaf.js';
 import './value-157ab062.js';
 
 var proto$b = {

package/exports/browser/{peernet-7b231fd6.js → peernet-f349ddaf.js}

@@ -2600,6 +2600,10 @@ var index = {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 function getAugmentedNamespace(n) {
   if (n.__esModule) return n;
   var f = n.default;
@@ -16082,7 +16086,7 @@ class Identity {
             globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-4d744cf5.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-3d3f56ca.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -16252,7 +16256,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-4a94eee0.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-af41e873.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -16319,7 +16323,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-238e0eb2.js');
+        const importee = await import('./client-111c93a3.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -16754,4 +16758,4 @@ class Peernet {
 }
 globalThis.Peernet = Peernet;
 
-export { FormatInterface as F, LittlePubSub as L, MultiWallet as M, Peernet as P, base58$1 as b, commonjsGlobal as c, encrypt as e, inherits_browserExports as i, require$$3 as r };
+export { FormatInterface as F, LittlePubSub as L, MultiWallet as M, Peernet as P, base58$1 as b, commonjsGlobal as c, encrypt as e, getDefaultExportFromCjs as g, inherits_browserExports as i, require$$3 as r };

package/exports/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-7b231fd6.js';
+export { P as default } from './peernet-f349ddaf.js';
 import './value-157ab062.js';

package/exports/browser/{client-238e0eb2.js → simple-peer-743c19fe.js}

@@ -1,229 +1,6 @@
-import { L as LittlePubSub, c as commonjsGlobal, r as require$$3, i as inherits_browserExports } from './peernet-7b231fd6.js';
+import { c as commonjsGlobal, r as require$$3$1, i as inherits_browserExports, g as getDefaultExportFromCjs } from './peernet-f349ddaf.js';
 import './value-157ab062.js';
 
-var clientApi = _pubsub => {
-
-  const subscribe = (topic, cb) => {
-    _pubsub.subscribe(topic, cb);
-  };
-
-  const unsubscribe = (topic, cb) => {
-    _pubsub.unsubscribe(topic, cb);
-  };
-
-  const publish = (topic, value) => {
-    _pubsub.publish(topic, value);
-  };
-
-  const connectionState = (state) => {
-    switch (state) {
-      case 0:
-        return 'connecting'
-      case 1:
-        return 'open'
-      case 2:
-        return 'closing'
-      case 3:
-        return 'closed'
-    }
-  };
-  /**
-   * @param {string} type
-   * @param {string} name
-   * @param {object} params
-   */
-  const request = (client, request) => {
-    return new Promise((resolve, reject) => {
-
-      const state = connectionState(client.readyState);
-      if (state !== 'open') return reject(`coudn't send request to ${client.id}, no open connection found.`)
-
-      request.id = Math.random().toString(36).slice(-12);
-      const handler = result => {
-        if (result && result.error) return reject(result.error)
-        resolve({result, id: request.id, handler});
-        unsubscribe(request.id, handler);
-      };
-      subscribe(request.id, handler);
-      send(client, request);
-    });
-  };
-
-  const send = async (client, request) => {
-    return client.send(JSON.stringify(request))
-  };
-
-  const pubsub = client => {
-    return {
-      publish: (topic = 'pubsub', value) => {
-        return send(client, {url: 'pubsub', params: { topic, value }})
-      },
-      subscribe: (topic = 'pubsub', cb) => {
-        subscribe(topic, cb);
-        return send(client, {url: 'pubsub', params: { topic, subscribe: true }})
-      },
-      unsubscribe: (topic = 'pubsub', cb) => {
-        unsubscribe(topic, cb);
-        return send(client, {url: 'pubsub', params: { topic, unsubscribe: true }})
-      },
-      subscribers: _pubsub.subscribers
-    }
-  };
-
-  const server = (client) => {
-    return {
-      uptime: async () => {
-        try {
-          const { result, id, handler } = await request(client, {url: 'uptime'});
-          unsubscribe(id, handler);
-          return result
-        } catch (e) {
-          throw e
-        }
-      },
-      ping: async () => {
-        try {
-          const now = new Date().getTime();
-          const { result, id, handler } = await request(client, {url: 'ping'});
-          unsubscribe(id, handler);
-          return (Number(result) - now)
-        } catch (e) {
-          throw e
-        }
-      }
-    }
-  };
-
-  const peernet = (client) => {
-    return {
-      join: async (params) => {
-        try {
-          params.join = true;
-          const requested = { url: 'peernet', params };
-          const { result, id, handler } = await request(client, requested);
-          unsubscribe(id, handler);
-          return result
-        } catch (e) {
-          throw e
-        }
-      },
-      leave: async (params) => {
-        try {
-          params.join = false;
-          const requested = { url: 'peernet', params };
-          const { result, id, handler } = await request(client, requested);
-          unsubscribe(id, handler);
-          return result
-        } catch (e) {
-          throw e
-        }
-      }
-    }
-  };
-
-  return { send, request, pubsub, server, subscribe, unsubscribe, publish, peernet, connectionState }
-};
-
-if (!globalThis.PubSub) globalThis.PubSub = LittlePubSub;
-if (!globalThis.pubsub) globalThis.pubsub = new LittlePubSub({verbose: false});
-
-const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry: true, timeout: 10_000, times: 10 }) => {
-  let { retry, timeout, times } = options;
-  if (retry === undefined) retry = true;
-  if (timeout === undefined) timeout = 10_000;  
-  if (times === undefined) times = 10;
-
-  const api = clientApi(pubsub);
-
-  let tries = 0;
-
-  const onerror = error => {
-    if (pubsub.subscribers['error']) {
-      pubsub.publish('error', error);
-    } else {
-      console.error(error);
-    }
-  };
-
-  const onmessage = message => {
-    const {value, url, status, id} = JSON.parse(message.data.toString());
-    const publisher = id ? id : url;
-    if (status === 200) {
-      pubsub.publish(publisher, value);
-    } else {
-      pubsub.publish(publisher, {error: value});
-    }
-  };
-
-  const clientConnection = client => {
-    const startTime = new Date().getTime();
-    return {
-      client,
-      request: async req => {
-        const { result, id, handler } = await api.request(client, req);
-        pubsub.unsubscribe(id, handler);
-        return result
-      },
-      send: req => api.send(client, req),
-      subscribe: api.subscribe,
-      unsubscribe: api.unsubscribe,
-      subscribers: api.subscribers,
-      publish: api.publish,
-      pubsub: api.pubsub(client),
-      uptime: () => {
-        const now = new Date().getTime();
-        return (now - startTime)
-      },
-      peernet: api.peernet(client),
-      server: api.server(client),
-      connectionState: () => api.connectionState(client.readyState),
-      close: exit => {
-        // client.onclose = message => {
-        //   if (exit) process.exit()
-        // }
-        client.close();
-      }
-    }
-  };
-
-  return new Promise(async (resolve, reject) => {
-    const init = async () => {
-      let ws;
-      if (typeof process === 'object' && !globalThis.WebSocket) {
-        ws = (await import('./browser-e1cd4e67.js').then(function (n) { return n.b; })).default;
-        ws = ws.w3cwebsocket;
-      } else {
-        ws = WebSocket;
-      }
-      const client = new ws(url, protocols);
-
-      client.onmessage = onmessage;
-      client.onerror = onerror;
-      
-      client.onopen = () => {
-        tries = 0;
-        resolve(clientConnection(client));
-      };
-      client.onclose = message => {
-        tries++;
-        if (!retry) return reject(options)
-        if (tries > times) {
-          console.log(`${protocols} Client Closed`);
-          console.error(`could not connect to - ${url}/`);
-          return resolve(clientConnection(client))
-        }
-        if (message.code === 1006) {
-          console.log(`Retrying in ${timeout} ms`);
-          setTimeout(() => {
-            return init();
-          }, timeout);
-        }
-      };
-    };
-    return init();
-  });
-};
-
 var browserExports$1 = {};
 var browser$2 = {
   get exports(){ return browserExports$1; },
@@ -947,6 +724,8 @@ var common = setup;
 	};
 } (browser$2, browserExports$1));
 
+var require$$0 = browserExports$1;
+
 // originally pulled out of simple-peer
 
 var getBrowserRtc = function getBrowserRTC () {
@@ -3944,7 +3723,7 @@ function requireBuffer_list () {
 	function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 	const _require = buffer,
 	  Buffer = _require.Buffer;
-	const _require2 = require$$3,
+	const _require2 = require$$3$1,
 	  inspect = _require2.inspect;
 	const custom = inspect && inspect.custom || 'inspect';
 	function copyBuffer(src, target, offset) {
@@ -5732,7 +5511,7 @@ function require_stream_readable () {
 	}
 
 	/*<replacement>*/
-	const debugUtil = require$$3;
+	const debugUtil = require$$3$1;
 	let debug;
 	if (debugUtil && debugUtil.debuglog) {
 	  debug = debugUtil.debuglog('stream');
@@ -6939,6 +6718,8 @@ var pipeline_1 = pipeline;
 	exports.pipeline = pipeline_1;
 } (readableBrowser, readableBrowserExports));
 
+var require$$3 = /*@__PURE__*/getDefaultExportFromCjs(readableBrowserExports);
+
 /*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
 let promise;
@@ -7020,10 +6801,10 @@ var errCode$1 = createError;
 
 /*! simple-peer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
-const debug = browserExports$1('simple-peer');
+const debug = require$$0('simple-peer');
 const getBrowserRTC = getBrowserRtc;
 const randombytes = browserExports;
-const stream = readableBrowserExports;
+const stream = require$$3;
 const queueMicrotask$1 = queueMicrotask_1; // TODO: remove when Node 10 is not supported
 const errCode = errCode$1;
 const { Buffer } = buffer;
@@ -7046,7 +6827,7 @@ function warn (message) {
  * Duplex stream.
  * @param {Object} opts
  */
-let Peer$1 = class Peer extends stream.Duplex {
+class Peer extends stream.Duplex {
   constructor (opts) {
     opts = Object.assign({
       allowHalfOpen: false
@@ -8047,16 +7828,16 @@ let Peer$1 = class Peer extends stream.Duplex {
     args[0] = '[' + this._id + '] ' + args[0];
     debug.apply(null, args);
   }
-};
+}
 
-Peer$1.WEBRTC_SUPPORT = !!getBrowserRTC();
+Peer.WEBRTC_SUPPORT = !!getBrowserRTC();
 
 /**
  * Expose peer and data channel config for overriding all Peer
  * instances. Otherwise, just set opts.config or opts.channelConfig
  * when constructing a Peer.
  */
-Peer$1.config = {
+Peer.config = {
   iceServers: [
     {
       urls: [
@@ -8068,391 +7849,8 @@ Peer$1.config = {
   sdpSemantics: 'unified-plan'
 };
 
-Peer$1.channelConfig = {};
-
-var simplePeer = Peer$1;
-
-class Peer {
-    #connection;
-    #connected = false;
-    #messageQue = [];
-    #chunksQue = {};
-    #channel;
-    id;
-    #peerId;
-    #channelName;
-    #chunkSize = 16 * 1024; // 16384
-    #queRunning = false;
-    #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024;
-    initiator = false;
-    state;
-    #makingOffer = false;
-    get connection() {
-        return this.#connection;
-    }
-    get connected() {
-        return this.#connected;
-    }
-    get readyState() {
-        return this.#channel?.readyState;
-    }
-    get channelName() {
-        return this.#channelName;
-    }
-    /**
-     * @params {Object} options
-     * @params {string} options.channelName - this peerid : otherpeer id
-    */
-    constructor(options = {}) {
-        this._in = this._in.bind(this);
-        this.offerOptions = options.offerOptions;
-        this.initiator = options.initiator;
-        this.streams = options.streams;
-        this.socketClient = options.socketClient;
-        this.id = options.id;
-        this.to = options.to;
-        this.bw = {
-            up: 0,
-            down: 0
-        };
-        this.#channelName = options.channelName;
-        this.#peerId = options.peerId;
-        this.options = options;
-        return this.#init();
-    }
-    get peerId() {
-        return this.#peerId;
-    }
-    set socketClient(value) {
-        // this.socketClient?.pubsub.unsubscribe('signal', this._in)
-        this._socketClient = value;
-        this._socketClient.pubsub.subscribe('signal', this._in);
-    }
-    get socketClient() {
-        return this._socketClient;
-    }
-    splitMessage(message) {
-        const chunks = [];
-        message = pako.deflate(message);
-        const size = message.byteLength || message.length;
-        let offset = 0;
-        return new Promise((resolve, reject) => {
-            const splitMessage = () => {
-                const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
-                offset += this.#chunkSize;
-                chunks.push(chunk);
-                if (offset < size)
-                    return splitMessage();
-                else
-                    resolve({ chunks, size });
-            };
-            splitMessage();
-        });
-    }
-    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();
-            await this.#connection.send(message);
-            if (this.#messageQue.length > 0)
-                return this.#runQue();
-            // 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 }));
-            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) {
-        return new Promise((resolve, reject) => {
-            const id = Math.random().toString(36).slice(-12);
-            const _onData = message => {
-                if (message.id === id) {
-                    resolve(message.data);
-                    pubsub.unsubscribe(`peer:data`, _onData);
-                }
-            };
-            pubsub.subscribe(`peer:data`, _onData);
-            // cleanup subscriptions
-            // setTimeout(() => {
-            //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
-            // }, 5000);
-            this.send(data, id);
-        });
-    }
-    async #init() {
-        try {
-            if (!globalThis.pako) {
-                const importee = await import('./pako.esm-aa674ebf.js');
-                globalThis.pako = importee.default;
-            }
-            const iceServers = [{
-                    urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
-                }, {
-                    urls: "stun:openrelay.metered.ca:80",
-                }, {
-                    urls: "turn:openrelay.metered.ca:443",
-                    username: "openrelayproject",
-                    credential: "openrelayproject",
-                }, {
-                    urls: "turn:openrelay.metered.ca:443?transport=tcp",
-                    username: "openrelayproject",
-                    credential: "openrelayproject",
-                }];
-            this.#connection = new simplePeer({
-                channelName: this.channelName,
-                initiator: this.initiator,
-                peerId: this.peerId,
-                wrtc: globalThis.wrtc,
-                config: {
-                    iceServers
-                }
-            });
-            this.#connection.on('signal', signal => {
-                this._sendMessage({ signal });
-            });
-            this.#connection.on('connected', () => {
-                this.#connected = true;
-                pubsub.publish('peer:connected', this);
-            });
-            this.#connection.on('close', () => {
-                this.close();
-            });
-            this.#connection.on('data', data => {
-                this._handleMessage(data);
-            });
-            this.#connection.on('error', (e) => {
-                pubsub.publish('connection closed', this);
-                console.log(e);
-                this.close();
-            });
-        }
-        catch (e) {
-            console.log(e);
-        }
-        return this;
-    }
-    _handleMessage(message) {
-        console.log({ message });
-        message = JSON.parse(new TextDecoder().decode(message.data));
-        // allow sharding (multiple peers share data)
-        pubsub.publish('peernet:shard', message);
-        const { id } = message;
-        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)) {
-                this.#chunksQue[id].push(value);
-            }
-        }
-        if (message.size === this.#chunksQue[id].length) {
-            let data = new Uint8Array(Object.values(this.#chunksQue[id]));
-            delete this.#chunksQue[id];
-            data = pako.inflate(data);
-            pubsub.publish('peer:data', { id, data, from: this.peerId });
-        }
-        this.bw.down += message.byteLength || message.length;
-    }
-    _sendMessage(message) {
-        this.socketClient.send({ url: 'signal', params: {
-                to: this.to,
-                from: this.id,
-                channelName: this.channelName,
-                ...message
-            } });
-    }
-    async _in(message, data) {
-        if (message.signal)
-            return this.#connection.signal(message.signal);
-    }
-    close() {
-        //  debug(`closing ${this.peerId}`)
-        this.#connected = false;
-        // this.#channel?.close()
-        // this.#connection?.exit()
-        this.socketClient.pubsub.unsubscribe('signal', this._in);
-    }
-}
+Peer.channelConfig = {};
 
-class Client {
-    #peerConnection;
-    #connections = {};
-    #stars = {};
-    id;
-    networkVersion;
-    starsConfig;
-    socketClient;
-    get connections() {
-        return { ...this.#connections };
-    }
-    get peers() {
-        return Object.entries(this.#connections);
-    }
-    constructor(id, networkVersion = 'peach', stars = ['wss://peach.leofcoin.org']) {
-        this.id = id || Math.random().toString(36).slice(-12);
-        this.peerJoined = this.peerJoined.bind(this);
-        this.peerLeft = this.peerLeft.bind(this);
-        this.starLeft = this.starLeft.bind(this);
-        this.starJoined = this.starJoined.bind(this);
-        this.networkVersion = networkVersion;
-        this._init(stars);
-    }
-    async _init(stars = []) {
-        this.starsConfig = stars;
-        // reconnectJob()
-        if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-10ffabe1.js').then(function (n) { return n.b; })).default;
-        else
-            globalThis.wrtc = {
-                RTCPeerConnection,
-                RTCSessionDescription,
-                RTCIceCandidate
-            };
-        for (const star of stars) {
-            try {
-                this.socketClient = await socketRequestClient(star, this.networkVersion);
-                const id = await this.socketClient.request({ url: 'id', params: { from: this.id } });
-                this.socketClient.peerId = id;
-                this.#stars[id] = this.socketClient;
-            }
-            catch (e) {
-                if (stars.indexOf(star) === stars.length - 1 && !this.socketClient)
-                    throw new Error(`No star available to connect`);
-            }
-        }
-        this.setupListeners();
-        const peers = await this.socketClient.peernet.join({ id: this.id });
-        for (const id of peers) {
-            if (id !== this.id && !this.#connections[id])
-                this.#connections[id] = await new Peer({ channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
-        }
-        pubsub.subscribe('connection closed', (peer) => {
-            this.removePeer(peer.peerId);
-            setTimeout(() => {
-                this.peerJoined(peer.peerId);
-            }, 1000);
-        });
-    }
-    setupListeners() {
-        this.socketClient.subscribe('peer:joined', this.peerJoined);
-        this.socketClient.subscribe('peer:left', this.peerLeft);
-        this.socketClient.subscribe('star:left', this.starLeft);
-    }
-    starJoined(id) {
-        if (this.#stars[id]) {
-            this.#stars[id].close();
-            delete this.#stars[id];
-        }
-        console.log(`star ${id} joined`);
-    }
-    async starLeft(id) {
-        if (this.#stars[id]) {
-            this.#stars[id].close();
-            delete this.#stars[id];
-        }
-        if (this.socketClient?.peerId === id) {
-            this.socketClient.unsubscribe('peer:joined', this.peerJoined);
-            this.socketClient.unsubscribe('peer:left', this.peerLeft);
-            this.socketClient.unsubscribe('star:left', this.starLeft);
-            this.socketClient.close();
-            this.socketClient = undefined;
-            for (const star of this.starsConfig) {
-                try {
-                    this.socketClient = await socketRequestClient(star, this.networkVersion);
-                    if (!this.socketClient?.client?._connection.connected)
-                        return;
-                    const id = await this.socketClient.request({ url: 'id', params: { from: this.id } });
-                    this.#stars[id] = this.socketClient;
-                    this.socketClient.peerId = id;
-                    const peers = await this.socketClient.peernet.join({ id: this.id });
-                    this.setupListeners();
-                    for (const id of peers) {
-                        if (id !== this.id) {
-                            if (!this.#connections[id]) {
-                                if (id !== this.id)
-                                    this.#connections[id] = await new Peer({ channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    console.log(e);
-                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 && !this.socketClient)
-                        throw new Error(`No star available to connect`);
-                }
-            }
-        }
-        globalThis.debug(`star ${id} left`);
-    }
-    peerLeft(peer) {
-        const id = peer.peerId || peer;
-        if (this.#connections[id]) {
-            this.#connections[id].close();
-            delete this.#connections[id];
-        }
-        globalThis.debug(`peer ${id} left`);
-    }
-    async peerJoined(peer, signal) {
-        const id = peer.peerId || peer;
-        if (this.#connections[id]) {
-            if (this.#connections[id].connected)
-                this.#connections[id].close();
-            delete this.#connections[id];
-        }
-        // RTCPeerConnection
-        this.#connections[id] = await new Peer({ initiator: true, channelName: `${this.id}:${id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id });
-        globalThis.debug(`peer ${id} joined`);
-    }
-    removePeer(peer) {
-        const id = peer.peerId || peer;
-        if (this.#connections[id]) {
-            this.#connections[id].connected && this.#connections[id].close();
-            delete this.#connections[id];
-        }
-        globalThis.debug(`peer ${id} removed`);
-    }
-    async close() {
-        this.socketClient.unsubscribe('peer:joined', this.peerJoined);
-        this.socketClient.unsubscribe('peer:left', this.peerLeft);
-        this.socketClient.unsubscribe('star:left', this.starLeft);
-        const promises = [
-            Object.values(this.#connections).map(connection => connection.close()),
-            Object.values(this.#stars).map(connection => connection.close()),
-            this.socketClient.close()
-        ];
-        return Promise.allSettled(promises);
-    }
-}
+var simplePeer = Peer;
 
-export { Client as default };
+export { simplePeer as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "",
   "main": "src/peernet.js",
   "exports": {