@jsenv/test 1.1.2 → 1.1.4

package/src/runtime_node/execute_using_dynamic_import.js

@@ -1,7 +1,7 @@
-import { writeFileSync } from "node:fs"
+import { writeFileSync } from "node:fs";
 
-import { startJsCoverage } from "./profiler_v8_coverage.js"
-import { startObservingPerformances } from "./node_execution_performance.js"
+import { startJsCoverage } from "./profiler_v8_coverage.js";
+import { startObservingPerformances } from "./node_execution_performance.js";
 
 export const executeUsingDynamicImport = async ({
   rootDirectoryUrl,
@@ -12,42 +12,42 @@ export const executeUsingDynamicImport = async ({
   coverageMethodForNodeJs,
   coverageFileUrl,
 }) => {
-  const result = {}
-  const afterImportCallbacks = []
+  const result = {};
+  const afterImportCallbacks = [];
   if (coverageEnabled && coverageMethodForNodeJs === "Profiler") {
-    const { filterV8Coverage } = await import("../coverage/v8_coverage.js")
-    const { stopJsCoverage } = await startJsCoverage()
+    const { filterV8Coverage } = await import("../coverage/v8_coverage.js");
+    const { stopJsCoverage } = await startJsCoverage();
     afterImportCallbacks.push(async () => {
-      const coverage = await stopJsCoverage()
+      const coverage = await stopJsCoverage();
       const coverageLight = await filterV8Coverage(coverage, {
         rootDirectoryUrl,
         coverageConfig,
-      })
+      });
       writeFileSync(
         new URL(coverageFileUrl),
         JSON.stringify(coverageLight, null, "  "),
-      )
-    })
+      );
+    });
   }
   if (collectPerformance) {
-    const getPerformance = startObservingPerformances()
+    const getPerformance = startObservingPerformances();
     afterImportCallbacks.push(async () => {
-      const performance = await getPerformance()
-      result.performance = performance
-    })
+      const performance = await getPerformance();
+      result.performance = performance;
+    });
   }
-  const namespace = await import(fileUrl)
-  const namespaceResolved = {}
+  const namespace = await import(fileUrl);
+  const namespaceResolved = {};
   await Promise.all(
     Object.keys(namespace).map(async (key) => {
-      const value = await namespace[key]
-      namespaceResolved[key] = value
+      const value = await namespace[key];
+      namespaceResolved[key] = value;
     }),
-  )
-  result.namespace = namespaceResolved
+  );
+  result.namespace = namespaceResolved;
   await afterImportCallbacks.reduce(async (previous, afterImportCallback) => {
-    await previous
-    await afterImportCallback()
-  }, Promise.resolve())
-  return result
-}
+    await previous;
+    await afterImportCallback();
+  }, Promise.resolve());
+  return result;
+};

package/src/runtime_node/exit_codes.js

@@ -1,9 +1,9 @@
 // https://nodejs.org/api/process.html#process_signal_events
-const SIGINT_SIGNAL_NUMBER = 2
-const SIGABORT_SIGNAL_NUMBER = 6
-const SIGTERM_SIGNAL_NUMBER = 15
+const SIGINT_SIGNAL_NUMBER = 2;
+const SIGABORT_SIGNAL_NUMBER = 6;
+const SIGTERM_SIGNAL_NUMBER = 15;
 export const EXIT_CODES = {
   SIGINT: 128 + SIGINT_SIGNAL_NUMBER,
   SIGABORT: 128 + SIGABORT_SIGNAL_NUMBER,
   SIGTERM: 128 + SIGTERM_SIGNAL_NUMBER,
-}
+};

package/src/runtime_node/importmap_node_loader.mjs

@@ -1,51 +1,51 @@
-import { readFileSync } from "node:fs"
-import { pathToFileURL } from "node:url"
-import { normalizeImportMap, resolveImport } from "@jsenv/importmap"
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { normalizeImportMap, resolveImport } from "@jsenv/importmap";
 
-let importMap
+let importMap;
 
-const cwdUrl = `${String(pathToFileURL(process.cwd()))}/`
+const cwdUrl = `${String(pathToFileURL(process.cwd()))}/`;
 
 if (process.env.IMPORT_MAP) {
-  importMap = JSON.parse(process.env.IMPORT_MAP)
+  importMap = JSON.parse(process.env.IMPORT_MAP);
 } else if (process.env.IMPORT_MAP_PATH) {
-  const importmapFileUrl = pathToFileURL(process.env.IMPORT_MAP_PATH)
-  const importmapFileContentAsString = readFileSync(importmapFileUrl, "utf8")
-  importMap = JSON.parse(importmapFileContentAsString)
+  const importmapFileUrl = pathToFileURL(process.env.IMPORT_MAP_PATH);
+  const importmapFileContentAsString = readFileSync(importmapFileUrl, "utf8");
+  importMap = JSON.parse(importmapFileContentAsString);
 } else {
-  const importmapFileUrl = new URL("./import_map.json", cwdUrl)
-  const importmapFileContentAsString = readFileSync(importmapFileUrl, "utf8")
-  importMap = JSON.parse(importmapFileContentAsString)
+  const importmapFileUrl = new URL("./import_map.json", cwdUrl);
+  const importmapFileContentAsString = readFileSync(importmapFileUrl, "utf8");
+  importMap = JSON.parse(importmapFileContentAsString);
 }
 
