@evolu/react-native 15.0.0-next.0 → 15.0.0-next.2

package/dist/src/sqlite-drivers/createOpSqliteDriver.js

@@ -1,37 +1,119 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { bytesToHex, createPreparedStatementsCache, lazyVoid, ok, } from "@evolu/common";
 import { open } from "@op-engineering/op-sqlite";
 export const createOpSqliteDriver = (name, options) => () => {
-    // https://op-engineering.github.io/op-sqlite/docs/configuration#in-memory
-    const stack = new globalThis.DisposableStack();
-    const db = stack.adopt(open(options?.mode === "memory"
-        ? { name: `inMemoryDb`, location: ":memory:" }
-        : {
-            name: `evolu1-${name}.db`,
-            ...(options?.mode === "encrypted" && {
-                encryptionKey: `x'${bytesToHex(options.encryptionKey)}'`,
-            }),
-        }), (db) => {
-        db.close();
-    });
-    const cache = stack.use(createPreparedStatementsCache((sql) => db.prepareStatement(sql), 
-    // op-sqlite doesn't have API for that
-    lazyVoid));
-    return ok({
-        exec: (query) => {
-            const prepared = cache.get(query);
-            if (prepared) {
-                prepared.bindSync(query.parameters);
-            }
-            const { rows, rowsAffected } = db.executeSync(query.sql, query.parameters);
-            return { rows: rows, changes: rowsAffected };
-        },
-        // FIXME: op-sqlite does not expose binary, but a path to the database file
-        // another react native dependency would be needed to implement this
-        export: () => {
-            throw new Error("TODO: Not implemented yet");
-        },
-        [Symbol.dispose]: () => {
-            stack.dispose();
-        },
-    });
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        // https://op-engineering.github.io/op-sqlite/docs/configuration#in-memory
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const db = disposer.adopt(open(options?.mode === "memory"
+            ? { name: `inMemoryDb`, location: ":memory:" }
+            : {
+                name: `evolu1-${name}.db`,
+                ...(options?.mode === "encrypted" && {
+                    encryptionKey: `x'${bytesToHex(options.encryptionKey)}'`,
+                }),
+            }), (db) => {
+            db.close();
+        });
+        const cache = disposer.use(createPreparedStatementsCache((sql) => db.prepareStatement(sql), 
+        // op-sqlite doesn't have API for that
+        lazyVoid));
+        const disposables = disposer.move();
+        return ok({
+            exec: (query) => {
+                const prepared = cache.get(query);
+                if (prepared) {
+                    prepared.bindSync(query.parameters);
+                }
+                const { rows, rowsAffected } = db.executeSync(query.sql, query.parameters);
+                return { rows: rows, changes: rowsAffected };
+            },
+            // FIXME: op-sqlite does not expose binary, but a path to the database file
+            // another react native dependency would be needed to implement this
+            export: () => {
+                throw new Error("TODO: Not implemented yet");
+            },
+            deleteDatabase: () => {
+                const env_2 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const deleteDisposer = __addDisposableResource(env_2, new DisposableStack(), false);
+                    if (options?.mode !== "memory") {
+                        deleteDisposer.defer(() => {
+                            db.delete();
+                        });
+                    }
+                    deleteDisposer.use(disposables);
+                }
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_2);
+                }
+            },
+            [Symbol.dispose]: () => {
+                disposables.dispose();
+            },
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/react-native",
-  "version": "15.0.0-next.0",
+  "version": "15.0.0-next.2",
   "description": "Evolu for React Native and Expo",
   "keywords": [
     "evolu",
@@ -12,7 +12,10 @@
   ],
   "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
   "license": "MIT",
-  "repository": "evoluhq/evolu",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evoluhq/evolu.git"
+  },
   "bugs": {
     "url": "https://github.com/evoluhq/evolu/issues"
   },
@@ -72,11 +75,6 @@
     "src/**",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc --build tsconfig.build.json",
