cubing 0.22.1 → 0.23.0

package/src/cubing/search/instantiator.ts

@@ -1,60 +1,95 @@
-import type { WorkerInsideAPI } from "./inside/api";
-
 import {
   constructWorkerFromString,
   workerFileConstructor,
   wrap,
 } from "../vendor/comlink-everywhere/outside";
+import type { WorkerInsideAPI } from "./inside/api";
+import { getWorkerEntryFileURL } from "./inside/module-entry-path-getter";
+
+const MODULE_WORKER_TIMEOUT_MILLISECONDS = 5000;
+export async function instantiateModuleWorker(): Promise<WorkerInsideAPI> {
+  // eslint-disable-next-line no-async-promise-executor
+  return new Promise<WorkerInsideAPI>(async (resolve, reject) => {
+    const timeoutID = setTimeout(() => {
+      reject(new Error("module instantiation timeout"));
+    }, MODULE_WORKER_TIMEOUT_MILLISECONDS);
 
-import type { esmTestAPIImplementation } from "./esm-test-worker";
-type ESMTestAPI = typeof esmTestAPIImplementation;
+    try {
+      const workerEntryFileURL = await getWorkerEntryFileURL();
+      if (!workerEntryFileURL) {
+        // This happens in `bundle-global`.
+        reject(new Error("Could not get worker entry file URL."));
+      }
+      let url: string | URL;
+      if (globalThis.Blob) {
+        // Standard browser-like environment.
+        const importSrc = `import "${workerEntryFileURL}";`;
+        const blob = new Blob([importSrc], {
+          type: "text/javascript",
+        });
+        url = URL.createObjectURL(blob);
+      } else {
+        // `node` doesn't have `Blob`. We can keep the original entry file URL there, but we have to wrap it.
+        // Needed for `node`
+        url = new URL(workerEntryFileURL);
+      }
 
-// Blocked on:
-// - https://github.com/evanw/esbuild/issues/312
-// - https://bugzilla.mozilla.org/show_bug.cgi?id=1558780
-const TEST_RELATIVE_URL_WORKER = false;
+      const constructor = await workerFileConstructor();
+      const worker = new constructor(url, {
+        type: "module",
+      }) as Worker & {
+        nodeWorker?: import("worker_threads").Worker;
+      };
 
-export async function instantiateRelativeURLWorker(): Promise<void> {
-  // eslint-disable-next-line no-async-promise-executor
-  return new Promise(async (resolve, reject) => {
-    setTimeout(() => {
-      reject();
-    }, 1000);
+      const onError = (e: ErrorEvent) => {
+        // TODO: Remove fallback when Firefox implements module workers: https://bugzilla.mozilla.org/show_bug.cgi?id=1247687
+        if (e.message?.startsWith("SyntaxError")) {
+          reject(e);
+        }
+      };
 
-    const Worker = await workerFileConstructor();
-    const worker = new Worker(new URL("./esm-test-worker.js", import.meta.url));
-    const api = wrap<ESMTestAPI>(worker);
+      const onFirstMessage = (messageData: string) => {
+        if (messageData === "comlink-exposed") {
+          // We need to clear the timeout so that we don't prevent `node` from exiting in the meantime.
+          clearTimeout(timeoutID);
+          resolve(wrap<WorkerInsideAPI>(worker));
+        } else {
+          reject(
+            new Error("wrong module instantiation message " + messageData),
+          );
+        }
+      };
 
-    if ((await api.test("to worker")) === "from worker") {
-      resolve();
-    } else {
-      reject();
+      if (worker.nodeWorker) {
+        // We have to use `once` so the `unref()` from `comlink-everywhere` allows the process to quite as expected.
+        worker.nodeWorker.once("message", onFirstMessage);
+      } else {
+        worker.addEventListener("error", onError, {
+          once: true,
+        });
+        worker.addEventListener("message", (e) => onFirstMessage(e.data), {
+          once: true,
+        });
+      }
+    } catch (e) {
+      reject(e);
     }
-
-    // TODO: terminate worker.
   });
 }
 
-export async function relativeURLWorkerTest(): Promise<void> {
+export async function instantiateWorker(): Promise<WorkerInsideAPI> {
   try {
-    await instantiateRelativeURLWorker();
-    console.info("Successful relative URL worker instantiation.");
+    // `await` is important for `catch` to work.
+    return await instantiateModuleWorker();
   } catch (e) {
     console.warn(
-      "WARNING: Could not instantiate and communicate with a relative URL worker. This means that your app may have issues with `cubing/solve` in the future.",
+      "Could not instantiate module worker (this is expected in Firefox and `bundle-global`). Falling back to string worker.",
+      e,
     );
+    const { workerSource } = await import(
+      "./worker-inside-generated-string.js"
+    );
+    const worker = await constructWorkerFromString(workerSource);
+    return wrap(worker);
   }
 }
-
-export async function instantiateWorker(): Promise<WorkerInsideAPI> {
-  const { workerSource } = await import("./worker-inside-generated-string.js");
-  // console.log({ workerSource });
-
-  const worker = await constructWorkerFromString(workerSource);
-
-  if (TEST_RELATIVE_URL_WORKER) {
-    relativeURLWorkerTest(); // do not wait for the result
-  }
-
-  return wrap(worker);
-}