@fairfox/polly 0.61.0 → 0.63.0

package/dist/src/mesh.js

@@ -69,6 +69,101 @@ 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, openFn = defaultOpenFn) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const request = openFn(options.name, options.version);
+    let settled = false;
+    const elapsed = () => Date.now() - start;
+    const rejectWith = (reason, cause) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new IDBOpenError(reason, options.name, elapsed(), cause));
+    };
+    const timer = setTimeout(() => rejectWith("timeout"), IDB_OPEN_TIMEOUT_MS);
+    request.onerror = () => rejectWith("error", request.error);
+    request.onblocked = () => rejectWith("blocked");
+    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, openFn) {
+  if (ref.promise)
+    return ref.promise;
+  const pending = openIDB(options, openFn);
+  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, IDBOpenError, defaultOpenFn = (name, version) => indexedDB.open(name, version);
+var init_idb_helpers = __esm(() => {
+  IDBOpenError = class IDBOpenError extends Error {
+    reason;
+    dbName;
+    elapsedMs;
+    constructor(reason, dbName, elapsedMs, cause) {
+      super(`Polly IndexedDB open of '${dbName}' ${reason} after ${elapsedMs}ms`, cause === undefined ? undefined : { cause });
+      this.name = "IDBOpenError";
+      this.reason = reason;
+      this.dbName = dbName;
+      this.elapsedMs = elapsedMs;
+    }
+  };
+});
+
 // src/shared/lib/encryption.ts
 var exports_encryption = {};
 __export(exports_encryption, {
@@ -169,6 +264,8 @@ var wasmUrl = new URL(wasmPath, import.meta.url).href;
 await initializeWasm(wasmUrl);
 
 // src/shared/lib/blob-cache.ts
+init_idb_helpers();
+
 class MemoryBlobCache {
   store = new Map;
   pinned = new Set;
@@ -255,69 +352,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 +394,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 +405,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 +423,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;
@@ -1812,6 +1835,7 @@ function resetMeshState() {
   lastLoadedRejection = undefined;
   lastStorageOpenError = undefined;
   lazyWrappers = [];
+  docIdResolver = undefined;
 }
 function isMeshStateConfigured() {
   return defaultRepo !== undefined;
@@ -1917,8 +1941,18 @@ function deriveDocumentId(key) {
   const bytes = digest.slice(0, 16);
   return interpretAsDocumentId(bytes);
 }
+var docIdResolver;
+function registerDocIdResolver(resolver) {
+  docIdResolver = resolver;
+}
+function getDocIdResolver() {
+  return docIdResolver;
+}
+function resolveDocumentId(key) {
+  return docIdResolver?.(key) ?? deriveDocumentId(key);
+}
 function buildHandleFactory(repo, key, initialDoc) {
-  const documentId = deriveDocumentId(key);
+  const documentId = resolveDocumentId(key);
   return async () => {
     lazyInvocations++;
     let exitReason = "threw";
@@ -3594,7 +3628,9 @@ export {
   serialisePairingToken,
   serialiseKeyring,
   revokePeerLocally,
+  resolveDocumentId,
   resetMeshState,
+  registerDocIdResolver,
   parsePairingToken,
   memoryKeyringStorage,
   isPairingTokenExpired,
@@ -3607,12 +3643,14 @@ export {
   getLazyInvocations,
   getLastLoadedRejection,
   getLastConfiguredRepoPeerId,
+  getDocIdResolver,
   generateSigningKeyPair,
   generateDocumentKey,
   encrypt,
   encodeRevocation,
   encodePairingToken,
   deserialiseKeyring,
+  deriveDocumentId,
   decryptOrThrow,
   decrypt,
   decodeRevocation,
@@ -3656,4 +3694,4 @@ export {
   $meshCounter
 };
 
-//# debugId=81CAD9639A4786EB64756E2164756E21
+//# debugId=82752400E00815C464756E2164756E21