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

package/README.md

@@ -1,6 +1,6 @@
-# Evolu for React Native and Expo
+# Evolu for React Native
 
-[Evolu](https://github.com/evoluhq/evolu) for [React Native](https://reactnative.dev/) and [Expo](https://expo.dev/).
+This package provides Evolu for [React Native](https://reactnative.dev) and [Expo](https://expo.dev).
 
 ## Documentation
 
@@ -12,4 +12,4 @@ The Evolu community is on [GitHub Discussions](https://github.com/evoluhq/evolu/
 
 To chat with other community members, you can join the [Evolu Discord](https://discord.gg/2J8yyyyxtZ).
 
-[![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/evoluhq.svg?style=social&label=Follow%20%40evoluhq)](https://twitter.com/evoluhq)
+[![X](https://img.shields.io/twitter/url/https/x.com/evoluhq.svg?style=social&label=Follow%20%40evoluhq)](https://x.com/evoluhq)

package/dist/src/LockManager.d.ts

@@ -0,0 +1,13 @@
+/**
+ * React Native implementation of {@link LockManager}.
+ *
+ * @module
+ */
+/**
+ * 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 declare const lockManager: LockManager;
+//# sourceMappingURL=LockManager.d.ts.map

package/dist/src/LockManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockManager.d.ts","sourceRoot":"","sources":["../../src/LockManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyQH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,WAIzB,CAAC"}

package/dist/src/LockManager.js

@@ -0,0 +1,219 @@
+/**
+ * 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", } = {}) => {
+    const heldLocksByName = new Map();
+    const pendingRequestsByName = new Map();
+    const processPendingRequests = (name) => {
+        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 = (name, pendingRequest) => {
+        const heldLocks = heldLocksByName.get(name) ?? [];
+        const heldLock = {
+            clientId,
+            mode: pendingRequest.mode,
+            name,
+            reject: pendingRequest.reject,
+        };
+        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) => {
+            pendingRequest.phase = "settled";
+            releaseHeldLock(name, heldLock);
+            pendingRequest.reject(error);
+        });
+    };
+    const releaseHeldLock = (name, heldLock) => {
+        const currentHeldLocks = heldLocksByName.get(name) ?? [];
+        heldLocksByName.set(name, currentHeldLocks.filter((lock) => lock !== heldLock));
+        cleanupNameState(name);
+        processPendingRequests(name);
+    };
+    const stealLocks = (name) => {
+        const heldLocks = heldLocksByName.get(name) ?? [];
+        if (heldLocks.length === 0)
+            return;
+        heldLocksByName.delete(name);
+        for (const heldLock of heldLocks) {
+            heldLock.reject(createAbortError());
+        }
+    };
+    const cleanupNameState = (name) => {
+        if (heldLocksByName.get(name)?.length === 0) {
+            heldLocksByName.delete(name);
+        }
+        if (pendingRequestsByName.get(name)?.length === 0) {
+            pendingRequestsByName.delete(name);
+        }
+    };
+    const removePendingRequest = (name, pendingRequest) => {
+        const pendingRequests = pendingRequestsByName.get(name);
+        pendingRequestsByName.set(name, pendingRequests.filter((request) => request !== pendingRequest));
+        cleanupNameState(name);
+        processPendingRequests(name);
+    };
+    const canGrantImmediately = (name, mode) => {
+        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: (name, optionsOrCallback, maybeCallback) => {
+            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);
+            }
+            if (options.ifAvailable && !canGrantImmediately(name, mode)) {
+                return Promise.resolve().then(() => Promise.resolve(callback(null)));
+            }
+            return new Promise((resolve, reject) => {
+                const pendingRequest = {
+                    abort: () => {
+                        if (pendingRequest.phase === "queued") {
+                            pendingRequest.phase = "settled";
+                            removePendingRequest(name, pendingRequest);
+                            reject(options.signal.reason);
+                            return;
+                        }
+                        pendingRequest.phase = "settled";
+                        reject(options.signal.reason);
+                    },
+                    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 = /*#__PURE__*/ createLockManagerPonyfill({
+    clientId: "react-native-main-thread",
+});
+const normalizeRequestArguments = (optionsOrCallback, maybeCallback) => typeof optionsOrCallback === "function"
+    ? [{}, optionsOrCallback]
+    : [optionsOrCallback, maybeCallback];
+const createAbortError = () => createNamedError("AbortError", "The request was aborted.");
+const createNotSupportedError = () => createNamedError("NotSupportedError", "The operation is not supported.");
+const createNamedError = (name, message) => {
+    const error = new Error(message);
+    error.name = name;
+    return error;
+};

package/dist/src/Polyfills.d.ts

@@ -0,0 +1,3 @@
+/** Installs polyfills required by Evolu in React Native runtimes. */
+export declare const installPolyfills: () => void;
+//# sourceMappingURL=Polyfills.d.ts.map

package/dist/src/Polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Polyfills.d.ts","sourceRoot":"","sources":["../../src/Polyfills.ts"],"names":[],"mappings":"AAmCA,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,QAAO,IAKnC,CAAC"}

package/dist/src/Polyfills.js

@@ -0,0 +1,209 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+import { installPolyfills as installCommonPolyfills } from "@evolu/common/polyfills";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import fromAsync from "array-from-async";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import withResolvers from "promise.withresolvers";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import promiseTry from "promise.try";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import toSorted from "array.prototype.tosorted";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import difference from "set.prototype.difference";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import intersection from "set.prototype.intersection";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import isDisjointFrom from "set.prototype.isdisjointfrom";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import isSubsetOf from "set.prototype.issubsetof";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import isSupersetOf from "set.prototype.issupersetof";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import symmetricDifference from "set.prototype.symmetricdifference";
+// @ts-expect-error Runtime polyfill package has no TypeScript declarations.
+import union from "set.prototype.union";
+difference.shim();
+intersection.shim();
+isDisjointFrom.shim();
+isSubsetOf.shim();
+isSupersetOf.shim();
+symmetricDifference.shim();
+union.shim();
+/** Installs polyfills required by Evolu in React Native runtimes. */
+export const installPolyfills = () => {
+    installCommonPolyfills();
+    installArrayPolyfills();
+    installPromisePolyfills();
+    installAbortControllerPolyfills();
+};
+const installArrayPolyfills = () => {
+    if (typeof Array.fromAsync !== "function") {
+        Object.defineProperty(Array, "fromAsync", {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: fromAsync,
+        });
+    }
+    toSorted.shim();
+};
+const installPromisePolyfills = () => {
+    withResolvers.shim();
+    promiseTry.shim();
+};
+const abortReasonBySignal = new WeakMap();
+const anyControllersBySignal = new WeakMap();
+const installAbortControllerPolyfills = () => {
+    installAbortReasonPolyfill(globalThis.AbortController, globalThis.AbortSignal);
+    installAbortSignalStaticMethods(globalThis.AbortController, globalThis.AbortSignal);
+};
+const installAbortReasonPolyfill = (abortController, abortSignal) => {
+    if (!("reason" in abortSignal.prototype)) {
+        Object.defineProperty(abortSignal.prototype, "reason", {
+            configurable: true,
+            enumerable: false,
+            get() {
+                return abortReasonBySignal.get(this);
+            },
+        });
+    }
+    const prototype = abortController.prototype;
+    if (prototype.__evoluAbortReasonPatched)
+        return;
+    const nativeAbort = prototype.abort;
+    prototype.abort = function (reason) {
+        const normalizedReason = reason === undefined ? createAbortError() : reason;
+        abortReasonBySignal.set(this.signal, normalizedReason);
+        nativeAbort.call(this, normalizedReason);
+    };
+    Object.defineProperty(prototype, "__evoluAbortReasonPatched", {
+        value: true,
+        configurable: true,
+        enumerable: false,
+        writable: false,
+    });
+};
+const installAbortSignalStaticMethods = (abortController, abortSignal) => {
+    if (typeof abortSignal.abort !== "function") {
+        Object.defineProperty(abortSignal, "abort", {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: (reason) => {
+                const controller = new abortController();
+                controller.abort(reason);
+                return controller.signal;
+            },
+        });
+    }
+    if (typeof abortSignal.timeout !== "function") {
+        Object.defineProperty(abortSignal, "timeout", {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: (milliseconds) => {
+                const controller = new abortController();
+                const timeoutId = globalThis.setTimeout(() => {
+                    controller.abort(createTimeoutError(milliseconds));
+                }, milliseconds);
+                controller.signal.addEventListener("abort", () => {
+                    globalThis.clearTimeout(timeoutId);
+                }, { once: true });
+                return controller.signal;
+            },
+        });
+    }
+    if (typeof abortSignal.any !== "function") {
+        Object.defineProperty(abortSignal, "any", {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: (signals) => createAbortSignalAny(abortController, signals),
+        });
+    }
+};
+const createAbortSignalAny = (abortController, signals) => {
+    const controller = new abortController();
+    if (signals.length === 0)
+        return controller.signal;
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort(readSignalReason(signal));
+            return controller.signal;
+        }
+    }
+    const sources = Array.from(new Set(signals));
+    for (const signal of sources) {
+        const registry = anyControllersBySignal.get(signal) ??
+            createAnyControllersRegistry(signal);
+        anyControllersBySignal.set(signal, registry);
+        registry.add(controller);
+    }
+    controller.signal.addEventListener("abort", () => {
+        for (const signal of sources) {
+            anyControllersBySignal.get(signal)?.remove(controller);
+        }
+    }, { once: true });
+    return controller.signal;
+};
+const createAnyControllersRegistry = (sourceSignal) => {
+    let refs = [];
+    const cleanup = () => {
+        refs = refs.filter((ref) => {
+            const controller = ref.deref();
+            return controller != null && !controller.signal.aborted;
+        });
+        if (refs.length === 0) {
+            sourceSignal.removeEventListener("abort", onAbort);
+            anyControllersBySignal.delete(sourceSignal);
+        }
+    };
+    const onAbort = () => {
+        const reason = readSignalReason(sourceSignal);
+        for (const ref of refs) {
+            const controller = ref.deref();
+            if (!controller || controller.signal.aborted)
+                continue;
+            controller.abort(reason);
+        }
+        refs = [];
+        sourceSignal.removeEventListener("abort", onAbort);
+        anyControllersBySignal.delete(sourceSignal);
+    };
+    sourceSignal.addEventListener("abort", onAbort, { once: true });
+    return {
+        add: (controller) => {
+            refs.push(new globalThis.WeakRef(controller));
+            cleanup();
+        },
+        remove: (controller) => {
+            refs = refs.filter((ref) => {
+                const candidate = ref.deref();
+                return candidate != null && candidate !== controller;
+            });
+            cleanup();
+        },
+    };
+};
+const readSignalReason = (signal) => {
+    if ("reason" in signal) {
+        return signal.reason;
+    }
+    return createAbortError();
+};
+const createTimeoutError = (milliseconds) => createNamedError("TimeoutError", `signal timed out after ${milliseconds} ms`);
+const createAbortError = () => createNamedError("AbortError", "This operation was aborted");
+const createNamedError = (name, message) => {
+    if (typeof globalThis.DOMException === "function") {
+        try {
+            return new globalThis.DOMException(message, name);
+        }
+        catch {
+            // Some runtimes expose DOMException but cannot construct it reliably.
+        }
+    }
+    const error = new Error(message);
+    error.name = name;
+    return error;
+};

package/dist/src/Task.d.ts

@@ -0,0 +1,31 @@
+/**
+ * React Native-specific Task utilities.
+ *
+ * @module
+ */
+import { type CreateRun, type RunDeps } from "@evolu/common";
+/**
+ * Creates {@link Run} for React Native with global error handling.
+ *
+ * Registers `ErrorUtils.setGlobalHandler` for uncaught JavaScript errors. The
+ * handler is restored to the previous one when the Run is disposed.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const console = createConsole({
+ *   formatter: createConsoleFormatter()({
+ *     timestampFormat: "relative",
+ *   }),
+ * });
+ *
+ * await using run = createRun({ console });
+ * await using disposer = new AsyncDisposableStack();
+ *
+ * disposer.use(await run.orThrow(startApp()));
+ * ```
+ *
+ * @group React Native Run
+ */
+export declare const createRun: CreateRun<RunDeps>;
+//# sourceMappingURL=Task.d.ts.map

package/dist/src/Task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../src/Task.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,OAAO,CA4BxC,CAAC"}

package/dist/src/Task.js

@@ -0,0 +1,46 @@
+/**
+ * React Native-specific Task utilities.
+ *
+ * @module
+ */
+import { createRun as createCommonRun, createUnknownError, } from "@evolu/common";
+/**
+ * Creates {@link Run} for React Native with global error handling.
+ *
+ * Registers `ErrorUtils.setGlobalHandler` for uncaught JavaScript errors. The
+ * handler is restored to the previous one when the Run is disposed.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const console = createConsole({
+ *   formatter: createConsoleFormatter()({
+ *     timestampFormat: "relative",
+ *   }),
+ * });
+ *
+ * await using run = createRun({ console });
+ * await using disposer = new AsyncDisposableStack();
+ *
+ * disposer.use(await run.orThrow(startApp()));
+ * ```
+ *
+ * @group React Native Run
+ */
+export const createRun = (deps) => {
+    const run = createCommonRun(deps);
+    const console = run.deps.console.child("global");
+    const previousHandler = globalThis.ErrorUtils?.getGlobalHandler();
+    const handleError = (error, isFatal) => {
+        console.error(isFatal ? "fatalError" : "uncaughtError", createUnknownError(error));
+        // Call the previous handler if it exists
+        previousHandler?.(error, isFatal);
+    };
+    globalThis.ErrorUtils?.setGlobalHandler(handleError);
+    run.onAbort(() => {
+        if (previousHandler) {
+            globalThis.ErrorUtils?.setGlobalHandler(previousHandler);
+        }
+    });
+    return run;
+};

package/dist/src/components/EvoluIdenticon.d.ts

@@ -0,0 +1,9 @@
+import { type IdenticonStyle, OwnerId } from "@evolu/common";
+import { type FC } from "react";
+export declare const EvoluIdenticon: FC<{
+    id: OwnerId;
+    size?: number;
+    borderRadius?: number;
+    style?: IdenticonStyle;
+}>;
+//# sourceMappingURL=EvoluIdenticon.d.ts.map

package/dist/src/components/EvoluIdenticon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvoluIdenticon.d.ts","sourceRoot":"","sources":["../../../src/components/EvoluIdenticon.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,KAAK,EAAE,EAAW,MAAM,OAAO,CAAC;AAIzC,eAAO,MAAM,cAAc,EAAE,EAAE,CAAC;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB,CAcA,CAAC"}

package/dist/{components → src/components}/EvoluIdenticon.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createIdenticon } from "@evolu/common";
+import { createIdenticon, OwnerId } from "@evolu/common";
 import { useMemo } from "react";
 import { View } from "react-native";
 import { SvgXml } from "react-native-svg";

package/dist/src/createExpoDeps.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=createExpoDeps.d.ts.map

package/dist/src/createExpoDeps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createExpoDeps.d.ts","sourceRoot":"","sources":["../../src/createExpoDeps.ts"],"names":[],"mappings":""}