@waku/core 0.0.34-9f1d8ca.0 → 0.0.34-c41b319.0

package/bundle/base_protocol-CCK9RCtH.js

@@ -0,0 +1,152 @@
+import { L as Logger } from './index-Db7LxDrL.js';
+
+function selectOpenConnection(connections) {
+    return connections
+        .filter((c) => c.status === "open")
+        .sort((left, right) => right.timeline.open - left.timeline.open)
+        .at(0);
+}
+
+const STREAM_LOCK_KEY = "consumed";
+class StreamManager {
+    multicodec;
+    getConnections;
+    addEventListener;
+    log;
+    ongoingCreation = new Set();
+    streamPool = new Map();
+    constructor(multicodec, getConnections, addEventListener) {
+        this.multicodec = multicodec;
+        this.getConnections = getConnections;
+        this.addEventListener = addEventListener;
+        this.log = new Logger(`stream-manager:${multicodec}`);
+        this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
+    }
+    async getStream(peerId) {
+        const peerIdStr = peerId.toString();
+        const scheduledStream = this.streamPool.get(peerIdStr);
+        if (scheduledStream) {
+            this.streamPool.delete(peerIdStr);
+            await scheduledStream;
+        }
+        let stream = this.getOpenStreamForCodec(peerId);
+        if (stream) {
+            this.log.info(`Found existing stream peerId=${peerIdStr} multicodec=${this.multicodec}`);
+            this.lockStream(peerIdStr, stream);
+            return stream;
+        }
+        stream = await this.createStream(peerId);
+        this.lockStream(peerIdStr, stream);
+        return stream;
+    }
+    async createStream(peerId, retries = 0) {
+        const connections = this.getConnections(peerId);
+        const connection = selectOpenConnection(connections);
+        if (!connection) {
+            throw new Error(`Failed to get a connection to the peer peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+        }
+        let lastError;
+        let stream;
+        for (let i = 0; i < retries + 1; i++) {
+            try {
+                this.log.info(`Attempting to create a stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+                stream = await connection.newStream(this.multicodec);
+                this.log.info(`Created stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+                break;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (!stream) {
+            throw new Error(`Failed to create a new stream for ${peerId.toString()} -- ` + lastError);
+        }
+        return stream;
+    }
+    async createStreamWithLock(peer) {
+        const peerId = peer.id.toString();
+        if (this.ongoingCreation.has(peerId)) {
+            this.log.info(`Skipping creation of a stream due to lock for peerId=${peerId} multicodec=${this.multicodec}`);
+            return;
+        }
+        try {
+            this.ongoingCreation.add(peerId);
+            await this.createStream(peer.id);
+        }
+        catch (error) {
+            this.log.error(`Failed to createStreamWithLock:`, error);
+        }
+        finally {
+            this.ongoingCreation.delete(peerId);
+        }
+        return;
+    }
+    handlePeerUpdateStreamPool = (evt) => {
+        const { peer } = evt.detail;
+        if (!peer.protocols.includes(this.multicodec)) {
+            return;
+        }
+        const stream = this.getOpenStreamForCodec(peer.id);
+        if (stream) {
+            return;
+        }
+        this.scheduleNewStream(peer);
+    };
+    scheduleNewStream(peer) {
+        this.log.info(`Scheduling creation of a stream for peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+        // abandon previous attempt
+        if (this.streamPool.has(peer.id.toString())) {
+            this.streamPool.delete(peer.id.toString());
+        }
+        this.streamPool.set(peer.id.toString(), this.createStreamWithLock(peer));
+    }
+    getOpenStreamForCodec(peerId) {
+        const connections = this.getConnections(peerId);
+        const connection = selectOpenConnection(connections);
+        if (!connection) {
+            return;
+        }
+        const stream = connection.streams.find((s) => s.protocol === this.multicodec);
+        if (!stream) {
+            return;
+        }
+        const isStreamUnusable = ["done", "closed", "closing"].includes(stream.writeStatus || "");
+        if (isStreamUnusable || this.isStreamLocked(stream)) {
+            return;
+        }
+        return stream;
+    }
+    lockStream(peerId, stream) {
+        this.log.info(`Locking stream for peerId:${peerId}\tstreamId:${stream.id}`);
+        stream.metadata[STREAM_LOCK_KEY] = true;
+    }
+    isStreamLocked(stream) {
+        return !!stream.metadata[STREAM_LOCK_KEY];
+    }
+}
+
+/**
+ * A class with predefined helpers, to be used as a base to implement Waku
+ * Protocols.
+ */
+class BaseProtocol {
+    multicodec;
+    components;
+    pubsubTopics;
+    addLibp2pEventListener;
+    removeLibp2pEventListener;
+    streamManager;
+    constructor(multicodec, components, pubsubTopics) {
+        this.multicodec = multicodec;
+        this.components = components;
+        this.pubsubTopics = pubsubTopics;
+        this.addLibp2pEventListener = components.events.addEventListener.bind(components.events);
+        this.removeLibp2pEventListener = components.events.removeEventListener.bind(components.events);
+        this.streamManager = new StreamManager(multicodec, components.connectionManager.getConnections.bind(components.connectionManager), this.addLibp2pEventListener);
+    }
+    async getStream(peerId) {
+        return this.streamManager.getStream(peerId);
+    }
+}
+
+export { BaseProtocol as B, StreamManager as S };

package/bundle/{index-BIW3qNYx.js → index-Db7LxDrL.js}

@@ -1,19 +1,16 @@
-/**
- * Returns a `Uint8Array` of the requested size. Referenced memory will
- * be initialized to 0.
- */
-function alloc(size = 0) {
-    return new Uint8Array(size);
-}
-/**
- * Where possible returns a Uint8Array of the requested size that references
- * uninitialized memory. Only use if you are certain you will immediately
- * overwrite every value in the returned `Uint8Array`.
- */
-function allocUnsafe(size = 0) {
-    return new Uint8Array(size);
+function equals(aa, bb) {
+    if (aa === bb)
+        return true;
+    if (aa.byteLength !== bb.byteLength) {
+        return false;
+    }
+    for (let ii = 0; ii < aa.byteLength; ii++) {
+        if (aa[ii] !== bb[ii]) {
+            return false;
+        }
+    }
+    return true;
 }
-
 function coerce(o) {
     if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
         return o;
@@ -24,10 +21,10 @@ function coerce(o) {
     }
     throw new Error('Unknown type, must be binary type');
 }
-function fromString$1(str) {
+function fromString(str) {
     return new TextEncoder().encode(str);
 }
-function toString$1(b) {
+function toString(b) {
     return new TextDecoder().decode(b);
 }
 
@@ -636,8 +633,8 @@ var base8$1 = /*#__PURE__*/Object.freeze({
 const identity = from({
     prefix: '\x00',
     name: 'identity',
-    encode: (buf) => toString$1(buf),
-    decode: (str) => fromString$1(str)
+    encode: (buf) => toString(buf),
+    decode: (str) => fromString(str)
 });
 
 var identityBase = /*#__PURE__*/Object.freeze({
@@ -648,69 +645,6 @@ var identityBase = /*#__PURE__*/Object.freeze({
 new TextEncoder();
 new TextDecoder();
 
-const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
-
-function createCodec(name, prefix, encode, decode) {
-    return {
-        name,
-        prefix,
-        encoder: {
-            name,
-            prefix,
-            encode
-        },
-        decoder: {
-            decode
-        }
-    };
-}
-const string = createCodec('utf8', 'u', (buf) => {
-    const decoder = new TextDecoder('utf8');
-    return 'u' + decoder.decode(buf);
-}, (str) => {
-    const encoder = new TextEncoder();
-    return encoder.encode(str.substring(1));
-});
-const ascii = createCodec('ascii', 'a', (buf) => {
-    let string = 'a';
-    for (let i = 0; i < buf.length; i++) {
-        string += String.fromCharCode(buf[i]);
-    }
-    return string;
-}, (str) => {
-    str = str.substring(1);
-    const buf = allocUnsafe(str.length);
-    for (let i = 0; i < str.length; i++) {
-        buf[i] = str.charCodeAt(i);
-    }
-    return buf;
-});
-const BASES = {
-    utf8: string,
-    'utf-8': string,
-    hex: bases.base16,
-    latin1: ascii,
-    ascii,
-    binary: ascii,
-    ...bases
-};
-
-/**
- * Create a `Uint8Array` from the passed string
- *
- * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
- *
- * Also `ascii` which is similar to node's 'binary' encoding.
- */
-function fromString(string, encoding = 'utf8') {
-    const base = BASES[encoding];
-    if (base == null) {
-        throw new Error(`Unsupported encoding "${encoding}"`);
-    }
-    // add multibase prefix
-    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
-}
-
 var Protocols;
 (function (Protocols) {
     Protocols["Relay"] = "relay";
@@ -825,6 +759,10 @@ var EConnectionStateEvents;
     EConnectionStateEvents["CONNECTION_STATUS"] = "waku:connection";
 })(EConnectionStateEvents || (EConnectionStateEvents = {}));
 
+var HealthStatusChangeEvents;
+(function (HealthStatusChangeEvents) {
+    HealthStatusChangeEvents["StatusChange"] = "health:change";
+})(HealthStatusChangeEvents || (HealthStatusChangeEvents = {}));
 var HealthStatus;
 (function (HealthStatus) {
     HealthStatus["Unhealthy"] = "Unhealthy";
@@ -832,44 +770,6 @@ var HealthStatus;
     HealthStatus["SufficientlyHealthy"] = "SufficientlyHealthy";
 })(HealthStatus || (HealthStatus = {}));
 
-/**
- * Turns a `Uint8Array` into a string.
- *
- * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
- *
- * Also `ascii` which is similar to node's 'binary' encoding.
- */
-function toString(array, encoding = 'utf8') {
-    const base = BASES[encoding];
-    if (base == null) {
-        throw new Error(`Unsupported encoding "${encoding}"`);
-    }
-    // strip multibase prefix
-    return base.encoder.encode(array).substring(1);
-}
-
-/**
- * Decode byte array to utf-8 string.
- */
-const bytesToUtf8 = (b) => toString(b, "utf8");
-/**
- * Encode utf-8 string to byte array.
- */
-const utf8ToBytes = (s) => fromString(s, "utf8");
-/**
- * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
- */
-function concat(byteArrays, totalLength) {
-    const len = byteArrays.reduce((acc, curr) => acc + curr.length, 0);
-    const res = new Uint8Array(len);
-    let offset = 0;
-    for (const bytes of byteArrays) {
-        res.set(bytes, offset);
-        offset += bytes.length;
-    }
-    return res;
-}
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -1214,24 +1114,62 @@ function setup(env) {
 		createDebug.names = [];
 		createDebug.skips = [];
 
-		let i;
-		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
-		const len = split.length;
+		const split = (typeof namespaces === 'string' ? namespaces : '')
+			.trim()
+			.replace(' ', ',')
+			.split(',')
+			.filter(Boolean);
 
-		for (i = 0; i < len; i++) {
-			if (!split[i]) {
-				// ignore empty strings
-				continue;
+		for (const ns of split) {
+			if (ns[0] === '-') {
+				createDebug.skips.push(ns.slice(1));
+			} else {
+				createDebug.names.push(ns);
 			}
+		}
+	}
 
-			namespaces = split[i].replace(/\*/g, '.*?');
-
-			if (namespaces[0] === '-') {
-				createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+	/**
+	 * Checks if the given string matches a namespace template, honoring
+	 * asterisks as wildcards.
+	 *
+	 * @param {String} search
+	 * @param {String} template
+	 * @return {Boolean}
+	 */
+	function matchesTemplate(search, template) {
+		let searchIndex = 0;
+		let templateIndex = 0;
+		let starIndex = -1;
+		let matchIndex = 0;
+
+		while (searchIndex < search.length) {
+			if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
+				// Match character or proceed with wildcard
+				if (template[templateIndex] === '*') {
+					starIndex = templateIndex;
+					matchIndex = searchIndex;
+					templateIndex++; // Skip the '*'
+				} else {
+					searchIndex++;
+					templateIndex++;
+				}
+			} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
+				// Backtrack to the last '*' and try to match more characters
+				templateIndex = starIndex + 1;
+				matchIndex++;
+				searchIndex = matchIndex;
 			} else {
-				createDebug.names.push(new RegExp('^' + namespaces + '$'));
+				return false; // No match
 			}
 		}
+
+		// Handle trailing '*' in template
+		while (templateIndex < template.length && template[templateIndex] === '*') {
+			templateIndex++;
+		}
+
+		return templateIndex === template.length;
 	}
 
 	/**
@@ -1242,8 +1180,8 @@ function setup(env) {
 	*/
 	function disable() {
 		const namespaces = [
-			...createDebug.names.map(toNamespace),
-			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+			...createDebug.names,
+			...createDebug.skips.map(namespace => '-' + namespace)
 		].join(',');
 		createDebug.enable('');
 		return namespaces;
@@ -1257,21 +1195,14 @@ function setup(env) {
 	* @api public
 	*/
 	function enabled(name) {
-		if (name[name.length - 1] === '*') {
-			return true;
-		}
-
-		let i;
-		let len;
-
-		for (i = 0, len = createDebug.skips.length; i < len; i++) {
-			if (createDebug.skips[i].test(name)) {
+		for (const skip of createDebug.skips) {
+			if (matchesTemplate(name, skip)) {
 				return false;
 			}
 		}
 
-		for (i = 0, len = createDebug.names.length; i < len; i++) {
-			if (createDebug.names[i].test(name)) {
+		for (const ns of createDebug.names) {
+			if (matchesTemplate(name, ns)) {
 				return true;
 			}
 		}
@@ -1279,19 +1210,6 @@ function setup(env) {
 		return false;
 	}
 
-	/**
-	* Convert regexp to namespace
-	*
-	* @param {RegExp} regxep
-	* @return {String} namespace
-	* @api private
-	*/
-	function toNamespace(regexp) {
-		return regexp.toString()
-			.substring(2, regexp.toString().length - 2)
-			.replace(/\.\*\?$/, '*');
-	}
-
 	/**
 	* Coerce `val`.
 	*
@@ -1453,6 +1371,7 @@ var common = setup;
 
 		// Is webkit? http://stackoverflow.com/a/16459606/376773
 		// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+		// eslint-disable-next-line no-return-assign
 		return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
 			// Is firebug? http://stackoverflow.com/a/398120/376773
 			(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
@@ -1626,4 +1545,4 @@ class Logger {
     }
 }
 
-export { EPeersByDiscoveryEvents as E, HealthStatus as H, Logger as L, ProtocolError as P, Tags as T, allocUnsafe as a, alloc as b, EConnectionStateEvents as c, Protocols as d, concat as e, fromString as f, bytesToUtf8 as g, utf8ToBytes as u };
+export { EPeersByDiscoveryEvents as E, Logger as L, ProtocolError as P, Tags as T, base32 as a, base36 as b, coerce as c, base58btc as d, equals as e, EConnectionStateEvents as f, base2$1 as g, base8$1 as h, identityBase as i, base10$1 as j, base16$1 as k, base32$1 as l, base36$1 as m, base58 as n, base64$1 as o, base256emoji$1 as p };