@loro-dev/flock-sqlite 0.7.0 → 0.9.0

package/src/lru.ts

@@ -0,0 +1,74 @@
+export class LruMap<K, V> {
+  private readonly map = new Map<K, V>();
+
+  constructor(private readonly maxSize: number) {
+    if (!Number.isFinite(maxSize) || maxSize <= 0) {
+      throw new Error(`LruMap maxSize must be a positive number, got ${maxSize}`);
+    }
+  }
+
+  get size(): number {
+    return this.map.size;
+  }
+
+  has(key: K): boolean {
+    return this.map.has(key);
+  }
+
+  get(key: K): V | undefined {
+    if (!this.map.has(key)) {
+      return undefined;
+    }
+    const value = this.map.get(key) as V;
+    // Refresh recency.
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+
+  set(key: K, value: V): void {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    }
+    this.map.set(key, value);
+    this.evictIfNeeded();
+  }
+
+  delete(key: K): boolean {
+    return this.map.delete(key);
+  }
+
+  clear(): void {
+    this.map.clear();
+  }
+
+  private evictIfNeeded(): void {
+    while (this.map.size > this.maxSize) {
+      const oldest = this.map.keys().next().value as K | undefined;
+      if (oldest === undefined) {
+        return;
+      }
+      this.map.delete(oldest);
+    }
+  }
+}
+
+export class LruSet<T> {
+  private readonly map: LruMap<T, true>;
+
+  constructor(maxSize: number) {
+    this.map = new LruMap<T, true>(maxSize);
+  }
+
+  has(value: T): boolean {
+    return this.map.get(value) !== undefined;
+  }
+
+  add(value: T): void {
+    this.map.set(value, true);
+  }
+
+  clear(): void {
+    this.map.clear();
+  }
+}

package/src/multi-tab-env.ts

@@ -0,0 +1,79 @@
+import type { FlockSQLiteRole } from "./types";
+
+export type FlockTransport = {
+  postMessage(message: unknown): void;
+  subscribe(onMessage: (message: unknown) => void): () => void;
+  close?: () => void;
+};
+
+export type FlockTransportFactory = (name: string) => FlockTransport | undefined;
+
+export type FlockRoleProvider = {
+  getRole(): FlockSQLiteRole;
+  subscribeRoleChange?: (listener: (role: FlockSQLiteRole) => void) => () => void;
+};
+
+export type TimeoutHandle = unknown;
+
+export type FlockRuntime = {
+  now(): number;
+  setTimeout(fn: () => void, ms: number): TimeoutHandle;
+  clearTimeout(handle: TimeoutHandle): void;
+  randomUUID(): string;
+};
+
+export function createDefaultRuntime(): FlockRuntime {
+  return {
+    now: () => Date.now(),
+    setTimeout: (fn, ms) => setTimeout(fn, ms) as unknown,
+    clearTimeout: (handle) => clearTimeout(handle as any),
+    randomUUID: () => {
+      try {
+        if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+          return crypto.randomUUID();
+        }
+      } catch {
+        // ignore
+      }
+      return `${Date.now()}_${Math.random().toString(16).slice(2)}`;
+    },
+  };
+}
+
+export function createBroadcastChannelTransport(name: string): FlockTransport | undefined {
+  if (typeof BroadcastChannel === "undefined") {
+    return undefined;
+  }
+
+  try {
+    const channel = new BroadcastChannel(name);
+
+    return {
+      postMessage: (message) => {
+        try {
+          channel.postMessage(message);
+        } catch {
+          // Swallow transport errors to avoid breaking the CRDT/sync pipeline.
+        }
+      },
+      subscribe: (onMessage) => {
+        const handler = (event: MessageEvent) => {
+          onMessage(event.data);
+        };
+        channel.addEventListener("message", handler);
+        return () => {
+          channel.removeEventListener("message", handler);
+        };
+      },
+      close: () => {
+        try {
+          channel.close();
+        } catch {
+          // ignore
+        }
+      },
+    };
+  } catch {
+    return undefined;
+  }
+}

package/src/multi-tab.ts

@@ -0,0 +1,107 @@
+import type { EntryClock, ExportBundle, ExportPayload, KeyPart, Value } from "./types";
+
+export type TabId = string;
+export type RequestId = string;
+
+export type FlockCommit = {
+  commitId: string;
+  origin: TabId;
+  source: string;
+  events: Array<{
+    key: KeyPart[];
+    clock: EntryClock;
+    payload: ExportPayload;
+  }>;
+  /** Optional meta updates that consumers should apply. */
+  meta?: {
+    peerId?: string;
+  };
+};
+
+export type FlockWriteRequest =
+  | {
+      kind: "apply";
+      source: "local";
+      key: KeyPart[];
+      payload: ExportPayload;
+      now?: number;
+      skipSameValue: boolean;
+    }
+  | {
+      kind: "putMvr";
+      source: "local";
+      key: KeyPart[];
+      value: Value;
+      now?: number;
+    }
+  | {
+      kind: "import";
+      source: "import";
+      bundle: ExportBundle;
+    }
+  | {
+      kind: "setPeerId";
+      source: "meta";
+      peerId: string;
+    };
+
+export type FlockRpcRequest = {
+  t: "req";
+  from: TabId;
+  id: RequestId;
+  payload: FlockWriteRequest;
+};
+
+export type FlockRpcResponse = {
+  t: "res";
+  to: TabId;
+  id: RequestId;
+  ok: boolean;
+  commit?: FlockCommit;
+  result?: unknown;
+  error?: { name: string; message: string; stack?: string };
+};
+
+export type FlockCommitMessage = {
+  t: "commit";
+  commit: FlockCommit;
+};
+
+export type FlockChannelMessage = FlockRpcRequest | FlockRpcResponse | FlockCommitMessage;
+
+export function isFlockChannelMessage(message: unknown): message is FlockChannelMessage {
+  if (!message || typeof message !== "object") {
+    return false;
+  }
+  const candidate = message as { t?: unknown };
+  return candidate.t === "req" || candidate.t === "res" || candidate.t === "commit";
+}
+
+export function createRequestId(): RequestId {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch {
+    // ignore
+  }
+  return `req_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+
+export function createTabId(): TabId {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+  } catch {
+    // ignore
+  }
+  return `tab_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+
+export function serializeError(error: unknown): { name: string; message: string; stack?: string } {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message, stack: error.stack };
+  }
+  return { name: "Error", message: String(error) };
+}

package/src/types.ts

@@ -101,6 +101,7 @@ export type EventPayload = ExportPayload;
 
 export type Event = {
   key: KeyPart[];
+  clock: EntryClock;
   value?: Value;
   metadata?: MetadataMap;
   payload: EventPayload;
@@ -111,6 +112,8 @@ export type EventBatch = {
   events: Event[];
 };
 
+export type FlockSQLiteRole = "host" | "participant" | "unknown";
+
 export type ExportOptions = {
   from?: VersionVector;
   hooks?: ExportHooks;
@@ -144,3 +147,5 @@ export type PutWithMetaOptions = {
 };
 
 export type EventListener = (batch: EventBatch) => void;
+
+export type RoleChangeListener = (role: FlockSQLiteRole) => void;