@waku/core 0.0.5 → 0.0.7

package/bundle/lib/peer_discovery_static_list.js

@@ -1,89 +0,0 @@
-import { p as peerIdFromString, E as EventEmitter, C as CustomEvent } from '../events-158407bb.js';
-import { m as multiaddr } from '../index-8710041d.js';
-import { d as debug } from '../browser-1e1a2f27.js';
-import { g as getPseudoRandomSubset } from '../random_subset-75d1c511.js';
-import '../index-64ce43f0.js';
-
-const symbol = Symbol.for('@libp2p/peer-discovery');
-
-function multiaddrsToPeerInfo(mas) {
-    return mas
-        .map((ma) => {
-        const peerIdStr = ma.getPeerId();
-        const protocols = [];
-        return {
-            id: peerIdStr ? peerIdFromString(peerIdStr) : null,
-            multiaddrs: [ma.decapsulateCode(421)],
-            protocols,
-        };
-    })
-        .filter((peerInfo) => peerInfo.id !== null);
-}
-
-const log = debug("waku:peer-discovery-static-list");
-/**
- * Pass a list of multiaddr that will be used to bootstrap a node.
- */
-class PeerDiscoveryStaticPeers extends EventEmitter {
-    /**
-     * @param peers Multiaddrs of peers to connect to.
-     * @param opts
-     */
-    constructor(peers, opts) {
-        super();
-        this.interval = opts?.interval ?? PeerDiscoveryStaticPeers.DefaultInterval;
-        const maxPeers = opts?.maxPeers ?? peers?.length;
-        const peerMas = peers.map((peer) => {
-            if (typeof peer === "string") {
-                return multiaddr(peer);
-            }
-            else {
-                return peer;
-            }
-        });
-        this.peers = multiaddrsToPeerInfo(getPseudoRandomSubset(peerMas, maxPeers));
-        log("Use provided list of peers (reduced to maxPeers)", this.peers.map((ma) => ma.toString()));
-    }
-    /**
-     * Start emitting static peers.
-     */
-    start() {
-        this._startTimer();
-    }
-    _startTimer() {
-        if (this.peers) {
-            log("Starting to emit static peers.");
-            if (this.timer != null) {
-                return;
-            }
-            this.timer = setInterval(() => this._returnPeers(), this.interval);
-            this._returnPeers();
-        }
-    }
-    _returnPeers() {
-        if (this.timer == null) {
-            return;
-        }
-        this.peers.forEach((peerData) => {
-            this.dispatchEvent(new CustomEvent("peer", { detail: peerData }));
-        });
-    }
-    /**
-     * Stop emitting peers.
-     */
-    stop() {
-        if (this.timer != null) {
-            clearInterval(this.timer);
-        }
-        this.timer = undefined;
-    }
-    get [symbol]() {
-        return true;
-    }
-    get [Symbol.toStringTag]() {
-        return "@waku/peer-discovery-static-list";
-    }
-}
-PeerDiscoveryStaticPeers.DefaultInterval = 200;
-
-export { PeerDiscoveryStaticPeers };

package/bundle/lib/wait_for_remote_peer.js

