@evolu/web 3.0.0-next.0 → 3.0.0-next.1

package/src/local-first/Db.worker.ts

@@ -7,14 +7,14 @@ installPolyfills();
 import { createRandomBytes } from "@evolu/common";
 import { startDbWorker } from "@evolu/common/local-first";
 import { createWasmSqliteDriver } from "../Sqlite.js";
-import { createLeaderLock, createRun } from "../Task.js";
+import { createRun } from "../Task.js";
 import { createWorkerDeps, createWorkerSelf } from "../Worker.js";
 
 // TODO: Disposal.
 const run = createRun({
   ...createWorkerDeps(),
   createSqliteDriver: createWasmSqliteDriver,
-  leaderLock: createLeaderLock(),
+  lockManager: globalThis.navigator.locks,
   randomBytes: createRandomBytes(),
 });
 

package/src/local-first/Evolu.ts

@@ -1,16 +1,20 @@
-import type { ConsoleDep } from "@evolu/common";
+import { exhaustiveCheck, type ConsoleDep } from "@evolu/common";
 import type {
+  SharedWorker as CommonSharedWorker,
   CreateDbWorker,
   DbWorkerInit,
   EvoluDeps,
   SharedWorkerInput,
+  SharedWorkerOutput,
 } from "@evolu/common/local-first";
 import { createEvoluDeps as createCommonEvoluDeps } from "@evolu/common/local-first";
 import { reloadApp } from "../Platform.js";
 import {
+  createBroadcastChannel,
   createMessageChannel,
   createSharedWorker,
   createWorker,
+  installOneTabSharedWorkerPolyfill,
 } from "../Worker.js";
 
 // // TODO: Redesign.
@@ -20,8 +24,20 @@ import {
 //   secureStorage: createWebAuthnStore({ randomBytes: createRandomBytes() }),
 // });
 
+export interface SharedWorkerUnsupported {
+  readonly type: "SharedWorkerUnsupported";
+}
+
+export interface SharedWorkerUnsupportedDep {
+  readonly onSharedWorkerUnsupported: () => void;
+}
+
 /** Creates Evolu dependencies for the web platform. */
-export const createEvoluDeps = (deps: Partial<ConsoleDep> = {}): EvoluDeps => {
+export const createEvoluDeps = (
+  deps: Partial<ConsoleDep> & Partial<SharedWorkerUnsupportedDep> = {},
+): EvoluDeps => {
+  installOneTabSharedWorkerPolyfill();
+
   const createDbWorker: CreateDbWorker = () =>
     createWorker<DbWorkerInit, never>(
       new Worker(new URL("Db.worker.js", import.meta.url), {
@@ -29,16 +45,59 @@ export const createEvoluDeps = (deps: Partial<ConsoleDep> = {}): EvoluDeps => {
       }),
     );
 
-  const sharedWorker = createSharedWorker<SharedWorkerInput>(
+  const webSharedWorker = createSharedWorker<
+    SharedWorkerInput,
+    SharedWorkerOutput
+  >(
     new SharedWorker(new URL("Shared.worker.js", import.meta.url), {
       type: "module",
     }),
   );
+  let onSharedWorkerMessage: ((message: SharedWorkerOutput) => void) | null =
+    null;
+  const sharedWorker: CommonSharedWorker = {
+    ...webSharedWorker,
+    port: {
+      ...webSharedWorker.port,
+      get onMessage() {
+        return onSharedWorkerMessage;
+      },
+      set onMessage(fn) {
+        onSharedWorkerMessage = fn;
+        webSharedWorker.port.onMessage = fn
+          ? (message: SharedWorkerOutput | SharedWorkerUnsupported) => {
+              switch (message.type) {
+                case "DbWorkerInit": {
+                  fn(message);
+                  break;
+                }
+
+                case "SharedWorkerUnsupported": {
+                  if (deps.onSharedWorkerUnsupported) {
+                    deps.onSharedWorkerUnsupported();
+                  } else {
+                    globalThis.alert(
+                      "This browser supports Evolu in one tab only. Close this tab and use the already open tab.",
+                    );
+                  }
+                  break;
+                }
+
+                default:
+                  exhaustiveCheck(message);
+              }
+            }
+          : null;
+      },
+    },
+  };
 
   return createCommonEvoluDeps({
     ...deps,
     createDbWorker,
+    createBroadcastChannel,
     createMessageChannel,
+    lockManager: globalThis.navigator.locks,
     reloadApp,
     sharedWorker,
   });

package/src/local-first/Shared.worker.ts

@@ -1,18 +1,58 @@
 /// <reference lib="webworker" />
-declare const self: SharedWorkerGlobalScope;
+declare const self: DedicatedWorkerGlobalScope | SharedWorkerGlobalScope;
 
 import { installPolyfills } from "@evolu/common/polyfills";
 installPolyfills();
 
-import { createWebSocket } from "@evolu/common";
+import { createWebSocket, ok } from "@evolu/common";
+import type {
+  SharedWorkerInput,
+  SharedWorkerOutput,
+} from "@evolu/common/local-first";
 import { initSharedWorker } from "@evolu/common/local-first";
+import type { SharedWorkerUnsupported } from "./Evolu.js";
 import { createRun } from "../Task.js";
-import { createSharedWorkerSelf, createWorkerDeps } from "../Worker.js";
+import {
+  createOneTabSharedWorkerSelfPolyfill,
+  createSharedWorkerSelf,
+  createWorkerDeps,
+} from "../Worker.js";
 
 // No disposal (`await using`) is needed — a SharedWorker lives forever.
 const run = createRun({
   ...createWorkerDeps(),
   createWebSocket,
+  lockManager: globalThis.navigator.locks,
 });
 
-run(initSharedWorker(createSharedWorkerSelf(self)));
+void run(async (run) => {
+  if ("onconnect" in self) {
+    void run(initSharedWorker(createSharedWorkerSelf(self)));
+    return ok();
+  }
+
+  using workerSelf = createOneTabSharedWorkerSelfPolyfill<
+    SharedWorkerInput,
+    SharedWorkerOutput
+  >(self);
+
+  await globalThis.navigator.locks.request(
+    "evolu-one-tab-sharedworker-polyfill",
+    { ifAvailable: true, mode: "exclusive" },
+    async (lock) => {
+      if (!lock) {
+        const message: SharedWorkerUnsupported = {
+          type: "SharedWorkerUnsupported",
+        };
+        self.postMessage(message);
+        return;
+      }
+
+      void run(initSharedWorker(workerSelf));
+
+      await Promise.withResolvers<never>().promise;
+    },
+  );
+
+  return ok();
+});