-    "prepack": "npm run build",
-    "format": "prettier --write \"src/*.{ts,tsx,md}\""
-  },
   "dependencies": {
     "array-from-async": "^3.0.0",
     "array.prototype.tosorted": "^1.1.4",
@@ -91,20 +89,20 @@
     "set.prototype.union": "^1.1.3"
   },
   "devDependencies": {
-    "@evolu/common": "8.0.0-next.0",
-    "@evolu/react": "11.0.0-next.0",
-    "@evolu/typescript-config": "*",
     "@op-engineering/op-sqlite": "^15.2.2",
     "@types/react": "^19.2.14",
     "expo": "^55.0.4",
     "expo-secure-store": "~55.0.8",
     "expo-sqlite": "~55.0.10",
     "react": "^19.2.4",
-    "react-native": "0.83.2",
+    "react-native": "0.83.6",
     "react-native-nitro-modules": "0.34.1",
     "react-native-sensitive-info": "6.0.0-rc.11",
     "react-native-svg": "15.15.3",
-    "typescript": "^5.9.3"
+    "typescript": "^6",
+    "@evolu/common": "8.0.0-next.5",
+    "@evolu/react": "11.0.0-next.0",
+    "@evolu/typescript-config": "0.0.2"
   },
   "peerDependencies": {
     "@evolu/common": "^8.0.0-next.0",
@@ -148,5 +146,9 @@
   "engines": {
     "node": ">=24.0.0"
   },
-  "sideEffects": false
-}
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "format": "prettier --write \"src/*.{ts,tsx,md}\""
+  }
+}

package/src/LockManager.ts

