@leofcoin/peernet 1.1.1 → 1.1.2

package/exports/browser/client-ff436f6a.js

@@ -1,682 +0,0 @@
-import { L as LittlePubSub } from './peernet-4aaa825c.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;
-    #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;
-    }
-    /**
-     * @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();
-            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 wrtc.RTCPeerConnection({ iceServers });
-            this.#connection.onnegotiationneeded = async () => {
-                try {
-                    this.#makingOffer = true;
-                    await this.#connection.setLocalDescription();
-                    this._sendMessage({ description: this.#connection.localDescription });
-                    this.#makingOffer = false;
-                }
-                catch (err) {
-                    console.error(err);
-                }
-            };
-            this.#connection.oniceconnectionstatechange = () => {
-                if (this.#connection.iceConnectionState === "failed") {
-                    this.#connection.restartIce();
-                }
-            };
-            this.#connection.onconnectionstatechange = () => {
-                switch (this.#connection.connectionState) {
-                    case "new":
-                    case "checking":
-                        this.state = "connecting";
-                        break;
-                    case "connected":
-                        this.state = 'connected';
-                        break;
-                    case "closed":
-                    case "disconnected":
-                        this.state = "disconnected";
-                        break;
-                    case "failed":
-                        this.state = 'failed';
-                        break;
-                    default:
-                        this.state = this.#connection.connectionState;
-                        break;
-                }
-                if (this.state === 'connected') {
-                    this.#connection.ondatachannel = (message) => {
-                        message.channel.onopen = () => {
-                            this.#connected = true;
-                            //  debug(`peer:connected ${this}`)
-                            pubsub.publish('peer:connected', this);
-                        };
-                        message.channel.onclose = () => this.close.bind(this);
-                        message.channel.onmessage = (message) => {
-                            this._handleMessage(this.id, message);
-                        };
-                        this.#channel = message.channel;
-                    };
-                    if (this.initiator) {
-                        this.#channel = this.#connection.createDataChannel('messageChannel');
-                        this.#channel.onopen = () => {
-                            this.#connected = true;
-                            pubsub.publish('peer:connected', this);
-                            // this.#channel.send('hi')
-                        };
-                        this.#channel.onclose = () => this.close.bind(this);
-                        this.#channel.onmessage = (message) => {
-                            this._handleMessage(this.peerId, message);
-                        };
-                    }
-                }
-            };
-            this.#connection.onicecandidate = ({ candidate }) => {
-                if (candidate) {
-                    this.address = candidate.address;
-                    this.port = candidate.port;
-                    this.protocol = candidate.protocol;
-                    this.ipFamily = this.address.includes('::') ? 'ipv6' : 'ipv4';
-                    this._sendMessage({ candidate });
-                }
-            };
-            // if (this.initiator) this.#connection.onnegotiationneeded = () => {
-            // console.log('create offer');
-        }
-        catch (e) {
-            console.log(e);
-        }
-        return this;
-    }
-    _handleMessage(peerId, message) {
-        //  debug(`incoming message from ${peerId}`)
-        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.options.channelName,
-                ...message
-            } });
-    }
-    async _in(message, data) {
-        let ignoreOffer = false;
-        try {
-            if (message.description) {
-                const offerCollision = message.description.type === "offer" &&
-                    (this.#makingOffer || this.#connection.signalingState !== "stable");
-                ignoreOffer = this.initiator && offerCollision;
-                if (ignoreOffer) {
-                    return;
-                }
-                await this.#connection.setRemoteDescription(message.description);
-                if (message.description.type === "offer") {
-                    await this.#connection.setLocalDescription();
-                    this._sendMessage({ description: this.#connection.localDescription });
-                }
-            }
-            else if (message.candidate) {
-                try {
-                    await this.#connection.addIceCandidate(message.candidate);
-                }
-                catch (err) {
-                    if (!ignoreOffer) {
-                        throw err;
-                    }
-                }
-            }
-        }
-        catch (e) {
-            pubsub.publish('connection closed', this);
-            console.log(e);
-            this.close();
-        }
-    }
-    close() {
-        //  debug(`closing ${this.peerId}`)
-        this.#connected = false;
-        this.#channel?.close();
-        this.#connection?.close();
-        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 };