@fireproof/core 0.14.8 → 0.15.0-dev

package/dist/browser/fireproof.cjs

@@ -11605,7 +11605,7 @@ replaceTraps((oldTraps) => ({
 }));
 
 // src/version.ts
-var PACKAGE_VERSION = "0.14.8";
+var PACKAGE_VERSION = "0.15.0-dev";
 
 // src/store.ts
 var match = PACKAGE_VERSION.match(/^([^.]*\.[^.]*)/);
@@ -11634,11 +11634,11 @@ var MetaStore = class extends VersionedStore {
   }
 };
 var DataStore = class {
-  constructor(loader) {
+  constructor(name8) {
     __publicField(this, "tag", "car-base");
     __publicField(this, "STORAGE_VERSION", STORAGE_VERSION);
-    __publicField(this, "loader");
-    this.loader = loader;
+    __publicField(this, "name");
+    this.name = name8;
   }
 };
 
@@ -11803,7 +11803,7 @@ var DataStore2 = class extends DataStore {
   }
   async _withDB(dbWorkFun) {
     if (!this.idb) {
-      const dbName = `fp.${this.STORAGE_VERSION}.${this.loader.keyId}.${this.loader.name}`;
+      const dbName = `fp.${this.STORAGE_VERSION}.${this.name}`;
       this.idb = await openDB(dbName, 1, {
         upgrade(db) {
           db.createObjectStore("cars");
@@ -11938,7 +11938,7 @@ var Loader = class {
     this.name = name8;
     this.opts = opts || this.opts;
     this.metaStore = new MetaStore2(this.name);
-    this.carStore = new DataStore2(this);
+    this.carStore = new DataStore2(this.name);
     this.remoteWAL = new RemoteWAL2(this);
     this.ready = Promise.resolve().then(async () => {
       if (!this.metaStore || !this.carStore || !this.remoteWAL)
@@ -21012,7 +21012,7 @@ var _DbLoader = class _DbLoader extends Loader {
     __publicField(this, "writing", Promise.resolve());
     __publicField(this, "remoteFileStore");
     __publicField(this, "fileStore");
-    this.fileStore = new DataStore2(this);
+    this.fileStore = new DataStore2(this.name);
     this.clock = clock;
   }
   async _readyForMerge() {
@@ -21220,7 +21220,7 @@ function applyHeadQueue(worker) {
         const task = queue.shift();
         if (!task)
           continue;
-        await worker(task.id, task.newHead, task.prevHead, task.updates);
+        await worker(task.newHead, task.prevHead);
         if (task.updates) {
           allUpdates.push(...task.updates);
         }
@@ -21250,7 +21250,7 @@ function applyHeadQueue(worker) {
 // src/crdt-clock.ts
 var CRDTClock = class {
   constructor() {
-    // todo: keep the clock of remote and local changes separate, merge on read
+    // todo: track local and remote clocks independently, merge on read
     // that way we can drop the whole remote if we need to
     // should go with making sure the local clock only references locally available blocks on write
     __publicField(this, "head", []);
@@ -21265,68 +21265,22 @@ var CRDTClock = class {
     this.head = head;
   }
   async applyHead(newHead, prevHead, updates = null) {
-    const taskId = Math.random().toString().slice(2, 8);
     for await (const { updates: updatesAcc, all } of this.applyHeadQueue.push({
-      id: taskId,
-      // tblocks,
       newHead,
       prevHead,
       updates
     })) {
-      ;
-      ((updatesAcc2, all2) => {
-        void Promise.resolve().then(async () => {
-          let intUpdates = updatesAcc2;
-          if (this.watchers.size && !all2) {
-            const changes = await clockChangesSince(this.blocks, this.head, prevHead, {});
-            intUpdates = changes.result;
-          }
-          this.zoomers.forEach((fn) => fn());
-          this.notifyWatchers(intUpdates || []);
-        });
-      })([...updatesAcc], all);
+      this.processUpdates(updatesAcc, all, prevHead);
     }
   }
-  async int_applyHead(taskId, newHead, prevHead) {
-    const ogHead = this.head.sort((a, b) => a.toString().localeCompare(b.toString()));
-    newHead = newHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-    newHead.map(async (cid) => {
-      const got = await this.blocks.get(cid);
-      if (!got) {
-        throw new Error("int_applyHead missing block: " + cid.toString());
-      }
-    });
-    if (ogHead.toString() === newHead.toString()) {
-      return;
-    }
-    const ogPrev = prevHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-    if (ogHead.toString() === ogPrev.toString()) {
-      this.setHead(newHead);
-      return;
+  async processUpdates(updatesAcc, all, prevHead) {
+    let internalUpdates = updatesAcc;
+    if (this.watchers.size && !all) {
+      const changes = await clockChangesSince(this.blocks, this.head, prevHead, {});
+      internalUpdates = changes.result;
     }
-    let head = this.head;
-    const noLoader = false;
-    const withBlocks = async (fn) => {
-      if (!this.blocks)
-        throw new Error("missing blocks");
-      return await this.blocks.transaction(fn, void 0, { noLoader });
-    };
-    await withBlocks(async (tblocks) => {
-      for (const cid of newHead) {
-        try {
-          head = await advance(tblocks, head, cid);
-        } catch (e) {
-          console.error("failed to advance", cid.toString(), e);
-          continue;
-        }
-      }
-      const result = await root(tblocks, head);
-      for (const { cid, bytes } of [...result.additions, ...result.removals]) {
-        tblocks.putSync(cid, bytes);
-      }
-      return { head };
-    });
-    this.setHead(head);
+    this.zoomers.forEach((fn) => fn());
+    this.notifyWatchers(internalUpdates || []);
   }
   notifyWatchers(updates) {
     this.emptyWatchers.forEach((fn) => fn());
@@ -21341,7 +21295,62 @@ var CRDTClock = class {
   onZoom(fn) {
     this.zoomers.add(fn);
   }
+  async int_applyHead(newHead, prevHead) {
+    const ogHead = sortClockHead(this.head);
+    newHead = sortClockHead(newHead);
+    await validateBlocks(newHead, this.blocks);
+    if (compareClockHeads(ogHead, newHead)) {
+      return;
+    }
+    const ogPrev = sortClockHead(prevHead);
+    if (compareClockHeads(ogHead, ogPrev)) {
+      this.setHead(newHead);
+      return;
+    }
+    let head = this.head;
+    const noLoader = false;
+    if (!this.blocks)
+      throw new Error("missing blocks");
+    await this.blocks.transaction(
+      async (tblocks) => {
+        head = await advanceBlocks(newHead, tblocks, head);
+        const result = await root(tblocks, head);
+        for (const { cid, bytes } of [...result.additions, ...result.removals]) {
+          tblocks.putSync(cid, bytes);
+        }
+        return { head };
+      },
+      void 0,
+      { noLoader }
+    );
+    this.setHead(head);
+  }
 };
+function sortClockHead(clockHead) {
+  return clockHead.sort((a, b) => a.toString().localeCompare(b.toString()));
+}
+async function validateBlocks(newHead, blocks) {
+  newHead.map(async (cid) => {
+    const got = await blocks.get(cid);
+    if (!got) {
+      throw new Error("int_applyHead missing block: " + cid.toString());
+    }
+  });
+}
+function compareClockHeads(head1, head2) {
+  return head1.toString() === head2.toString();
+}
+async function advanceBlocks(newHead, tblocks, head) {
+  for (const cid of newHead) {
+    try {
+      head = await advance(tblocks, head, cid);
+    } catch (e) {
+      console.error("failed to advance", cid.toString(), e);
+      continue;
+    }
+  }
+  return head;
+}
 
 // src/crdt.ts
 var CRDT = class {
@@ -21515,6 +21524,9 @@ var Database = class {
     }));
     return { rows, clock: head };
   }
+  async allDocuments() {
+    return this.allDocs();
+  }
   subscribe(listener, updates) {
     if (updates) {
       if (!this._listening) {