@@ -0,0 +1,325 @@
+/**
+ * React Native implementation of {@link LockManager}.
+ *
+ * @module
+ */
+
+/**
+ * React Native `LockManager` ponyfill.
+ *
+ * This is a temporary in-memory ponyfill until React Native ships native
+ * `LockManager` support.
+ *
+ * The ponyfill follows Web Locks request and query semantics within the current
+ * JavaScript process.
+ *
+ * ### Example
+ *
+ * ```ts
+ * await lockManager.request("db", async () => {
+ *   // critical section
+ * });
+ * ```
+ */
+const createLockManagerPonyfill = ({
+  clientId = "in-memory-main-thread",
+}: {
+  readonly clientId?: string;
+} = {}): LockManager => {
+  const heldLocksByName = new Map<string, Array<HeldLock>>();
+  const pendingRequestsByName = new Map<string, Array<PendingRequest<any>>>();
+
+  const processPendingRequests = (name: string): void => {
+    const pendingRequests = pendingRequestsByName.get(name);
+    if (pendingRequests == null || pendingRequests.length === 0) return;
+
+    const heldLocks = heldLocksByName.get(name) ?? [];
+    const hasExclusiveLock = heldLocks.some(
+      (lock) => lock.mode === "exclusive",
+    );
+    if (hasExclusiveLock) return;
+
+    if (heldLocks.length === 0) {
+      const nextRequest = pendingRequests[0];
+      if (nextRequest.mode === "exclusive") {
+        grantPendingRequest(name, pendingRequests.shift()!);
+      } else {
+        while (pendingRequests[0]?.mode === "shared") {
+          grantPendingRequest(name, pendingRequests.shift()!);
+        }
+      }
+    } else {
+      while (pendingRequests[0]?.mode === "shared") {
+        grantPendingRequest(name, pendingRequests.shift()!);
+      }
+    }
+
+    cleanupNameState(name);
+  };
+
+  const grantPendingRequest = <T>(
+    name: string,
+    pendingRequest: PendingRequest<T>,
+  ): void => {
+    const heldLocks = heldLocksByName.get(name) ?? [];
+    const heldLock = {
+      clientId,
+      mode: pendingRequest.mode,
+      name,
+      reject: pendingRequest.reject,
+    } satisfies HeldLock;
+
+    heldLocks.push(heldLock);
+    heldLocksByName.set(name, heldLocks);
+    pendingRequest.phase = "granted";
+
+    void Promise.resolve()
+      .then(() => {
+        if (pendingRequest.signal?.aborted) {
+          pendingRequest.phase = "settled";
+          pendingRequest.signal.removeEventListener(
+            "abort",
+            pendingRequest.abort,
+          );
+          releaseHeldLock(name, heldLock);
+          return;
+        }
+
+        pendingRequest.signal?.removeEventListener(
+          "abort",
+          pendingRequest.abort,
+        );
+        pendingRequest.phase = "running";
+
+        return Promise.resolve(
+          pendingRequest.callback({ mode: pendingRequest.mode, name }),
+        );
+      })
+      .then(
+        (value) => {
+          if (pendingRequest.phase === "settled") return;
+
+          pendingRequest.phase = "settled";
+          releaseHeldLock(name, heldLock);
+          pendingRequest.resolve(value!);
+        },
+        (error: unknown) => {
+          pendingRequest.phase = "settled";
+          releaseHeldLock(name, heldLock);
+          pendingRequest.reject(error);
+        },
+      );
+  };
+
+  const releaseHeldLock = (name: string, heldLock: HeldLock): void => {
+    const currentHeldLocks = heldLocksByName.get(name) ?? [];
+    heldLocksByName.set(
+      name,
+      currentHeldLocks.filter((lock) => lock !== heldLock),
+    );
+
+    cleanupNameState(name);
+    processPendingRequests(name);
+  };
+
+  const stealLocks = (name: string): void => {
+    const heldLocks = heldLocksByName.get(name) ?? [];
+    if (heldLocks.length === 0) return;
+
+    heldLocksByName.delete(name);
+
+    for (const heldLock of heldLocks) {
+      heldLock.reject(createAbortError());
+    }
+  };
+
+  const cleanupNameState = (name: string): void => {
+    if (heldLocksByName.get(name)?.length === 0) {
+      heldLocksByName.delete(name);
+    }
+
+    if (pendingRequestsByName.get(name)?.length === 0) {
+      pendingRequestsByName.delete(name);
+    }
+  };
+
+  const removePendingRequest = <T>(
+    name: string,
+    pendingRequest: PendingRequest<T>,
+  ): void => {
+    const pendingRequests = pendingRequestsByName.get(name)!;
+    pendingRequestsByName.set(
+      name,
+      pendingRequests.filter((request) => request !== pendingRequest),
+    );
+
+    cleanupNameState(name);
+    processPendingRequests(name);
+  };
+
+  const canGrantImmediately = (name: string, mode: LockMode): boolean => {
+    const pendingRequests = pendingRequestsByName.get(name);
+    if (pendingRequests != null && pendingRequests.length > 0) {
+      return false;
+    }
+
+    const heldLocks = heldLocksByName.get(name) ?? [];
+
+    if (mode === "exclusive") {
+      return heldLocks.length === 0;
+    }
+
+    return heldLocks.every((lock) => lock.mode === "shared");
+  };
+
+  return {
+    request: <T>(
+      name: string,
+      optionsOrCallback: RequestOptions | LockGrantedCallback<T>,
+      maybeCallback?: LockGrantedCallback<T>,
+    ): Promise<Awaited<T>> => {
+      const [options, callback] = normalizeRequestArguments(
+        optionsOrCallback,
+        maybeCallback,
+      );
+      const mode = options.mode ?? "exclusive";
+
+      if (name.startsWith("-")) {
+        return Promise.reject(createNotSupportedError());
+      }
+
+      if (options.ifAvailable && options.steal) {
+        return Promise.reject(createNotSupportedError());
+      }
+
+      if (options.steal && mode !== "exclusive") {
+        return Promise.reject(createNotSupportedError());
+      }
+
+      if (options.signal != null && (options.ifAvailable || options.steal)) {
+        return Promise.reject(createNotSupportedError());
+      }
+
+      if (options.signal?.aborted) {
+        return Promise.reject(options.signal.reason as Error);
+      }
+
+      if (options.ifAvailable && !canGrantImmediately(name, mode)) {
+        return Promise.resolve().then(() => Promise.resolve(callback(null)));
+      }
+
+      return new Promise<Awaited<T>>((resolve, reject) => {
+        const pendingRequest: PendingRequest<T> = {
+          abort: () => {
+            if (pendingRequest.phase === "queued") {
+              pendingRequest.phase = "settled";
+              removePendingRequest(name, pendingRequest);
+              reject(options.signal!.reason as Error);
+              return;
+            }
+
+            pendingRequest.phase = "settled";
+            reject(options.signal!.reason as Error);
+          },
+          callback,
+          mode,
+          name,
+          phase: "queued",
+          reject,
+          resolve,
+          ...(options.signal == null ? {} : { signal: options.signal }),
+        };
+
+        if (options.signal != null) {
+          options.signal.addEventListener("abort", pendingRequest.abort, {
+            once: true,
+          });
+        }
+
+        const pendingRequests = pendingRequestsByName.get(name) ?? [];
+
+        if (options.steal) {
+          stealLocks(name);
+          pendingRequests.unshift(pendingRequest);
+        } else {
+          pendingRequests.push(pendingRequest);
+        }
+
+        pendingRequestsByName.set(name, pendingRequests);
+        processPendingRequests(name);
+      });
+    },
+
+    query: () => {
+      const held = Array.from(heldLocksByName.values())
+        .flat()
+        .map(({ clientId, mode, name }) => ({ clientId, mode, name }));
+      const pending = Array.from(pendingRequestsByName.values())
+        .flat()
+        .map(({ mode, name }) => ({
+          clientId,
+          mode,
+          name,
+        }));
+
+      return Promise.resolve({ held, pending });
+    },
+  };
+};
+
+/**
+ * React Native {@link LockManager}.
+ *
+ * Uses an in-memory lock manager scoped to the main JavaScript thread while
+ * following Web Locks request and query semantics.
+ */
+export const lockManager: LockManager = /*#__PURE__*/ createLockManagerPonyfill(
+  {
+    clientId: "react-native-main-thread",
+  },
+);
+
+const normalizeRequestArguments = <T>(
+  optionsOrCallback: RequestOptions | LockGrantedCallback<T>,
+  maybeCallback?: LockGrantedCallback<T>,
+): [RequestOptions, LockGrantedCallback<T>] =>
+  typeof optionsOrCallback === "function"
+    ? [{}, optionsOrCallback]
+    : [optionsOrCallback, maybeCallback!];
+
+const createAbortError = (): Error =>
+  createNamedError("AbortError", "The request was aborted.");
+
+const createNotSupportedError = (): Error =>
+  createNamedError("NotSupportedError", "The operation is not supported.");
+
+const createNamedError = (name: string, message: string): Error => {
+  const error = new Error(message) as Error & { name: string };
+  error.name = name;
+  return error;
+};
+
+interface HeldLock extends LockInfo {
+  readonly clientId: string;
+  readonly mode: LockMode;
+  readonly name: string;
+  readonly reject: (reason?: unknown) => void;
+}
+
+interface RequestOptions {
+  readonly ifAvailable?: boolean;
+  readonly mode?: LockMode;
+  readonly signal?: AbortSignal;
+  readonly steal?: boolean;
+}
+
+interface PendingRequest<T> {
+  readonly abort: () => void;
+  readonly callback: LockGrantedCallback<T>;
+  readonly mode: LockMode;
+  readonly name: string;
+  phase: "queued" | "granted" | "running" | "settled";
+  readonly reject: (reason?: unknown) => void;
+  readonly resolve: (value: Awaited<T> | PromiseLike<Awaited<T>>) => void;
+  readonly signal?: AbortSignal;
+}

