@fairfox/polly 0.61.0 → 0.62.0

package/dist/src/mesh.js

@@ -69,6 +69,90 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/shared/lib/idb-helpers.ts
+function openIDB(options) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const request = indexedDB.open(options.name, options.version);
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      const elapsedMs = Date.now() - start;
+      reject(new Error(`Polly IndexedDB open of '${options.name}' timed out after ${elapsedMs}ms (cross-tab lock or zombie connection?)`));
+    }, IDB_OPEN_TIMEOUT_MS);
+    request.onerror = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(request.error);
+    };
+    request.onsuccess = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(request.result);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      options.upgrade(db, event);
+    };
+  });
+}
+function cachedOpen(ref, options) {
+  if (ref.promise)
+    return ref.promise;
+  const pending = openIDB(options);
+  pending.catch(() => {
+    if (ref.promise === pending)
+      ref.promise = null;
+  });
+  ref.promise = pending;
+  return pending;
+}
+function runRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function runTx(db, storeName, mode, fn) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, mode);
+    const store = tx.objectStore(storeName);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+    try {
+      fn(store);
+    } catch (err) {
+      try {
+        tx.abort();
+      } catch {}
+      reject(err);
+    }
+  });
+}
+function iterateCursor(db, storeName, visit) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readonly");
+    const store = tx.objectStore(storeName);
+    const request = store.openCursor();
+    request.onsuccess = () => {
+      const cursor = request.result;
+      if (!cursor)
+        return resolve();
+      visit(cursor.key, cursor.value);
+      cursor.continue();
+    };
+    request.onerror = () => reject(request.error);
+  });
+}
+var IDB_OPEN_TIMEOUT_MS = 5000;
+
 // src/shared/lib/encryption.ts
 var exports_encryption = {};
 __export(exports_encryption, {
@@ -255,69 +339,28 @@ class IndexedDBBlobCache {
   static DB_NAME = "polly-blobs";
   static DB_VERSION = 1;
   static STORE_NAME = "blobs";
-  dbPromise = null;
+  dbRef = { promise: null };
   urls = new Map;
-  static OPEN_TIMEOUT_MS = 5000;
   openDB() {
-    if (this.dbPromise)
-      return this.dbPromise;
-    const pending = new Promise((resolve, reject) => {
-      const start = Date.now();
-      const request = indexedDB.open(IndexedDBBlobCache.DB_NAME, IndexedDBBlobCache.DB_VERSION);
-      let settled = false;
-      const timer = setTimeout(() => {
-        if (settled)
-          return;
-        settled = true;
-        const elapsedMs = Date.now() - start;
-        reject(new Error(`Polly IndexedDB open of '${IndexedDBBlobCache.DB_NAME}' timed out after ${elapsedMs}ms (cross-tab lock or zombie connection?)`));
-      }, IndexedDBBlobCache.OPEN_TIMEOUT_MS);
-      request.onerror = () => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        reject(request.error);
-      };
-      request.onsuccess = () => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        resolve(request.result);
-      };
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
+    return cachedOpen(this.dbRef, {
+      name: IndexedDBBlobCache.DB_NAME,
+      version: IndexedDBBlobCache.DB_VERSION,
+      upgrade: (db) => {
         if (!db.objectStoreNames.contains(IndexedDBBlobCache.STORE_NAME)) {
           db.createObjectStore(IndexedDBBlobCache.STORE_NAME);
         }
-      };
-    });
-    pending.catch(() => {
-      if (this.dbPromise === pending)
-        this.dbPromise = null;
+      }
     });
-    this.dbPromise = pending;
-    return pending;
   }
   async getRecord(hash) {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.get(hash);
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-    });
+    const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
+    return runRequest(tx.objectStore(IndexedDBBlobCache.STORE_NAME).get(hash));
   }
   async putRecord(hash, record) {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readwrite");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
+    await runTx(db, IndexedDBBlobCache.STORE_NAME, "readwrite", (store) => {
       store.put(record, hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
     });
   }
   async get(hash) {
@@ -338,13 +381,9 @@ class IndexedDBBlobCache {
   }
   async has(hash) {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.count(hash);
-      request.onsuccess = () => resolve(request.result > 0);
-      request.onerror = () => reject(request.error);
-    });
+    const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
+    const count = await runRequest(tx.objectStore(IndexedDBBlobCache.STORE_NAME).count(hash));
+    return count > 0;
   }
   async delete(hash) {
     const url = this.urls.get(hash);
@@ -353,12 +392,8 @@ class IndexedDBBlobCache {
       this.urls.delete(hash);
     }
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readwrite");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
+    await runTx(db, IndexedDBBlobCache.STORE_NAME, "readwrite", (store) => {
       store.delete(hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
     });
   }
   async pin(hash) {
@@ -375,50 +410,25 @@ class IndexedDBBlobCache {
   }
   async size() {
     const db = await this.openDB();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.openCursor();
-      let total = 0;
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          const value = cursor.value;
-          total += value.size;
-          cursor.continue();
-        } else {
-          resolve(total);
-        }
-      };
-      request.onerror = () => reject(request.error);
+    let total = 0;
+    await iterateCursor(db, IndexedDBBlobCache.STORE_NAME, (_key, value) => {
+      total += value.size;
     });
+    return total;
   }
   async evict(maxBytes) {
     const db = await this.openDB();
     const candidates = [];
     let totalSize = 0;
-    await new Promise((resolve, reject) => {
-      const tx = db.transaction(IndexedDBBlobCache.STORE_NAME, "readonly");
-      const store = tx.objectStore(IndexedDBBlobCache.STORE_NAME);
-      const request = store.openCursor();
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          const value = cursor.value;
-          totalSize += value.size;
-          if (!value.pinned) {
-            candidates.push({
-              hash: cursor.key,
-              accessedAt: value.accessedAt,
-              size: value.size
-            });
-          }
-          cursor.continue();
-        } else {
-          resolve();
-        }
-      };
-      request.onerror = () => reject(request.error);
+    await iterateCursor(db, IndexedDBBlobCache.STORE_NAME, (key, value) => {
+      totalSize += value.size;
+      if (!value.pinned) {
+        candidates.push({
+          hash: key,
+          accessedAt: value.accessedAt,
+          size: value.size
+        });
+      }
     });
     if (totalSize <= maxBytes)
       return 0;
@@ -3656,4 +3666,4 @@ export {
   $meshCounter
 };
 
-//# debugId=81CAD9639A4786EB64756E2164756E21
+//# debugId=EFE12C3DC2653D4B64756E2164756E21