@leofcoin/peernet 1.1.3 → 1.1.5

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 };