-const importMapBaseUrl = process.env.IMPORT_MAP_BASE_URL || cwdUrl
-importMap = normalizeImportMap(importMap, importMapBaseUrl)
+const importMapBaseUrl = process.env.IMPORT_MAP_BASE_URL || cwdUrl;
+importMap = normalizeImportMap(importMap, importMapBaseUrl);
 
 export const resolve = (specifier, context, nextResolve) => {
   try {
-    let mapped
-    const importer = context.parentURL ? String(context.parentURL) : undefined
+    let mapped;
+    const importer = context.parentURL ? String(context.parentURL) : undefined;
     const resolved = resolveImport({
       specifier,
       importer,
       importMap,
       defaultExtension: ".js",
       onImportMapping: () => {
-        mapped = true
+        mapped = true;
       },
-    })
+    });
     if (mapped) {
       return {
         shortCircuit: true,
         url: resolved,
-      }
+      };
     }
   } catch (e) {
     if (e.message.includes("bare specifier")) {
-      return nextResolve(specifier, context)
+      return nextResolve(specifier, context);
     }
-    console.error(e)
-    return nextResolve(specifier, context)
+    console.error(e);
+    return nextResolve(specifier, context);
   }
-  return nextResolve(specifier, context)
-}
+  return nextResolve(specifier, context);
+};

package/src/runtime_node/importmap_node_loader_file_url.js

@@ -1,4 +1,4 @@
 export const IMPORTMAP_NODE_LOADER_FILE_URL = new URL(
   "./importmap_node_loader.mjs?entry_point",
   import.meta.url,
-).href
+).href;

package/src/runtime_node/kill_process_tree.js

@@ -1,57 +1,57 @@
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
 // see also https://github.com/sindresorhus/execa/issues/96
 export const killProcessTree = async (
   processId,
   { signal, timeout = 2000 },
 ) => {
-  const pidtree = requireFromJsenv("pidtree")
+  const pidtree = requireFromJsenv("pidtree");
 
-  let descendantProcessIds
+  let descendantProcessIds;
   try {
-    descendantProcessIds = await pidtree(processId)
+    descendantProcessIds = await pidtree(processId);
   } catch (e) {
     if (e.message === "No matching pid found") {
-      descendantProcessIds = []
+      descendantProcessIds = [];
     } else {
-      throw e
+      throw e;
     }
   }
   descendantProcessIds.forEach((descendantProcessId) => {
     try {
-      process.kill(descendantProcessId, signal)
+      process.kill(descendantProcessId, signal);
     } catch (error) {
       // ignore
     }
-  })
+  });
 
   try {
-    process.kill(processId, signal)
+    process.kill(processId, signal);
   } catch (e) {
     if (e.code !== "ESRCH") {
-      throw e
+      throw e;
     }
   }
 
-  let remainingIds = [...descendantProcessIds, processId]
+  let remainingIds = [...descendantProcessIds, processId];
 
   const updateRemainingIds = () => {
     remainingIds = remainingIds.filter((remainingId) => {
       try {
-        process.kill(remainingId, 0)
-        return true
+        process.kill(remainingId, 0);
+        return true;
       } catch (e) {
-        return false
+        return false;
       }
-    })
-  }
+    });
+  };
 
-  let timeSpentWaiting = 0
+  let timeSpentWaiting = 0;
 
   const check = async () => {
-    updateRemainingIds()
+    updateRemainingIds();
     if (remainingIds.length === 0) {
-      return
+      return;
     }
 
     if (timeSpentWaiting > timeout) {
@@ -59,18 +59,18 @@ export const killProcessTree = async (
         `timed out waiting for ${
           remainingIds.length
         } process to exit (${remainingIds.join(" ")})`,
-      )
-      timeoutError.code = "TIMEOUT"
-      throw timeoutError
+      );
+      timeoutError.code = "TIMEOUT";
+      throw timeoutError;
     }
 
-    await new Promise((resolve) => setTimeout(resolve, 400))
-    timeSpentWaiting += 400
-    await check()
-  }
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    timeSpentWaiting += 400;
+    await check();
+  };
 
   await new Promise((resolve) => {
-    setTimeout(resolve, 0)
-  })
-  await check()
-}
+    setTimeout(resolve, 0);
+  });
+  await check();
+};

package/src/runtime_node/no_experimental_warnings.cjs

@@ -1,13 +1,13 @@
 // see https://github.com/nodejs/node/issues/47478
-const originalEmit = process.emit
+const originalEmit = process.emit;
 process.emit = (event, error) => {
   if (event === "warning" && error.name === "ExperimentalWarning") {
     if (
       error.message.includes("--experimental-loader") ||
       error.message.includes("Custom ESM Loaders is an experimental")
     ) {
-      return false
+      return false;
     }
   }
-  return originalEmit.call(process, event, error)
-}
+  return originalEmit.call(process, event, error);
+};

package/src/runtime_node/no_experimental_warnings_file_url.js

@@ -1,4 +1,4 @@
 export const NO_EXPERIMENTAL_WARNING_FILE_URL = new URL(
   "./no_experimental_warnings.cjs?entry_point",
   import.meta.url,
-).href
+).href;