@leofcoin/peernet 1.1.99 → 1.1.100

package/exports/browser/{client-BfWOZz0W.js → client-DgmVTCEc.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './peernet-BQUef8u4.js';
+import { L as LittlePubSub } from './peernet-CP4375lb.js';
 import './identity-Cn0iQbY3.js';
 import './value-C3vAp-wb.js';
 
@@ -341,16 +341,16 @@ class Peer extends SimplePeer {
     channelName;
     version;
     bw = { up: 0, down: 0 };
+    get connected() {
+        return super.connected;
+    }
     constructor(options) {
-        const { from, to, trickle, config, version } = options;
-        // Canonical initiator and channel label based on sorted IDs
-        const [a, b] = [from, to].sort();
-        const channelName = `${a}:${b}`;
-        const initiator = from === a;
+        const { from, to, initiator, trickle, config, version } = options;
+        const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
         super({
             channelName,
             initiator,
-            trickle: trickle ?? true,
+            trickle: trickle || true,
             config: { iceServers, ...config },
             wrtc: globalThis.wrtc
         });
@@ -661,7 +661,7 @@ class Client {
         }
         debug(`peer ${id} left`);
     };
-    connect(peerId, star) {
+    connect(peerId, star, initiator = true) {
         if (this.#connections[peerId]) {
             debug(`peer ${peerId} already connected`);
             return;
@@ -670,15 +670,16 @@ class Client {
             console.warn(`Star ${star} is not connected, cannot reconnect to peer ${peerId}`);
             return;
         }
-        this.#createRTCPeerConnection(peerId, star, this.version);
+        this.#createRTCPeerConnection(peerId, star, this.version, initiator);
     }
-    reconnect(peerId, star) {
+    reconnect(peerId, star, initiator = false) {
         delete this.#connections[peerId];
         debug(`reconnecting to peer ${peerId}`);
-        return this.connect(peerId, star);
+        return this.connect(peerId, star, initiator);
     }
-    #createRTCPeerConnection = (peerId, star, version) => {
+    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
         const peer = new Peer({
+            initiator: initiator,
             from: this.peerId,
             to: peerId,
             version
@@ -697,7 +698,7 @@ class Client {
             delete this.#connections[peerId];
         }
         if (this.peerId !== peerId)
-            this.#createRTCPeerConnection(peerId, star, version);
+            this.#createRTCPeerConnection(peerId, star, version, true);
         debug(`peer ${peerId} joined`);
     };
     #inComingSignal = async ({ from, signal, channelName, version }, star) => {

package/exports/browser/messages/file-link.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @extends {CodecFormat}
+ */
+export default class PeernetFileLink {
+    /**
+     * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+     */
+    constructor(data: Buffer | string | any | DataMessage);
+    get messageName(): string;
+}

package/exports/browser/messages-Bx4w-Pqo.js

@@ -0,0 +1,206 @@
+import { F as FormatInterface } from './peernet-CP4375lb.js';
+import './identity-Cn0iQbY3.js';
+import './value-C3vAp-wb.js';
+
+var proto$b = {
+    data: new Uint8Array(),
+    signature: new Uint8Array(),
+    'from?': String(),
+    'to?': String(),
+    'id?': String()
+};
+
+class PeernetMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetMessage';
+    }
+    constructor(buffer) {
+        const name = 'peernet-message';
+        super(buffer, proto$b, { name });
+    }
+}
+
+var proto$a = {
+    hash: String(),
+    'store?': String()
+};
+
+/**
+ * @example `
+   new DHTMessage(hash, store)
+   // store = optional if not set, peernet checks every store
+   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
+   message = new DHTMessage('hashmvbs124xcfd...', 'block')
+ `
+ */
+class DHTMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetDHTMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-dht';
+        super(data, proto$a, { name });
+    }
+}
+
+var proto$9 = {
+    hash: String(),
+    has: Boolean()
+};
+
+class DHTMessageResponse extends FormatInterface {
+    get messageName() {
+        return 'PeernetDHTMessageResponse';
+    }
+    constructor(data) {
+        const name = 'peernet-dht-response';
+        super(data, proto$9, { name });
+    }
+}
+
+var proto$8 = {
+    hash: String(),
+    'store?': String()
+};
+
+/**
+ * @extends {CodecFormat}
+ */
+class DataMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetDataMessage';
+    }
+    /**
+     * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+     */
+    constructor(data) {
+        super(data, proto$8, { name: 'peernet-data' });
+    }
+}
+
+var proto$7 = {
+    data: new Uint8Array(),
+    topic: new Uint8Array()
+};
+
+class PsMessage extends FormatInterface {
+    get messageName() {
+        return 'PsMessage';
+    }
+    constructor(buffer) {
+        const name = 'peernet-ps';
+        super(buffer, proto$7, { name });
+    }
+}
+
+var proto$6 = {
+    id: String()
+};
+
+class PeerMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetPeerMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-peer';
+        super(data, proto$6, { name });
+    }
+}
+
+var proto$5 = {
+    request: String(),
+    'requested?': new Uint8Array()
+};
+
+class RequestMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetRequestMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-request';
+        super(data, proto$5, { name });
+    }
+}
+
+var proto$4 = {
+    response: {}
+};
+
+class ResponseMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetResponseMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-response';
+        super(data, proto$4, { name });
+    }
+}
+
+var proto$3 = {
+    id: String()
+};
+
+class PeerMessageResponse extends FormatInterface {
+    get messageName() {
+        return 'PeernetPeerMessageResponse';
+    }
+    constructor(data) {
+        const name = 'peernet-peer-response';
+        super(data, proto$3, { name });
+    }
+}
+
+var proto$2 = {
+    hash: String(),
+    data: new Uint8Array()
+};
+
+class DataMessageResponse extends FormatInterface {
+    get messageName() {
+        return 'PeernetDataMessageResponse';
+    }
+    constructor(data) {
+        const name = 'peernet-data-response';
+        super(data, proto$2, { name });
+    }
+}
+
+var proto$1 = {
+    value: String(),
+    author: String(),
+    timestamp: Number(),
+    files: [String()]
+};
+
+class ChatMessage extends FormatInterface {
+    get messageName() {
+        return 'ChatMessage';
+    }
+    constructor(buffer) {
+        const name = 'chat-message';
+        super(buffer, proto$1, { name });
+    }
+}
+
+var proto = {
+    path: String(),
+    'content?': '',
+    'links?': []
+};
+
+/**
+ * @extends {CodecFormat}
+ */
+class PeernetFile extends FormatInterface {
+    get messageName() {
+        return 'PeernetFile';
+    }
+    /**
+     * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+     */
+    constructor(data) {
+        super(data, proto, { name: 'peernet-file' });
+    }
+}
+
+export { ChatMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PeerMessage, PeerMessageResponse, PeernetFile, PeernetMessage, PsMessage, RequestMessage, ResponseMessage };

