@evolu/react-native 14.3.0 → 15.0.0-next.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/react-native",
-  "version": "14.3.0",
+  "version": "15.0.0-next.1",
   "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"
   },
@@ -20,76 +23,99 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js",
-      "react-native": "./dist/index.js"
+      "types": "./dist/src/index.d.ts",
+      "react-native": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    },
+    "./polyfills": {
+      "types": "./dist/src/Polyfills.d.ts",
+      "react-native": "./dist/src/Polyfills.js",
+      "default": "./dist/src/Polyfills.js"
     },
     "./expo-sqlite": {
-      "types": "./dist/exports/expo-sqlite.d.ts",
-      "default": "./dist/exports/expo-sqlite.js",
-      "react-native": "./dist/exports/expo-sqlite.js",
-      "browser": "./dist/web.js"
+      "types": "./dist/src/exports/expo-sqlite.d.ts",
+      "react-native": "./dist/src/exports/expo-sqlite.js",
+      "browser": "./dist/src/web.js",
+      "default": "./dist/src/exports/expo-sqlite.js"
     },
     "./expo-op-sqlite": {
-      "types": "./dist/exports/expo-op-sqlite.d.ts",
-      "default": "./dist/exports/expo-op-sqlite.js",
-      "react-native": "./dist/exports/expo-op-sqlite.js",
-      "browser": "./dist/web.js"
+      "types": "./dist/src/exports/expo-op-sqlite.d.ts",
+      "react-native": "./dist/src/exports/expo-op-sqlite.js",
+      "browser": "./dist/src/web.js",
+      "default": "./dist/src/exports/expo-op-sqlite.js"
     },
     "./bare-op-sqlite": {
-      "types": "./dist/exports/bare-op-sqlite.d.ts",
-      "default": "./dist/exports/bare-op-sqlite.js",
-      "react-native": "./dist/exports/bare-op-sqlite.js",
-      "browser": "./dist/web.js"
+      "types": "./dist/src/exports/bare-op-sqlite.d.ts",
+      "react-native": "./dist/src/exports/bare-op-sqlite.js",
+      "browser": "./dist/src/web.js",
+      "default": "./dist/src/exports/bare-op-sqlite.js"
     }
   },
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
+        "./dist/src/index.d.ts"
+      ],
+      "polyfills": [
+        "./dist/src/Polyfills.d.ts"
       ],
       "expo-sqlite": [
-        "./dist/exports/expo-sqlite.d.ts"
+        "./dist/src/exports/expo-sqlite.d.ts"
       ],
       "expo-op-sqlite": [
-        "./dist/exports/expo-op-sqlite.d.ts"
+        "./dist/src/exports/expo-op-sqlite.d.ts"
       ],
       "bare-op-sqlite": [
-        "./dist/exports/bare-op-sqlite.d.ts"
+        "./dist/src/exports/bare-op-sqlite.d.ts"
       ]
     }
   },
   "files": [
-    "dist/**",
+    "dist/src/**",
     "src/**",
     "README.md"
   ],
+  "dependencies": {
+    "array-from-async": "^3.0.0",
+    "array.prototype.tosorted": "^1.1.4",
+    "promise.try": "^2.0.1",
+    "promise.withresolvers": "^1.0.4",
+    "set.prototype.difference": "^1.1.7",
+    "set.prototype.intersection": "^1.1.8",
+    "set.prototype.isdisjointfrom": "^1.1.5",
+    "set.prototype.issubsetof": "^1.1.4",
+    "set.prototype.issupersetof": "^1.1.3",
+    "set.prototype.symmetricdifference": "^1.1.3",
+    "set.prototype.union": "^1.1.3"
+  },
   "devDependencies": {
-    "@op-engineering/op-sqlite": "^15.0.3",
-    "expo": "^54.0.10",
-    "expo-secure-store": "~15.0.7",
-    "expo-sqlite": "~16.0.8",
-    "react-native": "^0.81.4",
-    "react-native-nitro-modules": "^0.31.2",
-    "react-native-sensitive-info": "^6.0.0-rc.8",
-    "react-native-svg": "^15.14.0",
-    "typescript": "^5.9.2",
-    "vitest": "^4.0.4",
-    "@evolu/common": "7.4.0",
-    "@evolu/react": "10.4.0",
-    "@evolu/tsconfig": "0.0.2"
+    "@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.6",
+    "react-native-nitro-modules": "0.34.1",
+    "react-native-sensitive-info": "6.0.0-rc.11",
+    "react-native-svg": "15.15.3",
+    "typescript": "^6",
+    "@evolu/common": "8.0.0-next.4",
+    "@evolu/react": "11.0.0-next.0",
+    "@evolu/typescript-config": "0.0.2"
   },
   "peerDependencies": {
-    "@evolu/common": "^7.4.0",
-    "@evolu/react": "^10.4.0",
+    "@evolu/common": "^8.0.0-next.0",
+    "@evolu/react": "^11.0.0-next.0",
     "@op-engineering/op-sqlite": ">=12",
-    "expo": ">=54",
-    "expo-secure-store": ">=15",
-    "expo-sqlite": ">=16",
-    "react-native": ">=0.81",
-    "react-native-nitro-modules": ">=0.31",
+    "expo": ">=55",
+    "expo-secure-store": ">=55",
+    "expo-sqlite": ">=55",
+    "react": ">=19",
+    "react-native": ">=0.83",
+    "react-native-nitro-modules": ">=0.34",
     "react-native-sensitive-info": ">=6",
-    "react-native-svg": ">=15"
+    "react-native-svg": ">=15.15"
   },
   "peerDependenciesMeta": {
     "@op-engineering/op-sqlite": {
@@ -118,13 +144,11 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
-  "sideEffects": [],
+  "sideEffects": false,
   "scripts": {
-    "dev": "tsc --watch",
-    "build": "rimraf dist && tsc",
-    "clean": "rimraf .turbo node_modules dist",
+    "build": "tsc --build tsconfig.build.json",
     "format": "prettier --write \"src/*.{ts,tsx,md}\""
   }
 }

package/src/ErrorUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * React Native global error handling utilities.
+ *
+ * ErrorUtils is a React Native global that provides error handling
+ * capabilities.
+ */
+interface ErrorUtils {
+  getGlobalHandler: () => ((error: unknown, isFatal?: boolean) => void) | null;
+  setGlobalHandler: (
+    handler: (error: unknown, isFatal?: boolean) => void,
+  ) => void;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var ErrorUtils: ErrorUtils | undefined;
+}
+
+export {};

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;
+}