@dabble/patches 0.4.5 → 0.4.6

package/dist/client/IndexedDBStore.js

@@ -1,504 +1,391 @@
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-import { applyChanges } from '../algorithms/shared/applyChanges.js';
-import { transformPatch } from '../json-patch/transformPatch.js';
-import { blockable } from '../utils/concurrency.js';
-import { deferred } from '../utils/deferred.js';
+import {
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __publicField,
+  __runInitializers
+} from "../chunk-IZ2YBCUP.js";
+var _getLastRevs_dec, _saveCommittedChanges_dec, _replacePendingChanges_dec, _getPendingChanges_dec, _savePendingChanges_dec, _saveDoc_dec, _confirmDeleteDoc_dec, _deleteDoc_dec, _getDoc_dec, _init;
+import { applyChanges } from "../algorithms/shared/applyChanges.js";
+import { transformPatch } from "../json-patch/transformPatch.js";
+import { blockable } from "../utils/concurrency.js";
+import { deferred } from "../utils/deferred.js";
 const DB_VERSION = 1;
 const SNAPSHOT_INTERVAL = 200;
-/**
- * Creates a new IndexedDB database with stores:
- * - snapshots<{ docId: string; rev: number; state: any }> (primary key: docId)
- * - committedChanges<Change & { docId: string; }> (primary key: [docId, rev])
- * - pendingChanges<Change & { docId: string; }> (primary key: [docId, rev])
- * - docs<{ docId: string; committedRev: number; deleted?: boolean }> (primary key: docId)
- *
- * Under the hood, this class will store snapshots of the document only for committed state. It will not update the
- * committed state on *every* received committed change as this can cause issues with IndexedDB with many large updates.
- * After every 200 committed changes, the class will save the current state to the snapshot store and delete the committed changes that went into it.
- * A snapshot will not be created if there are pending changes based on revisions older than the 200th committed change until those pending changes are committed.
- */
-let IndexedDBStore = (() => {
-    let _instanceExtraInitializers = [];
-    let _getDoc_decorators;
-    let _deleteDoc_decorators;
-    let _confirmDeleteDoc_decorators;
-    let _saveDoc_decorators;
-    let _savePendingChanges_decorators;
-    let _getPendingChanges_decorators;
-    let _replacePendingChanges_decorators;
-    let _saveCommittedChanges_decorators;
-    let _getLastRevs_decorators;
-    return class IndexedDBStore {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _getDoc_decorators = [blockable];
-            _deleteDoc_decorators = [blockable];
-            _confirmDeleteDoc_decorators = [blockable];
-            _saveDoc_decorators = [blockable];
-            _savePendingChanges_decorators = [blockable];
-            _getPendingChanges_decorators = [blockable];
-            _replacePendingChanges_decorators = [blockable];
-            _saveCommittedChanges_decorators = [blockable];
-            _getLastRevs_decorators = [blockable];
-            __esDecorate(this, null, _getDoc_decorators, { kind: "method", name: "getDoc", static: false, private: false, access: { has: obj => "getDoc" in obj, get: obj => obj.getDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _deleteDoc_decorators, { kind: "method", name: "deleteDoc", static: false, private: false, access: { has: obj => "deleteDoc" in obj, get: obj => obj.deleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _confirmDeleteDoc_decorators, { kind: "method", name: "confirmDeleteDoc", static: false, private: false, access: { has: obj => "confirmDeleteDoc" in obj, get: obj => obj.confirmDeleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _saveDoc_decorators, { kind: "method", name: "saveDoc", static: false, private: false, access: { has: obj => "saveDoc" in obj, get: obj => obj.saveDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _savePendingChanges_decorators, { kind: "method", name: "savePendingChanges", static: false, private: false, access: { has: obj => "savePendingChanges" in obj, get: obj => obj.savePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _getPendingChanges_decorators, { kind: "method", name: "getPendingChanges", static: false, private: false, access: { has: obj => "getPendingChanges" in obj, get: obj => obj.getPendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _replacePendingChanges_decorators, { kind: "method", name: "replacePendingChanges", static: false, private: false, access: { has: obj => "replacePendingChanges" in obj, get: obj => obj.replacePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _saveCommittedChanges_decorators, { kind: "method", name: "saveCommittedChanges", static: false, private: false, access: { has: obj => "saveCommittedChanges" in obj, get: obj => obj.saveCommittedChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _getLastRevs_decorators, { kind: "method", name: "getLastRevs", static: false, private: false, access: { has: obj => "getLastRevs" in obj, get: obj => obj.getLastRevs }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        db = (__runInitializers(this, _instanceExtraInitializers), null);
-        dbName;
-        dbPromise;
-        constructor(dbName) {
-            this.dbName = dbName;
-            this.dbPromise = deferred();
-            if (this.dbName) {
-                this.initDB();
-            }
-        }
-        async initDB() {
-            if (!this.dbName)
-                return;
-            const request = indexedDB.open(this.dbName, DB_VERSION);
-            request.onerror = () => this.dbPromise.reject(request.error);
-            request.onsuccess = () => {
-                this.db = request.result;
-                this.dbPromise.resolve(this.db);
-            };
-            request.onupgradeneeded = event => {
-                const db = event.target.result;
-                // Create stores
-                if (!db.objectStoreNames.contains('snapshots')) {
-                    db.createObjectStore('snapshots', { keyPath: 'docId' });
-                }
-                if (!db.objectStoreNames.contains('committedChanges')) {
-                    db.createObjectStore('committedChanges', { keyPath: ['docId', 'rev'] });
-                }
-                if (!db.objectStoreNames.contains('pendingChanges')) {
-                    db.createObjectStore('pendingChanges', { keyPath: ['docId', 'rev'] });
-                }
-                if (!db.objectStoreNames.contains('docs')) {
-                    db.createObjectStore('docs', { keyPath: 'docId' });
-                }
-            };
-        }
-        getDB() {
-            return this.dbPromise.promise;
-        }
-        /**
-         * Set the name of the database, loads a new database connection.
-         * @param dbName - The new name of the database.
-         */
-        setName(dbName) {
-            this.dbName = dbName;
-            if (this.db) {
-                this.db.close();
-                this.db = null;
-                this.dbPromise = deferred();
-            }
-            this.initDB();
-        }
-        /**
-         * Closes the database connection. After calling this method, the store
-         * will no longer be usable. A new instance must be created to reopen
-         * the database.
-         */
-        async close() {
-            await this.dbPromise.promise;
-            if (this.db) {
-                this.db.close();
-                this.db = null;
-                this.dbPromise = deferred();
-                this.dbPromise.resolve(null);
-            }
-        }
-        async deleteDB() {
-            if (!this.dbName)
-                return;
-            await this.close();
-            await new Promise((resolve, reject) => {
-                const request = indexedDB.deleteDatabase(this.dbName);
-                request.onsuccess = () => resolve();
-                request.onerror = () => reject(request.error);
-                request.onblocked = () => reject(request.error);
-            });
-        }
-        async transaction(storeNames, mode) {
-            const db = await this.getDB();
-            const tx = new IDBTransactionWrapper(db.transaction(storeNames, mode));
-            const stores = storeNames.map(name => tx.getStore(name));
-            return [tx, ...stores];
-        }
-        /**
-         * Rebuilds a document snapshot + pending queue *without* loading
-         * the full PatchesDoc into memory.
-         *
-         * 1. load the last snapshot (state + rev)
-         * 2. load committedChanges[rev > snapshot.rev]
-         * 3. load pendingChanges
-         * 4. apply committed changes, rebase pending
-         * 5. return { state, rev, changes: pending }
-         */
-        async getDoc(docId) {
-            const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readonly');
-            const docMeta = await docsStore.get(docId);
-            if (docMeta?.deleted) {
-                await tx.complete();
-                return undefined;
-            }
-            const snapshot = await snapshots.get(docId);
-            const committed = await committedChanges.getAll([docId, snapshot?.rev ?? 0], [docId, Infinity]);
-            const pending = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
-            if (!snapshot && !committed.length && !pending.length)
-                return undefined;
-            // Apply any committed changes to the snapshot state
-            const state = applyChanges(snapshot?.state, committed);
-            // Rebase pending changes if there are any committed changes received since their baseRev
-            const lastCommitted = committed[committed.length - 1];
-            const baseRev = pending[0]?.baseRev;
-            if (lastCommitted && baseRev && baseRev < lastCommitted.rev) {
-                const patch = committed
-                    .filter(change => change.rev > baseRev)
-                    .map(change => change.ops)
-                    .flat();
-                const offset = lastCommitted.rev - baseRev;
-                pending.forEach(change => {
-                    change.rev += offset;
-                    change.ops = transformPatch(state, patch, change.ops);
-                });
-            }
-            await tx.complete();
-            return {
-                state,
-                rev: committed[committed.length - 1]?.rev ?? snapshot?.rev ?? 0,
-                changes: pending,
-            };
-        }
-        /**
-         * Completely remove all data for this docId and mark it as deleted (tombstone).
-         */
-        async deleteDoc(docId) {
-            const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
-            const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
-            await docsStore.put({ ...docMeta, deleted: true });
-            await Promise.all([
-                snapshots.delete(docId),
-                committedChanges.delete([docId, 0], [docId, Infinity]),
-                pendingChanges.delete([docId, 0], [docId, Infinity]),
-            ]);
-            await tx.complete();
-        }
-        /**
-         * Confirm the deletion of a document.
-         * @param docId - The ID of the document to delete.
-         */
-        async confirmDeleteDoc(docId) {
-            const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
-            await docsStore.delete(docId);
-            await tx.complete();
-        }
-        /**
-         * Save a document's state to the store.
-         * @param docId - The ID of the document to save.
-         * @param docState - The state of the document to save.
-         */
-        async saveDoc(docId, docState) {
-            const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
-            const { rev, state } = docState;
-            await Promise.all([
-                docsStore.put({ docId, committedRev: rev }),
-                snapshots.put({ docId, state, rev }),
-                committedChanges.delete([docId, 0], [docId, Infinity]),
-                pendingChanges.delete([docId, 0], [docId, Infinity]),
-            ]);
-            await tx.complete();
-        }
-        /**
-         * Append an array of local changes to the pending queue.
-         * Called *before* you attempt to send them to the server.
-         */
-        async savePendingChanges(docId, changes) {
-            const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
-            let docMeta = await docsStore.get(docId);
-            if (!docMeta) {
-                docMeta = { docId, committedRev: 0 };
-                await docsStore.put(docMeta);
-            }
-            else if (docMeta.deleted) {
-                delete docMeta.deleted;
-                await docsStore.put(docMeta);
-                console.warn(`Revived document ${docId} by saving pending changes.`);
-            }
-            await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
-            await tx.complete();
-        }
-        /**
-         * Read back all pending changes for this docId (in order).
-         * @param docId - The ID of the document to get the pending changes for.
-         * @returns The pending changes.
-         */
-        async getPendingChanges(docId) {
-            const [tx, pendingChanges] = await this.transaction(['pendingChanges'], 'readonly');
-            const result = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
-            await tx.complete();
-            return result;
-        }
-        /**
-         * Replace all pending changes for a document (used after rebasing).
-         * @param docId - The ID of the document to replace the pending changes for.
-         * @param changes - The changes to replace the pending changes with.
-         */
-        async replacePendingChanges(docId, changes) {
-            const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
-            // Ensure the document is tracked
-            let docMeta = await docsStore.get(docId);
-            if (!docMeta) {
-                docMeta = { docId, committedRev: 0 };
-                await docsStore.put(docMeta);
-            }
-            else if (docMeta.deleted) {
-                delete docMeta.deleted;
-                await docsStore.put(docMeta);
-                console.warn(`Revived document ${docId} by replacing pending changes.`);
-            }
-            // Remove all existing pending changes and add the new ones
-            await pendingChanges.delete([docId, 0], [docId, Infinity]);
-            await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
-            await tx.complete();
-        }
-        // ─── Committed Changes ─────────────────────────────────────────────────────
-        /**
-         * Store server‐confirmed changes.  Will:
-         * - persist them in the committedChanges store
-         * - remove any pending changes whose rev falls within `sentPendingRange`
-         * - optionally compact a new snapshot after N changes (hidden internally)
-         * @param docId - The ID of the document to save the changes for
-         * @param changes - The changes to save
-         * @param sentPendingRange - The range of pending changes to remove, *must* be provided after receiving the changes
-         * from the server in response to a patchesDoc request.
-         */
-        async saveCommittedChanges(docId, changes, sentPendingRange) {
-            const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(['committedChanges', 'pendingChanges', 'snapshots', 'docs'], 'readwrite');
-            // Save committed changes
-            await Promise.all(changes.map(change => committedChanges.put({ ...change, docId })));
-            // Remove pending changes if range provided
-            if (sentPendingRange) {
-                await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
-            }
-            // Check if we should create a snapshot
-            const count = await committedChanges.count([docId, 0], [docId, Infinity]);
-            if (count >= SNAPSHOT_INTERVAL) {
-                // Update the snapshot. A snapshot will not be updated if there are pending changes based on revisions older than
-                // the latest committed change until those pending changes are committed.
-                const [snapshot, committed, firstPending] = await Promise.all([
-                    snapshots.get(docId),
-                    committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
-                    pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity]),
-                ]);
-                // Update the snapshot
-                const lastRev = committed[committed.length - 1]?.rev;
-                if (!firstPending?.baseRev || firstPending?.baseRev >= lastRev) {
-                    const state = applyChanges(snapshot?.state, committed);
-                    await Promise.all([
-                        snapshots.put({
-                            docId,
-                            rev: lastRev,
-                            state,
-                        }),
-                        committedChanges.delete([docId, 0], [docId, lastRev]),
-                    ]);
-                }
-            }
-            // Update committedRev in the docs store if changes were saved
-            const lastCommittedRev = changes.at(-1)?.rev;
-            if (lastCommittedRev !== undefined) {
-                const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
-                if (lastCommittedRev > docMeta.committedRev) {
-                    await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: undefined });
-                }
-            }
-            await tx.complete();
-        }
-        /**
-         * List all documents in the store.
-         * @param includeDeleted - Whether to include deleted documents.
-         * @returns The list of documents.
-         */
-        async listDocs(includeDeleted = false) {
-            const [tx, docsStore] = await this.transaction(['docs'], 'readonly');
-            const allDocs = await docsStore.getAll();
-            await tx.complete();
-            return includeDeleted ? allDocs : allDocs.filter(doc => !doc.deleted);
-        }
-        /**
-         * Track a document.
-         * @param docIds - The IDs of the documents to track.
-         */
-        async trackDocs(docIds) {
-            const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
-            await Promise.all(docIds.map(async (docId) => {
-                const existing = await docsStore.get(docId);
-                if (existing) {
-                    // If exists but deleted, undelete it
-                    if (existing.deleted) {
-                        await docsStore.put({ ...existing, deleted: undefined });
-                    }
-                    // Otherwise, it's already tracked and not deleted, do nothing
-                }
-                else {
-                    // If doesn't exist, add it
-                    await docsStore.put({ docId, committedRev: 0 });
-                }
-            }));
-            await tx.complete();
-        }
-        /**
-         * Untrack a document.
-         * @param docIds - The IDs of the documents to untrack.
-         */
-        async untrackDocs(docIds) {
-            const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readwrite');
-            await Promise.all(docIds.map(docId => {
-                return Promise.all([
-                    docsStore.delete(docId),
-                    snapshots.delete(docId),
-                    committedChanges.delete([docId, 0], [docId, Infinity]),
-                    pendingChanges.delete([docId, 0], [docId, Infinity]),
-                ]);
-            }));
-            await tx.complete();
-        }
-        /**
-         * Tell me the last committed revision you have *and* the highest
-         * rev of any change.  Use these to drive:
-         *   - fetch changes:   api.getChangesSince(docId, committedRev)
-         *   - build new patch: newChange.rev = pendingRev; baseRev = committedRev
-         */
-        async getLastRevs(docId) {
-            const [tx, committedChanges, pendingChanges] = await this.transaction(['committedChanges', 'pendingChanges'], 'readonly');
-            const [lastCommitted, lastPending] = await Promise.all([
-                committedChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
-                pendingChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
-            ]);
-            await tx.complete();
-            return [lastCommitted?.rev ?? 0, lastPending?.rev ?? lastCommitted?.rev ?? 0];
-        }
-    };
-})();
-export { IndexedDBStore };
-class IDBTransactionWrapper {
-    tx;
-    promise;
-    constructor(tx) {
-        this.tx = tx;
-        this.promise = new Promise((resolve, reject) => {
-            tx.oncomplete = () => resolve();
-            tx.onerror = () => reject(tx.error);
-        });
-    }
-    getStore(name) {
-        return new IDBStoreWrapper(this.tx.objectStore(name));
+_getDoc_dec = [blockable], _deleteDoc_dec = [blockable], _confirmDeleteDoc_dec = [blockable], _saveDoc_dec = [blockable], _savePendingChanges_dec = [blockable], _getPendingChanges_dec = [blockable], _replacePendingChanges_dec = [blockable], _saveCommittedChanges_dec = [blockable], _getLastRevs_dec = [blockable];
+class IndexedDBStore {
+  constructor(dbName) {
+    __runInitializers(_init, 5, this);
+    __publicField(this, "db", null);
+    __publicField(this, "dbName");
+    __publicField(this, "dbPromise");
+    this.dbName = dbName;
+    this.dbPromise = deferred();
+    if (this.dbName) {
+      this.initDB();
     }
-    async complete() {
-        return this.promise;
-    }
-}
-class IDBStoreWrapper {
-    store;
-    constructor(store) {
-        this.store = store;
+  }
+  async initDB() {
+    if (!this.dbName) return;
+    const request = indexedDB.open(this.dbName, DB_VERSION);
+    request.onerror = () => this.dbPromise.reject(request.error);
+    request.onsuccess = () => {
+      this.db = request.result;
+      this.dbPromise.resolve(this.db);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains("snapshots")) {
+        db.createObjectStore("snapshots", { keyPath: "docId" });
+      }
+      if (!db.objectStoreNames.contains("committedChanges")) {
+        db.createObjectStore("committedChanges", { keyPath: ["docId", "rev"] });
+      }
+      if (!db.objectStoreNames.contains("pendingChanges")) {
+        db.createObjectStore("pendingChanges", { keyPath: ["docId", "rev"] });
+      }
+      if (!db.objectStoreNames.contains("docs")) {
+        db.createObjectStore("docs", { keyPath: "docId" });
+      }
+    };
+  }
+  getDB() {
+    return this.dbPromise.promise;
+  }
+  /**
+   * Set the name of the database, loads a new database connection.
+   * @param dbName - The new name of the database.
+   */
+  setName(dbName) {
+    this.dbName = dbName;
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.dbPromise = deferred();
     }
-    createRange(lower, upper) {
-        if (lower === undefined && upper === undefined)
-            return undefined;
-        return IDBKeyRange.bound(lower, upper);
+    this.initDB();
+  }
+  /**
+   * Closes the database connection. After calling this method, the store
+   * will no longer be usable. A new instance must be created to reopen
+   * the database.
+   */
+  async close() {
+    await this.dbPromise.promise;
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.dbPromise = deferred();
+      this.dbPromise.resolve(null);
     }
-    async getAll(lower, upper, count) {
-        return new Promise((resolve, reject) => {
-            const request = this.store.getAll(this.createRange(lower, upper), count);
-            request.onsuccess = () => resolve(request.result);
-            request.onerror = () => reject(request.error);
-        });
+  }
+  async deleteDB() {
+    if (!this.dbName) return;
+    await this.close();
+    await new Promise((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(this.dbName);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+      request.onblocked = () => reject(request.error);
+    });
+  }
+  async transaction(storeNames, mode) {
+    const db = await this.getDB();
+    const tx = new IDBTransactionWrapper(db.transaction(storeNames, mode));
+    const stores = storeNames.map((name) => tx.getStore(name));
+    return [tx, ...stores];
+  }
+  async getDoc(docId) {
+    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
+      ["docs", "snapshots", "committedChanges", "pendingChanges"],
+      "readonly"
+    );
+    const docMeta = await docsStore.get(docId);
+    if (docMeta?.deleted) {
+      await tx.complete();
+      return void 0;
     }
-    async get(key) {
-        return new Promise((resolve, reject) => {
-            const request = this.store.get(key);
-            request.onsuccess = () => resolve(request.result);
-            request.onerror = () => reject(request.error);
-        });
+    const snapshot = await snapshots.get(docId);
+    const committed = await committedChanges.getAll([docId, snapshot?.rev ?? 0], [docId, Infinity]);
+    const pending = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
+    if (!snapshot && !committed.length && !pending.length) return void 0;
+    const state = applyChanges(snapshot?.state, committed);
+    const lastCommitted = committed[committed.length - 1];
+    const baseRev = pending[0]?.baseRev;
+    if (lastCommitted && baseRev && baseRev < lastCommitted.rev) {
+      const patch = committed.filter((change) => change.rev > baseRev).map((change) => change.ops).flat();
+      const offset = lastCommitted.rev - baseRev;
+      pending.forEach((change) => {
+        change.rev += offset;
+        change.ops = transformPatch(state, patch, change.ops);
+      });
     }
-    async put(value) {
-        return new Promise((resolve, reject) => {
-            const request = this.store.put(value);
-            request.onsuccess = () => resolve(request.result);
-            request.onerror = () => reject(request.error);
-        });
+    await tx.complete();
+    return {
+      state,
+      rev: committed[committed.length - 1]?.rev ?? snapshot?.rev ?? 0,
+      changes: pending
+    };
+  }
+  async deleteDoc(docId) {
+    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
+      ["snapshots", "committedChanges", "pendingChanges", "docs"],
+      "readwrite"
+    );
+    const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
+    await docsStore.put({ ...docMeta, deleted: true });
+    await Promise.all([
+      snapshots.delete(docId),
+      committedChanges.delete([docId, 0], [docId, Infinity]),
+      pendingChanges.delete([docId, 0], [docId, Infinity])
+    ]);
+    await tx.complete();
+  }
+  async confirmDeleteDoc(docId) {
+    const [tx, docsStore] = await this.transaction(["docs"], "readwrite");
+    await docsStore.delete(docId);
+    await tx.complete();
+  }
+  async saveDoc(docId, docState) {
+    const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(
+      ["snapshots", "committedChanges", "pendingChanges", "docs"],
+      "readwrite"
+    );
+    const { rev, state } = docState;
+    await Promise.all([
+      docsStore.put({ docId, committedRev: rev }),
+      snapshots.put({ docId, state, rev }),
+      committedChanges.delete([docId, 0], [docId, Infinity]),
+      pendingChanges.delete([docId, 0], [docId, Infinity])
+    ]);
+    await tx.complete();
+  }
+  async savePendingChanges(docId, changes) {
+    const [tx, pendingChanges, docsStore] = await this.transaction(["pendingChanges", "docs"], "readwrite");
+    let docMeta = await docsStore.get(docId);
+    if (!docMeta) {
+      docMeta = { docId, committedRev: 0 };
+      await docsStore.put(docMeta);
+    } else if (docMeta.deleted) {
+      delete docMeta.deleted;
+      await docsStore.put(docMeta);
+      console.warn(`Revived document ${docId} by saving pending changes.`);
     }
-    async delete(keyOrLower, upper) {
-        return new Promise((resolve, reject) => {
-            const key = upper === undefined ? keyOrLower : this.createRange(keyOrLower, upper);
-            const request = this.store.delete(key);
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
-        });
+    await Promise.all(changes.map((change) => pendingChanges.put({ ...change, docId })));
+    await tx.complete();
+  }
+  async getPendingChanges(docId) {
+    const [tx, pendingChanges] = await this.transaction(["pendingChanges"], "readonly");
+    const result = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
+    await tx.complete();
+    return result;
+  }
+  async replacePendingChanges(docId, changes) {
+    const [tx, pendingChanges, docsStore] = await this.transaction(["pendingChanges", "docs"], "readwrite");
+    let docMeta = await docsStore.get(docId);
+    if (!docMeta) {
+      docMeta = { docId, committedRev: 0 };
+      await docsStore.put(docMeta);
+    } else if (docMeta.deleted) {
+      delete docMeta.deleted;
+      await docsStore.put(docMeta);
+      console.warn(`Revived document ${docId} by replacing pending changes.`);
     }
-    async count(lower, upper) {
-        return new Promise((resolve, reject) => {
-            const request = this.store.count(this.createRange(lower, upper));
-            request.onsuccess = () => resolve(request.result);
-            request.onerror = () => reject(request.error);
-        });
+    await pendingChanges.delete([docId, 0], [docId, Infinity]);
+    await Promise.all(changes.map((change) => pendingChanges.put({ ...change, docId })));
+    await tx.complete();
+  }
+  async saveCommittedChanges(docId, changes, sentPendingRange) {
+    const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(
+      ["committedChanges", "pendingChanges", "snapshots", "docs"],
+      "readwrite"
+    );
+    await Promise.all(changes.map((change) => committedChanges.put({ ...change, docId })));
+    if (sentPendingRange) {
+      await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
     }
-    async getFirstFromCursor(lower, upper) {
-        return new Promise((resolve, reject) => {
-            const request = this.store.openCursor(this.createRange(lower, upper));
-            request.onsuccess = () => resolve(request.result?.value);
-            request.onerror = () => reject(request.error);
-        });
+    const count = await committedChanges.count([docId, 0], [docId, Infinity]);
+    if (count >= SNAPSHOT_INTERVAL) {
+      const [snapshot, committed, firstPending] = await Promise.all([
+        snapshots.get(docId),
+        committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
+        pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity])
+      ]);
+      const lastRev = committed[committed.length - 1]?.rev;
+      if (!firstPending?.baseRev || firstPending?.baseRev >= lastRev) {
+        const state = applyChanges(snapshot?.state, committed);
+        await Promise.all([
+          snapshots.put({
+            docId,
+            rev: lastRev,
+            state
+          }),
+          committedChanges.delete([docId, 0], [docId, lastRev])
+        ]);
+      }
     }
-    async getLastFromCursor(lower, upper) {
-        return new Promise((resolve, reject) => {
-            const request = this.store.openCursor(this.createRange(lower, upper), 'prev');
-            request.onsuccess = () => resolve(request.result?.value);
-            request.onerror = () => reject(request.error);
-        });
+    const lastCommittedRev = changes.at(-1)?.rev;
+    if (lastCommittedRev !== void 0) {
+      const docMeta = await docsStore.get(docId) ?? { docId, committedRev: 0 };
+      if (lastCommittedRev > docMeta.committedRev) {
+        await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: void 0 });
+      }
     }
+    await tx.complete();
+  }
+  /**
+   * List all documents in the store.
+   * @param includeDeleted - Whether to include deleted documents.
+   * @returns The list of documents.
+   */
+  async listDocs(includeDeleted = false) {
+    const [tx, docsStore] = await this.transaction(["docs"], "readonly");
+    const allDocs = await docsStore.getAll();
+    await tx.complete();
+    return includeDeleted ? allDocs : allDocs.filter((doc) => !doc.deleted);
+  }
+  /**
+   * Track a document.
+   * @param docIds - The IDs of the documents to track.
+   */
+  async trackDocs(docIds) {
+    const [tx, docsStore] = await this.transaction(["docs"], "readwrite");
+    await Promise.all(
+      docIds.map(async (docId) => {
+        const existing = await docsStore.get(docId);
+        if (existing) {
+          if (existing.deleted) {
+            await docsStore.put({ ...existing, deleted: void 0 });
+          }
+        } else {
+          await docsStore.put({ docId, committedRev: 0 });
+        }
+      })
+    );
+    await tx.complete();
+  }
+  /**
+   * Untrack a document.
+   * @param docIds - The IDs of the documents to untrack.
+   */
+  async untrackDocs(docIds) {
+    const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(
+      ["docs", "snapshots", "committedChanges", "pendingChanges"],
+      "readwrite"
+    );
+    await Promise.all(
+      docIds.map((docId) => {
+        return Promise.all([
+          docsStore.delete(docId),
+          snapshots.delete(docId),
+          committedChanges.delete([docId, 0], [docId, Infinity]),
+          pendingChanges.delete([docId, 0], [docId, Infinity])
+        ]);
+      })
+    );
+    await tx.complete();
+  }
+  async getLastRevs(docId) {
+    const [tx, committedChanges, pendingChanges] = await this.transaction(
+      ["committedChanges", "pendingChanges"],
+      "readonly"
+    );
+    const [lastCommitted, lastPending] = await Promise.all([
+      committedChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
+      pendingChanges.getLastFromCursor([docId, 0], [docId, Infinity])
+    ]);
+    await tx.complete();
+    return [lastCommitted?.rev ?? 0, lastPending?.rev ?? lastCommitted?.rev ?? 0];
+  }
 }
+_init = __decoratorStart(null);
+__decorateElement(_init, 1, "getDoc", _getDoc_dec, IndexedDBStore);
+__decorateElement(_init, 1, "deleteDoc", _deleteDoc_dec, IndexedDBStore);
+__decorateElement(_init, 1, "confirmDeleteDoc", _confirmDeleteDoc_dec, IndexedDBStore);
+__decorateElement(_init, 1, "saveDoc", _saveDoc_dec, IndexedDBStore);
+__decorateElement(_init, 1, "savePendingChanges", _savePendingChanges_dec, IndexedDBStore);
+__decorateElement(_init, 1, "getPendingChanges", _getPendingChanges_dec, IndexedDBStore);
+__decorateElement(_init, 1, "replacePendingChanges", _replacePendingChanges_dec, IndexedDBStore);
+__decorateElement(_init, 1, "saveCommittedChanges", _saveCommittedChanges_dec, IndexedDBStore);
+__decorateElement(_init, 1, "getLastRevs", _getLastRevs_dec, IndexedDBStore);
+__decoratorMetadata(_init, IndexedDBStore);
+class IDBTransactionWrapper {
+  tx;
+  promise;
+  constructor(tx) {
+    this.tx = tx;
+    this.promise = new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  getStore(name) {
+    return new IDBStoreWrapper(this.tx.objectStore(name));
+  }
+  async complete() {
+    return this.promise;
+  }
+}
+class IDBStoreWrapper {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  createRange(lower, upper) {
+    if (lower === void 0 && upper === void 0) return void 0;
+    return IDBKeyRange.bound(lower, upper);
+  }
+  async getAll(lower, upper, count) {
+    return new Promise((resolve, reject) => {
+      const request = this.store.getAll(this.createRange(lower, upper), count);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async get(key) {
+    return new Promise((resolve, reject) => {
+      const request = this.store.get(key);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async put(value) {
+    return new Promise((resolve, reject) => {
+      const request = this.store.put(value);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async delete(keyOrLower, upper) {
+    return new Promise((resolve, reject) => {
+      const key = upper === void 0 ? keyOrLower : this.createRange(keyOrLower, upper);
+      const request = this.store.delete(key);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async count(lower, upper) {
+    return new Promise((resolve, reject) => {
+      const request = this.store.count(this.createRange(lower, upper));
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getFirstFromCursor(lower, upper) {
+    return new Promise((resolve, reject) => {
+      const request = this.store.openCursor(this.createRange(lower, upper));
+      request.onsuccess = () => resolve(request.result?.value);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getLastFromCursor(lower, upper) {
+    return new Promise((resolve, reject) => {
+      const request = this.store.openCursor(this.createRange(lower, upper), "prev");
+      request.onsuccess = () => resolve(request.result?.value);
+      request.onerror = () => reject(request.error);
+    });
+  }
+}
+export {
+  IndexedDBStore
+};