package/exports/browser/peer-info.d.ts

@@ -0,0 +1,4 @@
+export default class PeerInfo {
+    constructor(data: any, options: any);
+    keys: string[];
+}

package/exports/browser/{peernet-BQUef8u4.js → peernet-CP4375lb.js}

@@ -7820,54 +7820,55 @@ const FormatInterface = FormatInterface$1;
 const Codec = Codec$1;
 
 const BufferToUint8Array = (data) => {
-  if (data.type === 'Buffer') {
-    data = new Uint8Array(data.data);
-  }
-  return data
+    if (data.type === 'Buffer') {
+        data = new Uint8Array(data.data);
+    }
+    return data;
 };
-
 const protoFor = (message) => {
-  const codec = new Codec(message);
-  if (!codec.name) throw new Error(`proto not found ${message}`)
-  const Proto = globalThis.peernet.protos[codec.name];
-  if (!Proto) throw new Error(`No proto defined for ${codec.name}`)
-  return new Proto(message)
+    const codec = new Codec(message);
+    if (!codec.name)
+        throw new Error(`proto not found ${message}`);
+    const Proto = globalThis.peernet.protos[codec.name];
+    if (!Proto)
+        throw new Error(`No proto defined for ${codec.name}`);
+    return new Proto(message);
 };
-
 /**
  * wether or not a peernet daemon is active
  * @return {Boolean}
  */
 const hasDaemon = async () => {
-  try {
-    let response = await fetch('http://127.0.0.1:1000/api/version');
-    response = await response.json();
-    return Boolean(response.client === '@peernet/api/http')
-  } catch (e) {
-    return false
-  }
+    try {
+        let response = await fetch('http://127.0.0.1:1000/api/version');
+        response = await response.json();
+        return Boolean(response.client === '@peernet/api/http');
+    }
+    catch (e) {
+        return false;
+    }
 };