@@ -1,326 +0,0 @@
-import { P as Protocols, S as StoreCodec, L as LightPushCodec, F as FilterCodec } from '../index-a67d7136.js';
-import { d as debug } from '../browser-1e1a2f27.js';
-import '../message-049c8b67.js';
-import '../index-64ce43f0.js';
-
-class TimeoutError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = 'TimeoutError';
-	}
-}
-
-/**
-An error to be thrown when the request is aborted by AbortController.
-DOMException is thrown instead of this Error when DOMException is available.
-*/
-class AbortError extends Error {
-	constructor(message) {
-		super();
-		this.name = 'AbortError';
-		this.message = message;
-	}
-}
-
-/**
-TODO: Remove AbortError and just throw DOMException when targeting Node 18.
-*/
-const getDOMException = errorMessage => globalThis.DOMException === undefined ?
-	new AbortError(errorMessage) :
-	new DOMException(errorMessage);
-
-/**
-TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
-*/
-const getAbortedReason = signal => {
-	const reason = signal.reason === undefined ?
-		getDOMException('This operation was aborted.') :
-		signal.reason;
-
-	return reason instanceof Error ? reason : getDOMException(reason);
-};
-
-function pTimeout(promise, milliseconds, fallback, options) {
-	let timer;
-
-	const cancelablePromise = new Promise((resolve, reject) => {
-		if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
-			throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
-		}
-
-		if (milliseconds === Number.POSITIVE_INFINITY) {
-			resolve(promise);
-			return;
-		}
-
-		options = {
-			customTimers: {setTimeout, clearTimeout},
-			...options
-		};
-
-		if (options.signal) {
-			const {signal} = options;
-			if (signal.aborted) {
-				reject(getAbortedReason(signal));
-			}
-
-			signal.addEventListener('abort', () => {
-				reject(getAbortedReason(signal));
-			});
-		}
-
-		timer = options.customTimers.setTimeout.call(undefined, () => {
-			if (typeof fallback === 'function') {
-				try {
-					resolve(fallback());
-				} catch (error) {
-					reject(error);
-				}
-
-				return;
-			}
-
-			const message = typeof fallback === 'string' ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
-			const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
-
-			if (typeof promise.cancel === 'function') {
-				promise.cancel();
-			}
-
-			reject(timeoutError);
-		}, milliseconds);
-
-		(async () => {
-			try {
-				resolve(await promise);
-			} catch (error) {
-				reject(error);
-			} finally {
-				options.customTimers.clearTimeout.call(undefined, timer);
-			}
-		})();
-	});
-
-	cancelablePromise.clear = () => {
-		clearTimeout(timer);
-		timer = undefined;
-	};
-
-	return cancelablePromise;
-}
-
-const normalizeEmitter = emitter => {
-	const addListener = emitter.on || emitter.addListener || emitter.addEventListener;
-	const removeListener = emitter.off || emitter.removeListener || emitter.removeEventListener;
-
-	if (!addListener || !removeListener) {
-		throw new TypeError('Emitter is not compatible');
-	}
-
-	return {
-		addListener: addListener.bind(emitter),
-		removeListener: removeListener.bind(emitter),
-	};
-};
-
-function pEventMultiple(emitter, event, options) {
-	let cancel;
-	const returnValue = new Promise((resolve, reject) => {
-		options = {
-			rejectionEvents: ['error'],
-			multiArgs: false,
-			resolveImmediately: false,
-			...options,
-		};
-
-		if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
-			throw new TypeError('The `count` option should be at least 0 or more');
-		}
-
-		// Allow multiple events
-		const events = [event].flat();
-
-		const items = [];
-		const {addListener, removeListener} = normalizeEmitter(emitter);
-
-		const onItem = (...arguments_) => {
-			const value = options.multiArgs ? arguments_ : arguments_[0];
-
-			// eslint-disable-next-line unicorn/no-array-callback-reference
-			if (options.filter && !options.filter(value)) {
-				return;
-			}
-
-			items.push(value);
-
-			if (options.count === items.length) {
-				cancel();
-				resolve(items);
-			}
-		};
-
-		const rejectHandler = error => {
-			cancel();
-			reject(error);
-		};
-
-		cancel = () => {
-			for (const event of events) {
-				removeListener(event, onItem);
-			}
-
-			for (const rejectionEvent of options.rejectionEvents) {
-				removeListener(rejectionEvent, rejectHandler);
-			}
-		};
-
-		for (const event of events) {
-			addListener(event, onItem);
-		}
-
-		for (const rejectionEvent of options.rejectionEvents) {
-			addListener(rejectionEvent, rejectHandler);
-		}
-
-		if (options.resolveImmediately) {
-			resolve(items);
-		}
-	});
-
-	returnValue.cancel = cancel;
-
-	if (typeof options.timeout === 'number') {
-		const timeout = pTimeout(returnValue, options.timeout);
-		timeout.cancel = cancel;
-		return timeout;
-	}
-
-	return returnValue;
-}
-
-function pEvent(emitter, event, options) {
-	if (typeof options === 'function') {
-		options = {filter: options};
-	}
-
-	options = {
-		...options,
-		count: 1,
-		resolveImmediately: false,
-	};
-
-	const arrayPromise = pEventMultiple(emitter, event, options);
-	const promise = arrayPromise.then(array => array[0]); // eslint-disable-line promise/prefer-await-to-then
-	promise.cancel = arrayPromise.cancel;
-
-	return promise;
-}
-
-const log = debug("waku:wait-for-remote-peer");
-/**
- * Wait for a remote peer to be ready given the passed protocols.
- * Must be used after attempting to connect to nodes, using
- * {@link index.waku.WakuNode.dial} or a bootstrap method with
- * {@link lib/create_waku.createLightNode}.
- *
- * If the passed protocols is a GossipSub protocol, then it resolves only once
- * a peer is in a mesh, to help ensure that other peers will send and receive
- * message to us.
- *
- * @param waku The Waku Node
- * @param protocols The protocols that need to be enabled by remote peers.
- * @param timeoutMs A timeout value in milliseconds..
- *
- * @returns A promise that **resolves** if all desired protocols are fulfilled by
- * remote nodes, **rejects** if the timeoutMs is reached.
- * @throws If passing a protocol that is not mounted
- * @default Wait for remote peers with protocols enabled locally and no time out is applied.
- */
-async function waitForRemotePeer(waku, protocols, timeoutMs) {
-    protocols = protocols ?? getEnabledProtocols(waku);
-    if (!waku.isStarted())
-        return Promise.reject("Waku node is not started");
-    const promises = [];
-    if (protocols.includes(Protocols.Relay)) {
-        if (!waku.relay)
-            throw new Error("Cannot wait for Relay peer: protocol not mounted");
-        promises.push(waitForGossipSubPeerInMesh(waku.relay));
-    }
-    if (protocols.includes(Protocols.Store)) {
-        if (!waku.store)
-            throw new Error("Cannot wait for Store peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.store, [StoreCodec]));
-    }
-    if (protocols.includes(Protocols.LightPush)) {
-        if (!waku.lightPush)
-            throw new Error("Cannot wait for LightPush peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.lightPush, [LightPushCodec]));
-    }
-    if (protocols.includes(Protocols.Filter)) {
-        if (!waku.filter)
-            throw new Error("Cannot wait for Filter peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.filter, [FilterCodec]));
-    }
-    if (timeoutMs) {
-        await rejectOnTimeout(Promise.all(promises), timeoutMs, "Timed out waiting for a remote peer.");
-    }
-    else {
-        await Promise.all(promises);
-    }
-}
-/**
- * Wait for a peer with the given protocol to be connected.
- */
-async function waitForConnectedPeer(waku, codecs) {
-    const peers = await waku.peers();
-    if (peers.length) {
-        log(`${codecs} peer found: `, peers[0].id.toString());
-        return;
-    }
-    await new Promise((resolve) => {
-        const cb = (evt) => {
-            for (const codec of codecs) {
-                if (evt.detail.protocols.includes(codec)) {
-                    log("Resolving for", codec, evt.detail.protocols);
-                    waku.libp2p.peerStore.removeEventListener("change:protocols", cb);
-                    resolve();
-                    break;
-                }
-            }
-        };
-        waku.libp2p.peerStore.addEventListener("change:protocols", cb);
-    });
-}
-/**
- * Wait for a peer with the given protocol to be connected and in the gossipsub
- * mesh.
- */
-async function waitForGossipSubPeerInMesh(waku) {
-    let peers = waku.getMeshPeers();
-    while (peers.length == 0) {
-        await pEvent(waku, "gossipsub:heartbeat");
-        peers = waku.getMeshPeers();
-    }
-}
-const awaitTimeout = (ms, rejectReason) => new Promise((_resolve, reject) => setTimeout(() => reject(rejectReason), ms));
-async function rejectOnTimeout(promise, timeoutMs, rejectReason) {
-    await Promise.race([promise, awaitTimeout(timeoutMs, rejectReason)]);
-}
-function getEnabledProtocols(waku) {
-    const protocols = [];
-    if (waku.relay) {
-        protocols.push(Protocols.Relay);
-    }
-    if (waku.filter) {
-        protocols.push(Protocols.Filter);
-    }
-    if (waku.store) {
-        protocols.push(Protocols.Store);
-    }
-    if (waku.lightPush) {
-        protocols.push(Protocols.LightPush);
-    }
-    return protocols;
-}
-
-export { waitForRemotePeer };

package/bundle/lib/waku_message/topic_only_message.js

@@ -1,3 +0,0 @@
-import '../../browser-1e1a2f27.js';
-export { T as TopicOnlyDecoder, a as TopicOnlyMessage } from '../../topic_only_message-5ad3a869.js';
-import '../../message-049c8b67.js';