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

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Evolu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/Task.d.ts

@@ -20,9 +20,9 @@ import { type CreateRun, type RunDeps } from "@evolu/common";
  * });
  *
  * 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

package/dist/src/Task.js

@@ -20,9 +20,9 @@ import { createRun as createCommonRun, createUnknownError, } from "@evolu/common
  * });
  *
  * 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

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./components/EvoluIdenticon.js";
+export * from "./LockManager.js";
 export * from "./Task.js";
-export * from "./Worker.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC"}

package/dist/src/index.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAIV,SAAS,EAEV,MAAM,2BAA2B,CAAC;AAenC,mDAAmD;AACnD,eAAO,MAAM,eAAe,GAC1B,MAAM,YAAY,GAAG,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,KAC/D,SAuCF,CAAC"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAIV,SAAS,EAGV,MAAM,2BAA2B,CAAC;AAQnC,mDAAmD;AACnD,eAAO,MAAM,eAAe,GAC1B,MAAM,YAAY,GAAG,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,KAC/D,SA8CF,CAAC"}

package/dist/src/shared.js

@@ -1,7 +1,6 @@
-import { createConsole, createConsoleStoreOutput, createInMemoryLeaderLock, createRandomBytes, createRun, createWebSocket, } from "@evolu/common";
-import { createEvoluDeps as createCommonEvoluDeps, startDbWorker, initSharedWorker, } from "@evolu/common/local-first";
-import { createMessageChannel, createMessagePort, createSharedWorker, createWorker, } from "./Worker.js";
-const leaderLock = createInMemoryLeaderLock();
+import { createConsole, createConsoleStoreOutput, createBroadcastChannel, createMessageChannel, createMessagePort, createRandomBytes, createRun, createSharedWorker, createWebSocket, createWorker, } from "@evolu/common";
+import { createEvoluDeps as createCommonEvoluDeps, initSharedWorker, startDbWorker, } from "@evolu/common/local-first";
+import { lockManager } from "./LockManager.js";
 /** Creates Evolu dependencies for React Native. */
 export const createEvoluDeps = (deps) => {
     // Worker-side Run lives as long as the app. When RN supports real workers,
@@ -15,10 +14,12 @@ export const createEvoluDeps = (deps) => {
         return createRun({
             console: workerConsole,
             consoleStoreOutputEntry: consoleStoreOutput.entry,
+            createBroadcastChannel,
+            createMessageChannel,
             createMessagePort,
             createWebSocket,
             createSqliteDriver: deps.createSqliteDriver,
-            leaderLock,
+            lockManager,
             randomBytes: createRandomBytes(),
         });
     };
@@ -33,7 +34,9 @@ export const createEvoluDeps = (deps) => {
     return createCommonEvoluDeps({
         ...deps,
         createDbWorker,
+        createBroadcastChannel,
         createMessageChannel,
+        lockManager,
         reloadApp: deps.reloadApp,
         sharedWorker,
     });

package/dist/src/sqlite-drivers/createExpoSqliteDriver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createExpoSqliteDriver.d.ts","sourceRoot":"","sources":["../../../src/sqlite-drivers/createExpoSqliteDriver.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AAGvB,eAAO,MAAM,sBAAsB,EAAE,kBAgElC,CAAC"}
+{"version":3,"file":"createExpoSqliteDriver.d.ts","sourceRoot":"","sources":["../../../src/sqlite-drivers/createExpoSqliteDriver.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AAOvB,eAAO,MAAM,sBAAsB,EAAE,kBA2ElC,CAAC"}

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

@@ -1,51 +1,134 @@
+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, ok, } from "@evolu/common";
-import { openDatabaseSync, SQLiteStatement } from "expo-sqlite";
+import { deleteDatabaseSync, openDatabaseSync, } from "expo-sqlite";
 export const createExpoSqliteDriver = (name, options) => () => {
-    const stack = new globalThis.DisposableStack();
-    const db = stack.adopt(openDatabaseSync(options?.mode === "memory" ? ":memory:" : `evolu1-${name}.db`), (db) => {
-        db.closeSync();
-    });
-    if (options?.mode === "encrypted") {
-        db.execSync(`PRAGMA key = "x'${bytesToHex(options.encryptionKey)}'"`);
-    }
-    const cache = stack.use(createPreparedStatementsCache((sql) => db.prepareSync(sql), (statement) => {
-        statement.finalizeSync();
-    }));
-    return ok({
-        exec: (query) => {
-            const execStatement = (statement) => {
-                const result = statement.executeSync(query.parameters);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const databaseName = `evolu1-${name}.db`;
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const db = disposer.adopt(openDatabaseSync(options?.mode === "memory" ? ":memory:" : databaseName), (db) => {
+            db.closeSync();
+        });
+        if (options?.mode === "encrypted") {
+            db.execSync(`PRAGMA key = "x'${bytesToHex(options.encryptionKey)}'"`);
+        }
+        const cache = disposer.use(createPreparedStatementsCache((sql) => db.prepareSync(sql), (statement) => {
+            statement.finalizeSync();
+        }));
+        const disposables = disposer.move();
+        return ok({
+            exec: (query) => {
+                const execStatement = (statement) => {
+                    const result = statement.executeSync(query.parameters);
+                    try {
+                        const rows = result.getAllSync();
+                        const changes = result.changes;
+                        return { rows: rows, changes };
+                    }
+                    finally {
+                        result.resetSync();
+                    }
+                };
+                const prepared = cache.get(query);
+                if (prepared)
+                    return execStatement(prepared);
+                const statement = db.prepareSync(query.sql);
                 try {
-                    const rows = result.getAllSync();
-                    const changes = result.changes;
-                    return { rows: rows, changes };
+                    return execStatement(statement);
                 }
                 finally {
-                    result.resetSync();
-                }
-            };
-            const prepared = cache.get(query);
-            if (prepared)
-                return execStatement(prepared);
-            const statement = db.prepareSync(query.sql);
-            try {
-                return execStatement(statement);
-            }
-            finally {
-                statement.finalizeSync();
-            }
-        },
-        export: () => {
-            const file = db.serializeSync();
-            const { buffer } = file;
-            if (buffer instanceof ArrayBuffer) {
-                return new Uint8Array(buffer, file.byteOffset, file.byteLength);
-            }
-            // Ensure export uses transferable ArrayBuffer backing.
-            return new Uint8Array(file);
-        },
-        [Symbol.dispose]: () => {
-            stack.dispose();
-        },
-    });
+                    statement.finalizeSync();
+                }
+            },
+            export: () => {
+                const file = db.serializeSync();
+                const { buffer } = file;
+                if (buffer instanceof ArrayBuffer) {
+                    return new Uint8Array(buffer, file.byteOffset, file.byteLength);
+                }
+                // Ensure export uses transferable ArrayBuffer backing.
+                return new Uint8Array(file);
+            },
+            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(() => {
+                            deleteDatabaseSync(databaseName);
+                        });
+                    }
+                    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/dist/src/sqlite-drivers/createOpSqliteDriver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createOpSqliteDriver.d.ts","sourceRoot":"","sources":["../../../src/sqlite-drivers/createOpSqliteDriver.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EAIxB,MAAM,eAAe,CAAC;AAGvB,eAAO,MAAM,oBAAoB,EAAE,kBAqDhC,CAAC"}
+{"version":3,"file":"createOpSqliteDriver.d.ts","sourceRoot":"","sources":["../../../src/sqlite-drivers/createOpSqliteDriver.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EAIxB,MAAM,eAAe,CAAC;AAGvB,eAAO,MAAM,oBAAoB,EAAE,kBAiEhC,CAAC"}