chore: upgrade applesauce packages to v4.0.0

- Update all applesauce packages from 3.1.0 to 4.0.0
- Add applesauce-factory dependency
- Version 4.0.0 includes app-data helpers needed for NIP-78

node_modules/nostr-tools/lib/esm/abstract-pool.js

@@ -176,7 +176,10 @@ var AbstractRelay = class {
   baseEoseTimeout = 4400;
   connectionTimeout = 4400;
   publishTimeout = 4400;
+  pingFrequency = 2e4;
+  pingTimeout = 2e4;
   openSubs = /* @__PURE__ */ new Map();
+  enablePing;
   connectionTimeoutHandle;
   connectionPromise;
   openCountRequests = /* @__PURE__ */ new Map();
@@ -193,6 +196,7 @@ var AbstractRelay = class {
     this.url = normalizeURL(url);
     this.verifyEvent = opts.verifyEvent;
     this._WebSocket = opts.websocketImplementation || WebSocket;
+    this.enablePing = opts.enablePing;
   }
   static async connect(url, opts) {
     const relay = new AbstractRelay(url, opts);
@@ -238,7 +242,7 @@ var AbstractRelay = class {
       this.ws.onopen = () => {
         clearTimeout(this.connectionTimeoutHandle);
         this._connected = true;
-        if (this.ws && this.ws.ping) {
+        if (this.enablePing) {
           this.pingpong();
         }
         resolve();
@@ -246,45 +250,54 @@ var AbstractRelay = class {
       this.ws.onerror = (ev) => {
         clearTimeout(this.connectionTimeoutHandle);
         reject(ev.message || "websocket error");
-        if (this._connected) {
-          this._connected = false;
-          this.connectionPromise = void 0;
-          this.onclose?.();
-          this.closeAllSubscriptions("relay connection errored");
-        }
+        this._connected = false;
+        this.connectionPromise = void 0;
+        this.onclose?.();
+        this.closeAllSubscriptions("relay connection errored");
       };
       this.ws.onclose = (ev) => {
         clearTimeout(this.connectionTimeoutHandle);
         reject(ev.message || "websocket closed");
-        if (this._connected) {
-          this._connected = false;
-          this.connectionPromise = void 0;
-          this.onclose?.();
-          this.closeAllSubscriptions("relay connection closed");
-        }
+        this._connected = false;
+        this.connectionPromise = void 0;
+        this.onclose?.();
+        this.closeAllSubscriptions("relay connection closed");
       };
       this.ws.onmessage = this._onmessage.bind(this);
     });
     return this.connectionPromise;
   }
-  async receivePong() {
+  async waitForPingPong() {
     return new Promise((res, err) => {
       ;
       this.ws && this.ws.on && this.ws.on("pong", () => res(true)) || err("ws can't listen for pong");
+      this.ws && this.ws.ping && this.ws.ping();
+    });
+  }
+  async waitForDummyReq() {
+    return new Promise((resolve, _) => {
+      const sub = this.subscribe([{ ids: ["a".repeat(64)] }], {
+        oneose: () => {
+          sub.close();
+          resolve(true);
+        },
+        eoseTimeout: this.pingTimeout + 1e3
+      });
     });
   }
   async pingpong() {
-    if (this.ws?.readyState == 1) {
-      this.ws && this.ws.ping && this.ws.ping();
+    if (this.ws?.readyState === 1) {
       const result = await Promise.any([
-        this.receivePong(),
-        new Promise((res) => setTimeout(() => res(false), 1e4))
+        this.ws && this.ws.ping && this.ws.on ? this.waitForPingPong() : this.waitForDummyReq(),
+        new Promise((res) => setTimeout(() => res(false), this.pingTimeout))
       ]);
-      console.error("pingpong result", result);
       if (result) {
-        setTimeout(() => this.pingpong(), 1e4);
+        setTimeout(() => this.pingpong(), this.pingFrequency);
       } else {
-        this.ws && this.ws.close();
+        this.closeAllSubscriptions("pingpong timed out");
+        this._connected = false;
+        this.onclose?.();
+        this.ws?.close();
       }
     }
   }
@@ -449,8 +462,8 @@ var AbstractRelay = class {
   close() {
     this.closeAllSubscriptions("relay connection closed by us");
     this._connected = false;
-    this.ws?.close();
     this.onclose?.();
+    this.ws?.close();
   }
   _onmessage(ev) {
     this.incomingMessageQueue.enqueue(ev.data);
@@ -522,11 +535,13 @@ var AbstractSimplePool = class {
   seenOn = /* @__PURE__ */ new Map();
   trackRelays = false;
   verifyEvent;
+  enablePing;
   trustedRelayURLs = /* @__PURE__ */ new Set();
   _WebSocket;
   constructor(opts) {
     this.verifyEvent = opts.verifyEvent;
     this._WebSocket = opts.websocketImplementation;
+    this.enablePing = opts.enablePing;
   }
   async ensureRelay(url, params) {
     url = normalizeURL(url);
@@ -534,7 +549,8 @@ var AbstractSimplePool = class {
     if (!relay) {
       relay = new AbstractRelay(url, {
         verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
-        websocketImplementation: this._WebSocket
+        websocketImplementation: this._WebSocket,
+        enablePing: this.enablePing
       });
       relay.onclose = () => {
         this.relays.delete(url);
@@ -554,20 +570,38 @@ var AbstractSimplePool = class {
   }
   subscribe(relays, filter, params) {
     params.onauth = params.onauth || params.doauth;
-    return this.subscribeMap(
-      relays.map((url) => ({ url, filter })),
-      params
-    );
+    const request = [];
+    for (let i = 0; i < relays.length; i++) {
+      const url = normalizeURL(relays[i]);
+      if (!request.find((r) => r.url === url)) {
+        request.push({ url, filter });
+      }
+    }
+    return this.subscribeMap(request, params);
   }
-  subscribeMany(relays, filters, params) {
+  subscribeMany(relays, filter, params) {
     params.onauth = params.onauth || params.doauth;
-    return this.subscribeMap(
-      relays.flatMap((url) => filters.map((filter) => ({ url, filter }))),
-      params
-    );
+    const request = [];
+    const uniqUrls = [];
+    for (let i = 0; i < relays.length; i++) {
+      const url = normalizeURL(relays[i]);
+      if (uniqUrls.indexOf(url) === -1) {
+        uniqUrls.push(url);
+        request.push({ url, filter });
+      }
+    }
+    return this.subscribeMap(request, params);
   }
   subscribeMap(requests, params) {
     params.onauth = params.onauth || params.doauth;
+    const grouped = /* @__PURE__ */ new Map();
+    for (const req of requests) {
+      const { url, filter } = req;
+      if (!grouped.has(url))
+        grouped.set(url, []);
+      grouped.get(url).push(filter);
+    }
+    const groupedRequests = Array.from(grouped.entries()).map(([url, filters]) => ({ url, filters }));
     if (this.trackRelays) {
       params.receivedEvent = (relay, id) => {
         let set = this.seenOn.get(id);
@@ -612,8 +646,7 @@ var AbstractSimplePool = class {
       return have;
     };
     const allOpened = Promise.all(
-      requests.map(async ({ url, filter }, i) => {
-        url = normalizeURL(url);
+      groupedRequests.map(async ({ url, filters }, i) => {
         let relay;
         try {
           relay = await this.ensureRelay(url, {
@@ -623,13 +656,13 @@ var AbstractSimplePool = class {
           handleClose(i, err?.message || String(err));
           return;
         }
-        let subscription = relay.subscribe([filter], {
+        let subscription = relay.subscribe(filters, {
           ...params,
           oneose: () => handleEose(i),
           onclose: (reason) => {
             if (reason.startsWith("auth-required: ") && params.onauth) {
               relay.auth(params.onauth).then(() => {
-                relay.subscribe([filter], {
+                relay.subscribe(filters, {
                   ...params,
                   oneose: () => handleEose(i),
                   onclose: (reason2) => {
@@ -670,9 +703,9 @@ var AbstractSimplePool = class {
     });
     return subcloser;
   }
-  subscribeManyEose(relays, filters, params) {
+  subscribeManyEose(relays, filter, params) {
     params.onauth = params.onauth || params.doauth;
-    const subcloser = this.subscribeMany(relays, filters, {
+    const subcloser = this.subscribeMany(relays, filter, {
       ...params,
       oneose() {
         subcloser.close("closed automatically on eose");