@jsenv/test 1.1.2 → 1.1.3

package/src/runtime_node/node_worker_thread.js

@@ -1,25 +1,25 @@
 // https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/fork.js#L23
 // https://nodejs.org/api/worker_threads.html
 // https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/worker/base.js
-import { Worker } from "node:worker_threads"
-import { fileURLToPath } from "node:url"
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
 import {
   Abort,
   createCallbackListNotifiedOnce,
   raceCallbacks,
-} from "@jsenv/abort"
-import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
+} from "@jsenv/abort";
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js";
 
-import { createChildExecOptions } from "./child_exec_options.js"
-import { ExecOptions } from "./exec_options.js"
-import { EXIT_CODES } from "./exit_codes.js"
-import { IMPORTMAP_NODE_LOADER_FILE_URL } from "./importmap_node_loader_file_url.js"
-import { NO_EXPERIMENTAL_WARNING_FILE_URL } from "./no_experimental_warnings_file_url.js"
+import { createChildExecOptions } from "./child_exec_options.js";
+import { ExecOptions } from "./exec_options.js";
+import { EXIT_CODES } from "./exit_codes.js";
+import { IMPORTMAP_NODE_LOADER_FILE_URL } from "./importmap_node_loader_file_url.js";
+import { NO_EXPERIMENTAL_WARNING_FILE_URL } from "./no_experimental_warnings_file_url.js";
 
 const CONTROLLABLE_WORKER_THREAD_URL = new URL(
   "./controllable_worker_thread.mjs?entry_point",
   import.meta.url,
-).href
+).href;
 
 export const nodeWorkerThread = ({
   importMap,
@@ -31,12 +31,12 @@ export const nodeWorkerThread = ({
   commandLineOptions = [],
 } = {}) => {
   if (env !== undefined && typeof env !== "object") {
-    throw new TypeError(`env must be an object, got ${env}`)
+    throw new TypeError(`env must be an object, got ${env}`);
   }
   env = {
     ...env,
     JSENV: true,
-  }
+  };
 
   return {
     type: "node",
@@ -60,17 +60,17 @@ export const nodeWorkerThread = ({
       coverageFileUrl,
     }) => {
       if (coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
-        env.NODE_V8_COVERAGE = ""
+        env.NODE_V8_COVERAGE = "";
       }
       if (importMap) {
-        env.IMPORT_MAP = JSON.stringify(importMap)
-        env.IMPORT_MAP_BASE_URL = rootDirectoryUrl
+        env.IMPORT_MAP = JSON.stringify(importMap);
+        env.IMPORT_MAP_BASE_URL = rootDirectoryUrl;
         commandLineOptions.push(
           `--experimental-loader=${IMPORTMAP_NODE_LOADER_FILE_URL}`,
-        )
+        );
         commandLineOptions.push(
           `--require=${fileURLToPath(NO_EXPERIMENTAL_WARNING_FILE_URL)}`,
-        )
+        );
       }
 
       const workerThreadExecOptions = await createChildExecOptions({
@@ -78,22 +78,22 @@ export const nodeWorkerThread = ({
         debugPort,
         debugMode,
         debugModeInheritBreak,
-      })
+      });
       const execArgvForWorkerThread = ExecOptions.toExecArgv({
         ...workerThreadExecOptions,
         ...ExecOptions.fromExecArgv(commandLineOptions),
-      })
+      });
       const envForWorkerThread = {
         ...(inheritProcessEnv ? process.env : {}),
         ...env,
-      }
+      };
 
