@abraca/dabra 1.0.17 → 1.0.19

package/dist/abracadabra-provider.cjs

@@ -2744,8 +2744,10 @@ var OfflineStore = class {
 	}
 	destroy() {
 		this._destroyed = true;
+		const db = this.db;
 		this.db = null;
 		this.dbPromise = null;
+		if (db) Promise.resolve().then(() => db.close());
 	}
 };
 
@@ -3100,8 +3102,11 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 	}
 	destroy() {
 		this.document.off("subdocs", this.boundHandleYSubdocsChange);
+		const childIds = [...this.childProviders.keys()];
 		for (const provider of this.childProviders.values()) provider.destroy();
 		this.childProviders.clear();
+		const wsProviderMap = this.configuration.websocketProvider?.configuration?.providerMap;
+		if (wsProviderMap) for (const childId of childIds) wsProviderMap.delete(childId);
 		this.offlineStore?.destroy();
 		this.offlineStore = null;
 		super.destroy();
@@ -8419,7 +8424,9 @@ var BackgroundSyncManager = class extends EventEmitter {
 		this.opts = {
 			concurrency: opts?.concurrency ?? 2,
 			syncTimeout: opts?.syncTimeout ?? 15e3,
-			prefetchFiles: opts?.prefetchFiles ?? true
+			prefetchFiles: opts?.prefetchFiles ?? true,
+			throttleMs: opts?.throttleMs ?? 50,
+			maxRetries: opts?.maxRetries ?? 2
 		};
 		let serverOrigin = "default";
 		try {
@@ -8453,7 +8460,38 @@ var BackgroundSyncManager = class extends EventEmitter {
 		for (const [docId, v] of entries) updatedAtMap.set(docId, v?.updatedAt ?? v?.createdAt ?? 0);
 		this._prefetchCovers(entries).catch(() => null);
 		const queue = this._buildQueue(entries);
-		await Promise.all(queue.map((docId) => this._syncWithSemaphore(docId, updatedAtMap.get(docId) ?? 0)));
+		const failed = [];
+		let idx = 0;
+		const next = async () => {
+			while (idx < queue.length) {
+				if (this._destroyed) return;
+				const docId = queue[idx++];
+				const updatedAt = updatedAtMap.get(docId) ?? 0;
+				if (!await this._syncWithSemaphore(docId, updatedAt)) failed.push(docId);
+				if (this.opts.throttleMs > 0 && idx < queue.length) await new Promise((r) => setTimeout(r, this.opts.throttleMs));
+			}
+		};
+		const workers = Array.from({ length: this.opts.concurrency }, () => next());
+		await Promise.all(workers);
+		for (let retry = 0; retry < this.opts.maxRetries && failed.length > 0; retry++) {
+			if (this._destroyed) return;
+			const batch = failed.splice(0, failed.length);
+			const backoff = 2e3 * 2 ** retry;
+			await new Promise((r) => setTimeout(r, backoff));
+			idx = 0;
+			const retryQueue = batch;
+			const retryNext = async () => {
+				while (idx < retryQueue.length) {
+					if (this._destroyed) return;
+					const docId = retryQueue[idx++];
+					const updatedAt = updatedAtMap.get(docId) ?? 0;
+					if (!await this._syncWithSemaphore(docId, updatedAt)) failed.push(docId);
+					if (this.opts.throttleMs > 0 && idx < retryQueue.length) await new Promise((r) => setTimeout(r, this.opts.throttleMs));
+				}
+			};
+			const retryWorkers = Array.from({ length: this.opts.concurrency }, () => retryNext());
+			await Promise.all(retryWorkers);
+		}
 	}
 	/** Sync a single document by ID. */
 	async syncDoc(docId) {
@@ -8534,15 +8572,16 @@ var BackgroundSyncManager = class extends EventEmitter {
 		items.sort((a, b) => b.priority - a.priority);
 		return items.map((i) => i.docId);
 	}
+	/** Returns true on success (or skip), false on error. */
 	async _syncWithSemaphore(docId, updatedAt) {
-		if (this._destroyed) return;
+		if (this._destroyed) return true;
 		const existing = this.syncStates.get(docId);
 		if (existing && existing.status === "synced" && existing.lastSynced !== null && existing.lastSynced >= updatedAt) {
 			this.emit("stateChanged", {
 				docId,
 				state: existing
 			});
-			return;
+			return true;
 		}
 		await this.semaphore.acquire();
 		try {
@@ -8553,6 +8592,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				state
 			});
+			return state.status !== "error";
 		} finally {
 			this.semaphore.release();
 		}
@@ -8588,10 +8628,12 @@ var BackgroundSyncManager = class extends EventEmitter {
 		}
 	}
 	async _syncNonE2EDoc(docId) {
+		const alreadyCached = this.rootProvider.children.has(docId);
 		const childProvider = await this.rootProvider.loadChild(docId);
 		await childProvider.ready;
 		await this._waitForSynced(childProvider);
 		if (this.opts.prefetchFiles && this.fileBlobStore) this._prefetchDocFiles(docId, childProvider.document).catch(() => null);
+		if (!alreadyCached) this.rootProvider.unloadChild(docId);
 		return {
 			docId,
 			status: "synced",