-
 const https = () => {
-  if (!globalThis.location) return false
-  return Boolean(globalThis.location.protocol === 'https:')
+    if (!globalThis.location)
+        return false;
+    return Boolean(globalThis.location.protocol === 'https:');
 };
-
 /**
  * Get current environment
  * @return {String} current environment [node, electron, browser]
  */
 const environment = () => {
-  const _navigator = globalThis.navigator;
-  if (!_navigator) {
-    return 'node'
-  } else if (_navigator && /electron/i.test(_navigator.userAgent)) {
-    return 'electron'
-  } else {
-    return 'browser'
-  }
+    const _navigator = globalThis.navigator;
+    if (!_navigator) {
+        return 'node';
+    }
+    else if (_navigator && /electron/i.test(_navigator.userAgent)) {
+        return 'electron';
+    }
+    else {
+        return 'browser';
+    }
 };
-
 /**
  * * Get current environment
  * @return {Object} result
@@ -7875,84 +7876,84 @@ const environment = () => {
  * @property {Boolean} reult.environment Current environment
  */
 const target = async () => {
-  let daemon = false;
-  if (!https()) daemon = await hasDaemon();
-
-  return { daemon, environment: environment() }
+    let daemon = false;
+    if (!https())
+        daemon = await hasDaemon();
+    return { daemon, environment: environment() };
 };
 
 class PeerDiscovery {
-  constructor(id) {
-    this.id = id;
-  }
-
-  _getPeerId(id) {
-    if (!peernet.peerMap || (peernet.peerMap && peernet.peerMap.size === 0)) return false
-
-    for (const entry of [...peernet.peerMap.entries()]) {
-      for (const _id of entry[1]) {
-        if (_id === id) return entry[0]
-      }
+    constructor(id) {
+        this.id = id;
     }
-  }
-
-  async discover(peer) {
-    let id = this._getPeerId(peer.id);
-    if (id) return id
-    const data = await new peernet.protos['peernet-peer']({ id: this.id });
-    const node = await peernet.prepareMessage(peer.id, data.encoded);
-
-    let response = await peer.request(node.encoded);
-    response = await protoFor(response);
-    response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
-
-    id = response.decoded.id;
-    if (id === this.id) return
-
-    if (!peernet.peerMap.has(id)) peernet.peerMap.set(id, [peer.id]);
-    else {
-      const connections = peernet.peerMap.get(id);
-      if (connections.indexOf(peer.id) === -1) {
-        connections.push(peer.id);
-        peernet.peerMap.set(peer.id, connections);
-      }
+    _getPeerId(id) {
+        if (!peernet.peerMap || (peernet.peerMap && peernet.peerMap.size === 0))
+            return false;
+        for (const entry of [...peernet.peerMap.entries()]) {
+            for (const _id of entry[1]) {
+                if (_id === id)
+                    return entry[0];
+            }
+        }
     }
-    return id
-  }
-
-  async discoverHandler(message, peer) {
-    const { id, proto } = message;
-    // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
-    if (proto.name === 'peernet-peer') {
-      const from = proto.decoded.id;
-      if (from === this.id) return
-
-      if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id]);
-      else {
-        const connections = peernet.peerMap.get(from);
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id);
-          peernet.peerMap.set(from, connections);
+    async discover(peer) {
+        let id = this._getPeerId(peer.id);
+        if (id)
+            return id;
+        const data = await new peernet.protos['peernet-peer']({ id: this.id });
+        const node = await peernet.prepareMessage(peer.id, data.encoded);
+        let response = await peer.request(node.encoded);
+        response = await protoFor(response);
+        response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
+        id = response.decoded.id;
+        if (id === this.id)
+            return;
+        if (!peernet.peerMap.has(id))
+            peernet.peerMap.set(id, [peer.id]);
+        else {
+            const connections = peernet.peerMap.get(id);
+            if (connections.indexOf(peer.id) === -1) {
+                connections.push(peer.id);
+                peernet.peerMap.set(peer.id, connections);
+            }
         }
-      }
-      const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
-      const node = await peernet.prepareMessage(from, data.encoded);
-
-      peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
-    } else if (proto.name === 'peernet-peer-response') {
-      const from = proto.decoded.id;
-      if (from === this.id) return
-
-      if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id]);
-      else {
-        const connections = peernet.peerMap.get(from);
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id);
-          peernet.peerMap.set(from, connections);
+        return id;
+    }
+    async discoverHandler(message, peer) {
+        const { id, proto } = message;
+        // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
+        if (proto.name === 'peernet-peer') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
+            const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
+            const node = await peernet.prepareMessage(from, data.encoded);
+            peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
+        }
+        else if (proto.name === 'peernet-peer-response') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
         }
