@leofcoin/peernet 1.2.1 → 1.2.3

package/README.md

@@ -1,72 +1,266 @@
 # peernet
 
+Peer-to-peer networking for Leofcoin and distributed applications.
+
+## Features
+- Decentralized peer discovery and messaging
+- Pluggable request handlers
+- File and data sharing
+- Works in Node.js, browser, and Electron
+
+## Installation
+
+```sh
+npm install @leofcoin/peernet
+```
+
 ## Usage
+
 ```js
 import Peernet from '@leofcoin/peernet'
 
-
 const config = {
   network: 'leofcoin:peach',
   networkVersion: 'peach',
   stars: ['wss://peach.leofcoin.org']
 }
 
-const node = await new Peernet(config)
-// ... setup some things
+// If your identity is password-protected, prompt for password:
+import passwordPrompt from '@leofcoin/peernet/src/prompts/password/node.js';
+const password = await passwordPrompt();
+
+const node = await new Peernet(config, password)
 await node.start()
 
 console.log(globalThis.peernet)
 ```
 
-
-
 ## API
-#### addRequestHandler
 
-examples
+### addRequestHandler
+Register a handler for custom requests:
+
 ```js
-peernet.addRequestHandler('lastBlock', () => {
-  let response;
+peernet.addRequestHandler('lastBlock', async () => {
   const height = await chainStore.get('localIndex')
   const hash = await chainStore.get('localBlock')
-  response = JSON.stringify({ height: height.toString(), hash: hash.toString() })
+  const response = JSON.stringify({ height: height.toString(), hash: hash.toString() })
   return new ResponseMessage({ response })
   // or
-  return new peernet.protos['peernet-response']({ response })
+  // return new peernet.protos['peernet-response']({ response })
 })
-```
 
-```js
 peernet.addRequestHandler('hello', () => {
   return new ResponseMessage({ response: 'hi' })
-  // or
-  return new peernet.protos['peernet-response']({ response: 'hi' })
 })
-```
-#### add version to peer
-```js
+
 peernet.addRequestHandler('version', () => {
-  return new ResponseMessage({ response: {version: 1} })
+  return new ResponseMessage({ response: { version: 1 } })
 })
 ```
 
-## Development
+### Password Prompt
+For password-protected identities, use the provided prompt:
 
-`note: you need to install jsproject`
-```sh
-npm i -g @vandeurenglenn/project
+- **Node.js:** `import passwordPrompt from '@leofcoin/peernet/src/prompts/password/node.js'`
+- **Browser:** `import passwordPrompt from '@leofcoin/peernet/src/prompts/password/browser.js'`
+
+```js
+const password = await passwordPrompt();
+const node = await new Peernet(config, password);
 ```
 
-### watch
-```sh
-npm run w
+## In-Memory Broadcasts: API and Usage
+
+**What is it?**  
+The `broadcast` method allows you to share files or folders with peers, storing them in-memory (not persisted to disk). Data is available for direct retrieval by hash until the process restarts.
+
+**API:**
+```typescript
+// For files:
+peernet.broadcast(path: string, { content: Uint8Array }): Promise<string>
+
+// For folders:
+peernet.broadcast(path: string, { links: Array<{ path: string, hash: string }> }): Promise<string>
 ```