package/src/Polyfills.ts

@@ -76,10 +76,6 @@ interface AbortControllerPrototype extends AbortController {
   readonly __evoluAbortReasonPatched?: true;
 }
 
-interface AbortSignalWithReason extends AbortSignal {
-  readonly reason: unknown;
-}
-
 interface AnyControllersRegistry {
   readonly add: (controller: AbortController) => void;
   readonly remove: (controller: AbortController) => void;
@@ -99,12 +95,12 @@ const anyControllersBySignal = new WeakMap<
 
 const installAbortControllerPolyfills = (): void => {
   installAbortReasonPolyfill(
-    globalThis.AbortController as AbortControllerConstructor,
-    globalThis.AbortSignal as AbortSignalConstructor,
+    globalThis.AbortController,
+    globalThis.AbortSignal,
   );
   installAbortSignalStaticMethods(
-    globalThis.AbortController as AbortControllerConstructor,
-    globalThis.AbortSignal as AbortSignalConstructor,
+    globalThis.AbortController,
+    globalThis.AbortSignal,
   );
 };
 
@@ -279,7 +275,7 @@ const createAnyControllersRegistry = (
 
 const readSignalReason = (signal: AbortSignal): unknown => {
   if ("reason" in signal) {
-    return (signal as AbortSignalWithReason).reason;
+    return signal.reason;
   }
   return createAbortError();
 };

package/src/Task.ts

@@ -9,7 +9,7 @@ import {
   createUnknownError,
   type CreateRun,
   type Run,
-  type RunDeps,
+  type RunDefaultDeps,
 } from "@evolu/common";
 
 /**
@@ -28,16 +28,16 @@ import {
  * });
  *
  * await using run = createRun({ console });
- * await using stack = new AsyncDisposableStack();
+ * await using disposer = new AsyncDisposableStack();
  *
- * stack.use(await run.orThrow(startApp()));
+ * disposer.use(await run.orThrow(startApp()));
  * ```
  *
  * @group React Native Run
  */
-export const createRun: CreateRun<RunDeps> = <D>(
+export const createRun: CreateRun<RunDefaultDeps> = <D>(
   deps?: D,
-): Run<RunDeps & D> => {
+): Run<RunDefaultDeps & D> => {
   const run = createCommonRun(deps);
 
   const console = run.deps.console.child("global");

package/src/index.ts

@@ -1,3 +1,3 @@
 export * from "./components/EvoluIdenticon.js";
+export * from "./LockManager.js";
 export * from "./Task.js";
-export * from "./Worker.js";

package/src/shared.ts

@@ -1,10 +1,14 @@
 import {
   createConsole,
   createConsoleStoreOutput,
-  createInMemoryLeaderLock,
+  createBroadcastChannel,
+  createMessageChannel,
+  createMessagePort,
   createRandomBytes,
   createRun,
+  createSharedWorker,
   createWebSocket,
+  createWorker,
   type ConsoleDep,
   type CreateSqliteDriverDep,
   type ReloadAppDep,
@@ -15,20 +19,14 @@ import type {
   DbWorkerInit,
   EvoluDeps,
   SharedWorkerInput,
+  SharedWorkerOutput,
 } from "@evolu/common/local-first";
 import {
   createEvoluDeps as createCommonEvoluDeps,
-  startDbWorker,
   initSharedWorker,
+  startDbWorker,
 } from "@evolu/common/local-first";
-import {
-  createMessageChannel,
-  createMessagePort,
-  createSharedWorker,
-  createWorker,
-} from "./Worker.js";
-
-const leaderLock = createInMemoryLeaderLock();
+import { lockManager } from "./LockManager.js";
 
 /** Creates Evolu dependencies for React Native. */
 export const createEvoluDeps = (
@@ -46,10 +44,12 @@ export const createEvoluDeps = (
     return createRun({
       console: workerConsole,
       consoleStoreOutputEntry: consoleStoreOutput.entry,
+      createBroadcastChannel,
+      createMessageChannel,
       createMessagePort,
       createWebSocket,
       createSqliteDriver: deps.createSqliteDriver,
-      leaderLock,
+      lockManager,
       randomBytes: createRandomBytes(),
     });
   };
@@ -60,7 +60,10 @@ export const createEvoluDeps = (
       dbWorkerRun(startDbWorker(self));
     });
 
-  const sharedWorker = createSharedWorker<SharedWorkerInput, never>((self) => {
+  const sharedWorker = createSharedWorker<
+    SharedWorkerInput,
+    SharedWorkerOutput
+  >((self) => {
     const sharedWorkerRun = createWorkerRun();
     sharedWorkerRun(initSharedWorker(self));
   });
@@ -68,7 +71,9 @@ export const createEvoluDeps = (
   return createCommonEvoluDeps({
     ...deps,
     createDbWorker,
+    createBroadcastChannel,
     createMessageChannel,
+    lockManager,
     reloadApp: deps.reloadApp,
     sharedWorker,
   });