@loro-dev/flock-sqlite 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loro-dev/flock-sqlite",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "SQLite-backed Flock CRDT replica for Node, browsers, and Cloudflare Workers.",
   "type": "module",
   "exports": {
@@ -63,7 +63,7 @@
     "tsdown": "^0.15.4",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
-    "@loro-dev/flock": "4.4.0",
+    "@loro-dev/flock": "4.4.1",
     "@loro-dev/unisqlite": "0.6.0"
   },
   "scripts": {

package/src/event-batcher.ts

@@ -1,22 +1,31 @@
-import type { FlockRuntime, TimeoutHandle } from "./multi-tab-env";
+export type TimeoutHandle = unknown;
+
+export type EventBatcherRuntime = {
+  now(): number;
+  setTimeout(fn: () => void, ms: number): TimeoutHandle;
+  clearTimeout(handle: TimeoutHandle): void;
+};
 
 export class EventBatcher<TEvent> {
+  private outbox: Array<{ source: string; events: TEvent[] }> = [];
+  private outboxCursor = 0;
+  private draining = false;
   private txnEventSink: TEvent[] | undefined;
   private debounceState:
     | {
         timeout: number;
         maxDebounceTime: number;
         timerId: TimeoutHandle;
-        maxTimerId: TimeoutHandle;
+        deadlineAt: number | undefined;
         pendingEvents: TEvent[];
       }
     | undefined;
 
-  private readonly runtime: FlockRuntime;
+  private readonly runtime: EventBatcherRuntime;
   private readonly emit: (source: string, events: TEvent[]) => void;
 
   constructor(options: {
-    runtime: FlockRuntime;
+    runtime: EventBatcherRuntime;
     emit: (source: string, events: TEvent[]) => void;
   }) {
     this.runtime = options.runtime;
@@ -39,11 +48,11 @@ export class EventBatcher<TEvent> {
       return;
     }
     if (bufferable && this.debounceState) {
-      this.debounceState.pendingEvents.push(...events);
-      this.resetDebounceTimer();
+      this.bufferLocalEvents(events);
       return;
     }
-    this.emit(source, events);
+
+    this.enqueueBatch({ source, events });
   }
 
   beforeImport(): void {
@@ -68,7 +77,8 @@ export class EventBatcher<TEvent> {
     try {
       const result = await callback();
       if (eventSink.length > 0) {
-        this.emit("local", eventSink);
+        this.txnEventSink = undefined;
+        this.enqueueBatch({ source: "local", events: eventSink });
       }
       return result;
     } finally {
@@ -99,7 +109,7 @@ export class EventBatcher<TEvent> {
       timeout,
       maxDebounceTime,
       timerId: undefined,
-      maxTimerId: undefined,
+      deadlineAt: undefined,
       pendingEvents: [],
     };
   }
@@ -109,17 +119,10 @@ export class EventBatcher<TEvent> {
       return;
     }
 
-    const { timerId, maxTimerId, pendingEvents } = this.debounceState;
-    if (timerId !== undefined) {
-      this.runtime.clearTimeout(timerId);
-    }
-    if (maxTimerId !== undefined) {
-      this.runtime.clearTimeout(maxTimerId);
-    }
+    const eventsToEmit = this.takeDebouncedEvents();
     this.debounceState = undefined;
-
-    if (pendingEvents.length > 0) {
-      this.emit("local", pendingEvents);
+    if (eventsToEmit.length > 0) {
+      this.enqueueBatch({ source: "local", events: eventsToEmit });
     }
   }
 
@@ -127,21 +130,7 @@ export class EventBatcher<TEvent> {
     if (this.debounceState === undefined) {
       return;
     }
-
-    const { timerId, maxTimerId, pendingEvents } = this.debounceState;
-    if (timerId !== undefined) {
-      this.runtime.clearTimeout(timerId);
-      this.debounceState.timerId = undefined;
-    }
-    if (maxTimerId !== undefined) {
-      this.runtime.clearTimeout(maxTimerId);
-      this.debounceState.maxTimerId = undefined;
-    }
-
-    if (pendingEvents.length > 0) {
-      this.emit("local", pendingEvents);
-      this.debounceState.pendingEvents = [];
-    }
+    this.flushDebouncedEvents();
   }
 
   isAutoDebounceActive(): boolean {
@@ -159,31 +148,117 @@ export class EventBatcher<TEvent> {
       const pending = this.txnEventSink;
       this.txnEventSink = undefined;
       if (pending.length > 0) {
-        this.emit("local", pending);
+        const eventsToEmit = pending.slice();
+        pending.length = 0;
+        this.enqueueBatch({ source: "local", events: eventsToEmit });
       }
     }
   }
 
-  private resetDebounceTimer(): void {
+  private enqueueBatch(batch: { source: string; events: TEvent[] }): void {
+    this.outbox.push(batch);
+    this.drainOutbox();
+  }
+
+  private drainOutbox(): void {
+    if (this.draining) {
+      return;
+    }
+    this.draining = true;
+    try {
+      while (this.outboxCursor < this.outbox.length) {
+        const batch = this.outbox[this.outboxCursor];
+        this.outboxCursor += 1;
+        this.deliverBatch(batch);
+      }
+    } finally {
+      this.outbox = [];
+      this.outboxCursor = 0;
+      this.draining = false;
+    }
+  }
+
+  private deliverBatch(batch: { source: string; events: TEvent[] }): void {
+    try {
+      this.emit(batch.source, batch.events);
+    } catch (error) {
+      void error;
+    }
+  }
+
+  private bufferLocalEvents(events: TEvent[]): void {
     if (this.debounceState === undefined) {
       return;
     }
+    if (events.length === 0) {
+      return;
+    }
+    const state = this.debounceState;
+    const now = this.runtime.now();
+    if (state.pendingEvents.length === 0) {
+      state.deadlineAt = now + state.maxDebounceTime;
+    }
+    state.pendingEvents.push(...events);
+    this.scheduleDebounceFlush(now);
+  }
 
-    if (this.debounceState.timerId !== undefined) {
-      this.runtime.clearTimeout(this.debounceState.timerId);
+  private scheduleDebounceFlush(now: number): void {
+    if (this.debounceState === undefined) {
+      return;
+    }
+    const state = this.debounceState;
+    if (state.pendingEvents.length === 0) {
+      return;
+    }
+    if (state.timeout <= 0) {
+      this.flushDebouncedEvents();
+      return;
     }
 
-    this.debounceState.timerId = this.runtime.setTimeout(() => {
-      this.commit();
-    }, this.debounceState.timeout);
+    const deadlineAt = state.deadlineAt ?? now + state.maxDebounceTime;
+    state.deadlineAt = deadlineAt;
+    const dueAt = Math.min(now + state.timeout, deadlineAt);
+
+    if (dueAt <= now) {
+      this.flushDebouncedEvents();
+      return;
+    }
+
+    if (state.timerId !== undefined) {
+      this.runtime.clearTimeout(state.timerId);
+    }
+
+    state.timerId = this.runtime.setTimeout(() => {
+      this.flushDebouncedEvents();
+    }, Math.max(0, dueAt - now));
+  }
 
-    if (
-      this.debounceState.maxTimerId === undefined &&
-      this.debounceState.pendingEvents.length === 1
-    ) {
-      this.debounceState.maxTimerId = this.runtime.setTimeout(() => {
-        this.commit();
-      }, this.debounceState.maxDebounceTime);
+  private takeDebouncedEvents(): TEvent[] {
+    if (this.debounceState === undefined) {
+      return [];
+    }
+    const state = this.debounceState;
+
+    if (state.timerId !== undefined) {
+      this.runtime.clearTimeout(state.timerId);
+      state.timerId = undefined;
+    }
+    state.deadlineAt = undefined;
+
+    if (state.pendingEvents.length === 0) {
+      return [];
+    }
+
+    const eventsToEmit = state.pendingEvents;
+    state.pendingEvents = [];
+    return eventsToEmit;
+  }
+
+  private flushDebouncedEvents(): void {
+    const eventsToEmit = this.takeDebouncedEvents();
+    if (eventsToEmit.length === 0) {
+      return;
     }
+    this.enqueueBatch({ source: "local", events: eventsToEmit });
   }
 }

package/src/index.ts

@@ -94,7 +94,7 @@ type EncodableVersionVectorEntry = {
   counter: number;
 };
 
-export interface VersionVector extends VersionVectorType {}
+export interface VersionVector extends VersionVectorType { }
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -701,13 +701,13 @@ function createDefaultRoleProvider(db: UniStoreConnection): FlockRoleProvider {
     subscribeRoleChange:
       typeof subscribeRoleChange === "function"
         ? (listener) =>
-            subscribeRoleChange.call(db, (role) => {
-              const normalized = normalizeRole(role);
-              if (!normalized) {
-                return;
-              }
-              listener(normalized);
-            })
+          subscribeRoleChange.call(db, (role) => {
+            const normalized = normalizeRole(role);
+            if (!normalized) {
+              return;
+            }
+            listener(normalized);
+          })
         : undefined,
   };
 }
@@ -1021,9 +1021,9 @@ export class FlockSQLite {
     const maxHlc =
       first && Number.isFinite(first.physical) && Number.isFinite(first.logical)
         ? {
-            physicalTime: Number(first.physical),
-            logicalCounter: Number(first.logical),
-          }
+          physicalTime: Number(first.physical),
+          logicalCounter: Number(first.logical),
+        }
         : { physicalTime: 0, logicalCounter: 0 };
     return { vv, maxHlc };
   }
@@ -1203,9 +1203,14 @@ export class FlockSQLite {
         }),
       ),
     };
-    this.listeners.forEach((listener) => {
-      listener(batch);
-    });
+    const listeners = Array.from(this.listeners);
+    for (const listener of listeners) {
+      try {
+        listener(batch);
+      } catch (error) {
+        console.error(error);
+      }
+    }
   }
 
   async put(key: KeyPart[], value: Value, now?: number): Promise<void> {
@@ -1555,9 +1560,9 @@ export class FlockSQLite {
     }
     const postFilter = prefixFilter
       ? (
-          (pf: Uint8Array) => (bytes: Uint8Array) =>
-            keyMatchesPrefix(bytes, pf)
-        )(prefixFilter)
+        (pf: Uint8Array) => (bytes: Uint8Array) =>
+          keyMatchesPrefix(bytes, pf)
+      )(prefixFilter)
       : undefined;
     return { where, params, postFilter };
   }