-### compile
-```sh
-npm run c
+
+**Parameters:**
+- `path` (string): The virtual path or identifier for the file or folder.
+- `content` (Uint8Array): The file data (for files).
+- `links` (Array): An array of `{ path, hash }` objects (for folders).
+
+**Returns:**  
+A `Promise` that resolves to a hash string, which can be used to retrieve the data.
+
+---
+
+### Examples
+
+**Broadcast a file:**
+```js
+const hash = await peernet.broadcast('/hello.txt', {
+  content: new TextEncoder().encode('Hello world!')
+});
+```
+
+**Broadcast a folder:**
+```js
+const folderHash = await peernet.broadcast('/my-folder', {
+  links: [
+    { path: '/hello.txt', hash: hash }
+  ]
+});
 ```
-### serve html
+
+**Retrieve data by hash (peer side):**
+```js
+const proto = { decoded: { hash } };
+await peernet.handleData(peer, 'some-id', proto);
+// The peer will receive either .data (for files) or .links (for folders)
+```
+
+---
+
+### Notes
+
+- If you broadcast a folder, only the `links` property is required; `content` should be omitted.
+- If you broadcast a file, only the `content` property is required; `links` should be omitted.
+- The hash returned is unique to the content or folder structure.
+- Data is lost when the process restarts.
+
+### In-Memory Broadcasts
+
+
+Peernet supports in-memory data sharing for fast, temporary distribution of files or folders between peers. This feature allows you to broadcast a file (with content) or a folder (with just links), which is then available for retrieval by other peers (or yourself) until the process is restarted or the in-memory cache is cleared.
+
+### Usage Example
+
+```js
+// Broadcast a file in-memory
+const hash = await peernet.broadcast('/example', {
+  content: new TextEncoder().encode('hello world')
+});
+
+// Broadcast a folder (just links) in-memory
+const folderHash = await peernet.broadcast('/folder', {
+  links: [
+    { path: '/file1', hash: 'hash1' },
+    { path: '/file2', hash: 'hash2' }
+  ]
+});
+
+// Another peer can request the data by hash
+// (handled internally by peernet.handleData)
+```
+
+### Detailed Example
+
+```js
+// 1. Broadcast a file in-memory
+const hash = await peernet.broadcast('/example', {
+  content: new TextEncoder().encode('Hello Peernet!')
+});
+console.log('Broadcasted hash:', hash);
+
+// 2. Broadcast a folder in-memory
+const folderHash = await peernet.broadcast('/folder', {
+  links: [
+    { path: '/file1', hash: 'hash1' },
+    { path: '/file2', hash: 'hash2' }
+  ]
+});
+console.log('Broadcasted folder hash:', folderHash);
+
+// 3. Simulate a peer requesting the data by hash
+const mockPeer = {
+  connected: true,
+  send: async (data, id) => {
+    // Handle the received data (for demo/testing)
+    const DataResponseProto = globalThis.peernet.protos['peernet-data-response'];
+    const decodedProto = await new DataResponseProto(data);
+    await decodedProto.decode();
+    if (decodedProto.decoded.data) {
+      const decodedContent = new TextDecoder().decode(decodedProto.decoded.data);
+      console.log('Received content:', decodedContent);
+    } else if (decodedProto.decoded.links) {
+      console.log('Received folder links:', decodedProto.decoded.links);
+    }
+  }
+};
+const proto = { decoded: { hash } };
+await peernet.handleData(mockPeer, 'test-id', proto);
+```
+
+### Data Flow Diagram
+
+```
+[You/Peer] --(broadcast)--> [Peernet Node: In-Memory Map]
+     ^                                 |
+     |                                 |
+     +------(handleData request)--------+
+```
+
+- `broadcast()` stores the data in-memory and returns a hash.
+- `handleData()` retrieves the data by hash and sends it to the requesting peer.
+
+- The broadcasted data is stored in-memory and is not persisted to disk.
+- Retrieval is by hash, matching the value returned from `broadcast()`.
+- The feature is useful for ephemeral data, rapid prototyping, or testing.
+- If the process restarts, the in-memory data is lost.
+
+### Testing
+
+Automated tests verify that broadcasting and retrieving in-memory data works as expected, including content integrity and hash matching.
+
+## Folder Support (Files with Just Links)
+
+
+Peernet supports "folders" as special file objects that contain only links to other files, without any content. This allows you to represent directory structures or collections of files.
+
+**Example: Broadcasting a Folder**
+```js
+const folderHash = await peernet.broadcast('/folder', {
+  links: [
+    { path: '/file1', hash: 'hash1' },
+    { path: '/file2', hash: 'hash2' }
+  ]
+});
+```
+
+**Retrieving a Folder**
+When a folder is retrieved (e.g., via `handleData`), its `links` array will be preserved, and `content` will be empty or undefined.
+
+**Test Coverage**
+Automated tests verify that broadcasting and retrieving folders works as expected, ensuring the links are preserved and content is empty or undefined.
+
+## Development
+
+> **Note:** You need to install [jsproject](https://www.npmjs.com/package/@vandeurenglenn/project)
+
 ```sh