-      const cleanupCallbackList = createCallbackListNotifiedOnce()
+      const cleanupCallbackList = createCallbackListNotifiedOnce();
       const cleanup = async (reason) => {
-        await cleanupCallbackList.notify({ reason })
-      }
-      const actionOperation = Abort.startOperation()
-      actionOperation.addAbortSignal(signal)
+        await cleanupCallbackList.notify({ reason });
+      };
+      const actionOperation = Abort.startOperation();
+      actionOperation.addAbortSignal(signal);
       // https://nodejs.org/api/worker_threads.html#new-workerfilename-options
       const workerThread = new Worker(
         fileURLToPath(CONTROLLABLE_WORKER_THREAD_URL),
@@ -105,16 +105,16 @@ export const nodeWorkerThread = ({
           stdout: true,
           stderr: true,
         },
-      )
+      );
       const removeOutputListener = installWorkerThreadOutputListener(
         workerThread,
         ({ type, text }) => {
-          onConsole({ type, text })
+          onConsole({ type, text });
         },
-      )
+      );
       const workerThreadReadyPromise = new Promise((resolve) => {
-        onceWorkerThreadMessage(workerThread, "ready", resolve)
-      })
+        onceWorkerThreadMessage(workerThread, "ready", resolve);
+      });
 
       const stop = memoize(async () => {
         // read all stdout before terminating
@@ -122,48 +122,48 @@ export const nodeWorkerThread = ({
         if (collectConsole) {
           while (workerThread.stdout.read() !== null) {}
           await new Promise((resolve) => {
-            setTimeout(resolve, 50)
-          })
+            setTimeout(resolve, 50);
+          });
         }
-        await workerThread.terminate()
-      })
+        await workerThread.terminate();
+      });
 
       const winnerPromise = new Promise((resolve) => {
         raceCallbacks(
           {
             aborted: (cb) => {
-              return actionOperation.addAbortCallback(cb)
+              return actionOperation.addAbortCallback(cb);
             },
             error: (cb) => {
-              return onceWorkerThreadEvent(workerThread, "error", cb)
+              return onceWorkerThreadEvent(workerThread, "error", cb);
             },
             exit: (cb) => {
               return onceWorkerThreadEvent(
                 workerThread,
                 "exit",
                 (code, signal) => {
-                  cb({ code, signal })
+                  cb({ code, signal });
                 },
-              )
+              );
             },
             response: (cb) => {
-              return onceWorkerThreadMessage(workerThread, "action-result", cb)
+              return onceWorkerThreadMessage(workerThread, "action-result", cb);
             },
           },
           resolve,
-        )
-      })
+        );
+      });
 
       const result = {
         status: "executing",
         errors: [],
         namespace: null,
-      }
+      };
 
       const writeResult = async () => {
-        actionOperation.throwIfAborted()
-        await workerThreadReadyPromise
-        actionOperation.throwIfAborted()
+        actionOperation.throwIfAborted();
+        await workerThreadReadyPromise;
+        actionOperation.throwIfAborted();
         await sendToWorkerThread(workerThread, {
           type: "action",
           data: {
@@ -179,30 +179,30 @@ export const nodeWorkerThread = ({
               exitAfterAction: true,
             },
           },
-        })
-        const winner = await winnerPromise
+        });
+        const winner = await winnerPromise;
         if (winner.name === "aborted") {
-          result.status = "aborted"
-          return
+          result.status = "aborted";
+          return;
         }
         if (winner.name === "error") {
-          const error = winner.data
-          removeOutputListener()
-          result.status = "failed"
-          result.errors.push(error)
-          return
+          const error = winner.data;
+          removeOutputListener();
+          result.status = "failed";
+          result.errors.push(error);
+          return;
         }
         if (winner.name === "exit") {
-          const { code } = winner.data
-          await cleanup("process exit")
+          const { code } = winner.data;
+          await cleanup("process exit");
           if (code === 12) {
-            result.status = "failed"
+            result.status = "failed";
             result.errors.push(
               new Error(
                 `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
               ),
-            )
-            return
+            );
+            return;
           }
           if (
             code === null ||
@@ -211,91 +211,91 @@ export const nodeWorkerThread = ({
             code === EXIT_CODES.SIGTERM ||
             code === EXIT_CODES.SIGABORT
           ) {
-            result.status = "failed"
+            result.status = "failed";
             result.errors.push(
               new Error(`node worker thread exited during execution`),
-            )
-            return
+            );
+            return;
           }
           // process.exit(1) in child process or process.exitCode = 1 + process.exit()
           // means there was an error even if we don't know exactly what.
-          result.status = "failed"
+          result.status = "failed";
           result.errors.push(
             new Error(
               `node worker thread exited with code ${code} during execution`,
             ),
-          )
+          );
         }
-        const { status, value } = winner.data
+        const { status, value } = winner.data;
         if (status === "action-failed") {
-          result.status = "failed"
-          result.errors.push(value)
-          return
+          result.status = "failed";
+          result.errors.push(value);
+          return;
         }
-        const { namespace, performance, coverage } = value
-        result.status = "completed"
-        result.namespace = namespace
-        result.performance = performance
-        result.coverage = coverage
-      }
+        const { namespace, performance, coverage } = value;
+        result.status = "completed";
+        result.namespace = namespace;
+        result.performance = performance;
+        result.coverage = coverage;
+      };
 
       try {
-        await writeResult()
+        await writeResult();
       } catch (e) {
-        result.status = "failed"
-        result.errors.push(e)
+        result.status = "failed";
+        result.errors.push(e);
       }
 
       if (keepRunning) {
-        stopSignal.notify = stop
+        stopSignal.notify = stop;
       } else {
-        await stop()
+        await stop();
       }
-      await actionOperation.end()
-      return result
+      await actionOperation.end();
+      return result;
     },
-  }
-}
+  };
+};
 
 const installWorkerThreadOutputListener = (workerThread, callback) => {
   // beware that we may receive ansi output here, should not be a problem but keep that in mind
   const stdoutDataCallback = (chunk) => {
-    const text = String(chunk)
-    callback({ type: "log", text })
-  }
-  workerThread.stdout.on("data", stdoutDataCallback)
+    const text = String(chunk);
+    callback({ type: "log", text });
+  };
+  workerThread.stdout.on("data", stdoutDataCallback);
   const stdErrorDataCallback = (chunk) => {
-    const text = String(chunk)
-    callback({ type: "error", text })
-  }
-  workerThread.stderr.on("data", stdErrorDataCallback)
+    const text = String(chunk);
+    callback({ type: "error", text });
+  };
+  workerThread.stderr.on("data", stdErrorDataCallback);
   return () => {
-    workerThread.stdout.removeListener("data", stdoutDataCallback)
-    workerThread.stderr.removeListener("data", stdErrorDataCallback)
-  }
-}
+    workerThread.stdout.removeListener("data", stdoutDataCallback);
+    workerThread.stderr.removeListener("data", stdErrorDataCallback);
+  };
+};
 
 const sendToWorkerThread = (worker, { type, data }) => {
-  worker.postMessage({ jsenv: true, type, data })
-}
+  worker.postMessage({ jsenv: true, type, data });
+};
 
 const onceWorkerThreadMessage = (workerThread, type, callback) => {
   const onmessage = (message) => {
     if (message && message.jsenv && message.type === type) {
-      workerThread.removeListener("message", onmessage)
+      workerThread.removeListener("message", onmessage);
       // eslint-disable-next-line no-eval
-      callback(message.data ? eval(`(${message.data})`) : undefined)
+      callback(message.data ? eval(`(${message.data})`) : undefined);
     }
-  }
-  workerThread.on("message", onmessage)
+  };
+  workerThread.on("message", onmessage);
   return () => {
-    workerThread.removeListener("message", onmessage)
-  }
-}
+    workerThread.removeListener("message", onmessage);
+  };
+};
 
 const onceWorkerThreadEvent = (worker, type, callback) => {
-  worker.once(type, callback)
+  worker.once(type, callback);
   return () => {
-    worker.removeListener(type, callback)
-  }
-}
+    worker.removeListener(type, callback);
+  };
+};

package/src/runtime_node/profiler_v8_coverage.js

@@ -13,44 +13,44 @@
  * - https://vanilla.aslushnikov.com/?Profiler.startPreciseCoverage
  */
 
-import { Session } from "node:inspector"
+import { Session } from "node:inspector";
 
 export const startJsCoverage = async ({
   callCount = true,
   detailed = true,
 } = {}) => {
-  const session = new Session()
-  session.connect()
+  const session = new Session();
+  session.connect();
   const postSession = (action, options) => {
     const promise = new Promise((resolve, reject) => {
       session.post(action, options, (error, data) => {
         if (error) {
-          reject(error)
+          reject(error);
         } else {
-          resolve(data)
+          resolve(data);
         }
-      })
-    })
-    return promise
-  }
+      });
+    });
+    return promise;
+  };
 
-  await postSession("Profiler.enable")
-  await postSession("Profiler.startPreciseCoverage", { callCount, detailed })
+  await postSession("Profiler.enable");
+  await postSession("Profiler.startPreciseCoverage", { callCount, detailed });
 
   const takeJsCoverage = async () => {
-    const coverage = await postSession("Profiler.takePreciseCoverage")
-    return coverage
-  }
+    const coverage = await postSession("Profiler.takePreciseCoverage");
+    return coverage;
+  };
 
   const stopJsCoverage = async () => {
-    const coverage = await takeJsCoverage()
-    await postSession("Profiler.stopPreciseCoverage")
-    await postSession("Profiler.disable")
-    return coverage
-  }
+    const coverage = await takeJsCoverage();
+    await postSession("Profiler.stopPreciseCoverage");
+    await postSession("Profiler.disable");
+    return coverage;
+  };
 
   return {
     takeJsCoverage,
     stopJsCoverage,
-  }
-}
+  };
+};