@leofcoin/peernet 1.1.99 → 1.1.101

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

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './peernet-BQUef8u4.js';
+import { L as LittlePubSub } from './peernet-CnZz_eNn.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
         });
@@ -428,7 +428,6 @@ class Client {
     #connections = {};
     #stars = {};
     #starListeners = {};
-    #handlersSetup = false;
     #reinitLock = null;
     #connectEvent = 'peer:connected';
     #retryOptions = { retries: 5, factor: 2, minTimeout: 1000, maxTimeout: 30000 };
@@ -561,8 +560,6 @@ class Client {
         else {
             globalThis.addEventListener('beforeunload', this.close.bind(this));
         }
-        // Setup resume/sleep detection so we can reinit connections after wake
-        this._setupResumeHandler();
     }
     setupStarListeners(starConnection, starId) {
         // create stable references to handlers so we can unsubscribe later
@@ -584,46 +581,6 @@ class Client {
             { topic: 'signal', handler: onSignal }
         ];
     }
-    _setupResumeHandler() {
-        if (this.#handlersSetup)
-            return;
-        this.#handlersSetup = true;
-        const THRESHOLD = 10 * 1000; // 10s gap indicates sleep/wake
-        let last = Date.now();
-        const check = () => {
-            const now = Date.now();
-            const delta = now - last;
-            last = now;
-            if (delta > THRESHOLD) {
-                debug(`resume detected (gap ${delta}ms)`);
-                this.reinit().catch((e) => debug('reinit error', e));
-            }
-        };
-        // Start interval checker
-        const iv = setInterval(check, 2000);
-        // Browser specific events
-        if (typeof document !== 'undefined' && document.addEventListener) {
-            document.addEventListener('visibilitychange', () => {
-                if (document.visibilityState === 'visible') {
-                    // small delay to let timers update
-                    setTimeout(() => check(), 50);
-                }
-            });
-            window.addEventListener('online', () => setTimeout(() => check(), 50));
-        }
-        // Node: listen for SIGCONT (process continued) as well
-        if (globalThis.process?.on) {
-            try {
-                process.on('SIGCONT', () => setTimeout(() => check(), 50));
-            }
-            catch (e) {
-                // ignore
-            }
-        }
-        // keep reference so it can be cleared on close
-        // @ts-ignore
-        this._resumeInterval = iv;
-    }
     #starJoined = (id) => {
         if (this.#stars[id]) {
             this.#stars[id].close(0);
@@ -661,7 +618,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 +627,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 +655,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) => {
@@ -741,7 +699,8 @@ class Client {
                 to: peer.peerId,
                 channelName: peer.channelName,
                 version,
-                signal
+                signal,
+                initiator: peer.initiator
             }
         });
     };
@@ -823,10 +782,6 @@ class Client {
                 }
             }
         }
-        // Ensure we wait for all peer and star close/destroy operations.
-        // Previous code passed an array of arrays to Promise.allSettled which
-        // resolves immediately; flatten into a single array of promises (or
-        // values) so we actually wait for async close operations.
         const peerClosers = Object.values(this.#connections).map((connection) => {
             try {
                 // destroy() may be sync or return a promise

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-DYI_YkZS.js

@@ -0,0 +1,206 @@
+import { F as FormatInterface } from './peernet-CnZz_eNn.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[];
+}