-npm run demo
+npm i -g @vandeurenglenn/project
 ```
 
+### Scripts
+
+- **Watch:**
+  ```sh
+  npm run watch
+  ```
+- **Build:**
+  ```sh
+  npm run build
+  ```
+- **Test:**
+  ```sh
+  npm test
+  ```
+- **Serve HTML Demo:**
+  ```sh
+  npm run demo
+  ```
+
+## License
+
+MIT
+

package/exports/browser/{browser-CfYI-6aD.js → browser-CWWW0kSj.js}

@@ -1,5 +1,20 @@
 import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
 
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
 var global;
 var hasRequiredGlobal;
 
@@ -124,9 +139,9 @@ function requireBrowser () {
 var browserExports = requireBrowser();
 var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-var browser$1 = /*#__PURE__*/Object.freeze({
+var browser$1 = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
 	default: browser
-});
+}, [browserExports]);
 
 export { browser$1 as b };

package/exports/browser/{browser-Qcpp3EKK.js → browser-DMVbMScf.js}

@@ -1,5 +1,20 @@
 import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
 
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
 var browser$2 = {};
 
 var hasRequiredBrowser;
@@ -30,9 +45,9 @@ function requireBrowser () {
 var browserExports = requireBrowser();
 var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-var browser$1 = /*#__PURE__*/Object.freeze({
+var browser$1 = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
 	default: browser
-});
+}, [browserExports]);
 
 export { browser$1 as b };

package/exports/browser/{client-CWkdUcxK.js → client-B2RpD9kv.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub, d as deflate_1, c as createDebugger, i as inflate_1 } from './peernet-CXod4Dva.js';
+import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-BTtebeW3.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 
@@ -231,7 +231,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-CfYI-6aD.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-CWWW0kSj.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);
@@ -346,7 +346,7 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-DTbjK0sK.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-BoQ4uWm2.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
@@ -616,7 +616,7 @@ class Client {
     }
     async _init() {
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-Qcpp3EKK.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-DMVbMScf.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 await this.setupStar(star);

package/exports/browser/{index-DTbjK0sK.js → index-BoQ4uWm2.js}

@@ -1,6 +1,21 @@
 import { h as commonjsGlobal, r as require$$3, j as requireInherits_browser, g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
 import require$$0 from 'events';
 
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
 var browser$2 = {exports: {}};
 
 /**
@@ -7572,9 +7587,9 @@ function requireSimplePeer () {
 var simplePeerExports = requireSimplePeer();
 var index = /*@__PURE__*/getDefaultExportFromCjs(simplePeerExports);
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
   default: index
-});
+}, [simplePeerExports]);
 
 export { index$1 as i };

package/exports/browser/{messages-C507MMRx.js → messages-DiCEP9k9.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-CXod4Dva.js';
+import { F as FormatInterface } from './peernet-BTtebeW3.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 
@@ -184,7 +184,7 @@ class ChatMessage extends FormatInterface {
 
 var proto = {
     path: String(),
-    'content?': '',
+    'content?': new Uint8Array(),
     'links?': []
 };
 

package/exports/browser/{peernet-CXod4Dva.js → peernet-BTtebeW3.js}

@@ -27,58 +27,73 @@ const createDebugger = (target) => {
 };
 
 class LittlePubSub {
-    subscribers = {};
+    subscribers = new Map();
     verbose;
     constructor(verbose) {
-        this.verbose = verbose;
-    }
-    _handleContext(handler, context) {
-        if (typeof context === 'undefined') {
-            context = handler;
-        }
-        return context;
+        this.verbose = verbose ?? false;
     }
     hasSubscribers(event) {
-        return this.subscribers[event] ? true : false;
+        return this.subscribers.has(event);
+    }
+    subscriberCount(event) {
+        return this.subscribers.get(event)?.handlers.length ?? 0;
+    }
+    clear() {
+        this.subscribers.clear();
     }
     getValue(event) {
-        if (this.subscribers[event])
-            return this.subscribers[event].value;
-        return undefined;
+        return this.subscribers.get(event)?.value;
     }
     subscribe(event, handler, options) {
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = { handlers: [], value: undefined };
-        const context = this._handleContext(handler, options?.context);
-        const _handler = handler.bind(context);
-        this.subscribers[event].handlers.push(_handler);
-        if (this.subscribers[event].value !== undefined)
-            _handler(this.subscribers[event].value, undefined);
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        // Only bind if context is provided
+        const context = options?.context;
+        const boundHandler = context
+            ? handler.bind(context)
+            : handler;
+        subscriber.handlers.push({ original: handler, bound: boundHandler });
+        // Call handler immediately if value already exists
+        if (subscriber.value !== undefined) {
+            boundHandler(subscriber.value, undefined);
+        }
+        // Return unsubscribe function
+        return () => this.unsubscribe(event, handler, options);
     }
     unsubscribe(event, handler, options) {
-        if (!options)
-            options = { keepValue: false };
-        if (!this.hasSubscribers(event))
+        const subscriber = this.subscribers.get(event);
+        if (subscriber === undefined)
             return;
-        const context = this._handleContext(handler, options.context);
-        const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
-        this.subscribers[event].handlers.splice(index);
-        // delete event if no handlers left but supports keeping value for later use
-        // (like when unsubscribing from a value that is still needed because others might subscibe to it)
-        if (this.subscribers[event].handlers.length === 0 && !options.keepValue)
-            delete this.subscribers[event];
+        const handlers = subscriber.handlers;
+        // Find and remove handler by original reference
+        for (let i = 0, len = handlers.length; i < len; i++) {
+            if (handlers[i].original === handler) {
+                handlers.splice(i, 1);
+                break;
+            }
+        }
+        // Delete event if no handlers left (unless keepValue is true)
+        if (handlers.length === 0 && !options?.keepValue) {
+            this.subscribers.delete(event);
+        }
     }
     publish(event, value, verbose) {
-        // always set value even when having no subscribers
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = {
-                handlers: []
-            };
-        const oldValue = this.subscribers[event]?.value;
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        const oldValue = subscriber.value;
+        // Only trigger handlers if verbose or value changed
         if (this.verbose || verbose || oldValue !== value) {
-            this.subscribers[event].value = value;
-            for (const handler of this.subscribers[event].handlers) {
-                handler(value, oldValue);
+            subscriber.value = value;
+            const handlers = subscriber.handlers;
+            const len = handlers.length;
+            for (let i = 0; i < len; i++) {
+                handlers[i].bound(value, oldValue);
             }
         }
     }
@@ -86,12 +101,21 @@ class LittlePubSub {
         this.publish(event, value, true);
     }
     once(event, options) {
-        return new Promise((resolve) => {
-            const cb = (value) => {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            const handler = (value) => {
+                if (timeoutId !== undefined)
+                    clearTimeout(timeoutId);
                 resolve(value);
-                this.unsubscribe(event, cb, options);
+                this.unsubscribe(event, handler, options);
             };
-            this.subscribe(event, cb, options);
+            this.subscribe(event, handler, options);
+            if (options?.timeout !== undefined) {
+                timeoutId = setTimeout(() => {
+                    this.unsubscribe(event, handler, options);
+                    reject(new Error(`Timeout waiting for event "${event}"`));
+                }, options.timeout);
+            }
         });
     }
 }
@@ -8244,6 +8268,7 @@ class Peernet {
     protos;
     version;
     #peerAttempts = {};
+    _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -8355,7 +8380,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-C507MMRx.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-DiCEP9k9.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8449,7 +8474,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-CWkdUcxK.js');
+        const importee = await import('./client-B2RpD9kv.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8520,10 +8545,62 @@ class Peernet {
         const node = await this.prepareMessage(data);
         this.sendMessage(peer, id, node.encoded);
     }
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     *
+     * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @param {string} [storeName='data'] - The store to use for storing the data
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     * The data is kept in memory only and not persisted to storage.
+     * @param {string} path - The path or identifier for the content being broadcasted
+     * @param {{content?: Uint8Array, links?: any[]}} data - The data to broadcast
+   
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    async broadcast(path, { content, links }) {
+        let protoInput;
+        if (content)
+            protoInput = { path, content };
+        else if (links)
+            protoInput = { path, links };
+        const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput);
+        const hash = await protoNode.hash();
+        const encoded = await protoNode.encoded;
+        if (!this._inMemoryBroadcasts)
+            this._inMemoryBroadcasts = new Map();
+        this._inMemoryBroadcasts.set(hash, encoded);
+        await this.publish('broadcast', { hash, from: this.id });
+        return hash;
+    }
     async handleData(peer, id, proto) {
         let { hash, store } = proto.decoded;
         let data;
         try {
+            if (this._inMemoryBroadcasts && this._inMemoryBroadcasts.has(hash)) {
+                data = this._inMemoryBroadcasts.get(hash);
+                let resolvedHash = hash;
+                if (typeof hash === 'function') {
+                    resolvedHash = await hash();
+                }
+                // Decode the stored proto to extract the content or links
+                const FileProto = globalThis.peernet.protos['peernet-file'];
+                const fileProto = await new FileProto(data);
+                await fileProto.decode();
+                const { content, links } = fileProto.decoded;
+                console.log(links);
+                data = await new globalThis.peernet.protos['peernet-data-response']({
+                    hash: resolvedHash,
+                    data: links || content
+                });
+                const node = await this.prepareMessage(data);
+                await this.sendMessage(peer, id, node.encoded);
+                return;
+            }
             store = globalThis[`${store}Store`] || (await this.whichStore([...this.stores], hash));
             if (store && !store.private) {
                 data = await store.get(hash);
@@ -8533,7 +8610,7 @@ class Peernet {
                         data
                     });
                     const node = await this.prepareMessage(data);
-                    this.sendMessage(peer, id, node.encoded);
+                    await this.sendMessage(peer, id, node.encoded);
                 }
             }
             else {
@@ -8541,6 +8618,7 @@ class Peernet {
             }
         }
         catch (error) {
+            console.error('handleData: error', error);
             return this.requestData(hash, store);
         }
     }