-      }
     }
-  }
 }
 
 /**
@@ -8054,59 +8055,57 @@ class DhtEarth {
 }
 
 class MessageHandler {
-  constructor(network) {
-    this.network = network;
-  }
-  /**
-   * hash and sign message
-   *
-   * @param {object} message
-   * @param {Buffer} message.from peer id
-   * @param {Buffer} message.to peer id
-   * @param {string} message.data Peernet message
-   * (PeernetMessage excluded) encoded as a string
-   * @return message
-   */
-  async hashAndSignMessage(message) {
-    const hash = await message.peernetHash;
-    message.decoded.signature = globalThis.identity.sign(hash.buffer);
-    return message
-  }
-
-  /**
-   * @param {String} from - peer id
-   * @param {String} to - peer id
-   * @param {String|PeernetMessage} data - data encoded message string
-   * or the messageNode itself
-   */
-  async prepareMessage(message) {
-    if (message.keys.includes('signature')) {
-      message = await this.hashAndSignMessage(message);
+    constructor(network) {
+        this.network = network;
+    }
+    /**
+     * hash and sign message
+     *
+     * @param {object} message
+     * @param {Buffer} message.from peer id
+     * @param {Buffer} message.to peer id
+     * @param {string} message.data Peernet message
+     * (PeernetMessage excluded) encoded as a string
+     * @return message
+     */
+    async hashAndSignMessage(message) {
+        const hash = await message.peernetHash;
+        message.decoded.signature = globalThis.identity.sign(hash.buffer);
+        return message;
+    }
+    /**
+     * @param {String} from - peer id
+     * @param {String} to - peer id
+     * @param {String|PeernetMessage} data - data encoded message string
+     * or the messageNode itself
+     */
+    async prepareMessage(message) {
+        if (message.keys.includes('signature')) {
+            message = await this.hashAndSignMessage(message);
+        }
+        return message;
     }
-
-    return message
-  }
 }
 
 const dataHandler = async (message) => {
-  if (!message) return
-
-  try {
-    const { data, id, from, peer } = message;
-    const proto = await protoFor(data);
-    peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from);
-  } catch (error) {
-    console.error(error);
-  }
+    if (!message)
+        return;
+    try {
+        const { data, id, from, peer } = message;
+        const proto = await protoFor(data);
+        peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from);
+    }
+    catch (error) {
+        console.error(error);
+    }
 };
 
 const dhtError = (proto) => {
-  const text = `Received proto ${proto.name} expected peernet-dht-response`;
-  return new Error(`Routing error: ${text}`)
+    const text = `Received proto ${proto.name} expected peernet-dht-response`;
+    return new Error(`Routing error: ${text}`);
 };
-
 const nothingFoundError = (hash) => {
-  return new Error(`nothing found for ${hash}`)
+    return new Error(`nothing found for ${hash}`);
 };
 
 const isBrowser = globalThis.process?.versions?.node ? false : true;
@@ -8367,7 +8366,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-B2WVXv2a.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-Bx4w-Pqo.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8461,7 +8460,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-BfWOZz0W.js');
+        const importee = await import('./client-DgmVTCEc.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/peernet.js

@@ -1,3 +1,3 @@
-export { P as default } from './peernet-BQUef8u4.js';
+export { P as default } from './peernet-CP4375lb.js';
 import './identity-Cn0iQbY3.js';
 import './value-C3vAp-wb.js';

package/exports/browser/prompts/password/browser.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<string>;
+export default _default;

package/exports/browser/prompts/password/node.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<any>;
+export default _default;

package/exports/browser/proto/file-link.proto.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    hash: string;
+    path: string;
+    'size?': number;
+};
+export default _default;