@leofcoin/peernet 1.1.2 → 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-3c5482a7.js → index-3d3f56ca.js}

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

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

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

package/exports/browser/{peernet-5b33f983.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-3c5482a7.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-c9724c0b.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-4b8a9fee.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-5b33f983.js';
+export { P as default } from './peernet-f349ddaf.js';
 import './value-157ab062.js';