@jsenv/core 27.3.0 → 27.3.3

package/dist/main.js

@@ -9,6 +9,7 @@ import net, { createServer } from "node:net";
 import { Readable, Stream, Writable } from "node:stream";
 import { Http2ServerResponse } from "node:http2";
 import { createReadStream, readdirSync, statSync, readFile as readFile$1, chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFileSync as readFileSync$1, watch, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, existsSync, realpathSync } from "node:fs";
+import { lookup } from "node:dns";
 import { performance } from "node:perf_hooks";
 import { extname, dirname, basename } from "node:path";
 import { pathToFileURL, fileURLToPath } from "node:url";
@@ -2653,15 +2654,32 @@ const statusIsClientError = status => status >= 400 && status < 500;
 
 const statusIsServerError = status => status >= 500 && status < 600;
 
-const getServerOrigins = ({
+const applyDnsResolution = async hostname => {
+  const dnsResolution = await new Promise((resolve, reject) => {
+    lookup(hostname, (error, address, family) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve({
+          address,
+          family
+        });
+      }
+    });
+  });
+  return dnsResolution;
+};
+
+const getServerOrigins = async ({
   protocol,
   ip,
   port
 }) => {
   const isInternalIp = ip === "127.0.0.1";
+  const localhostDnsResolution = await applyDnsResolution("localhost");
   const internalOrigin = createServerOrigin({
     protocol,
-    hostname: "localhost",
+    hostname: localhostDnsResolution.address === "127.0.0.1" ? "localhost" : "127.0.0.1",
     port
   });
 
@@ -3536,7 +3554,7 @@ const startServer = async ({
   };
 
   status = "opened";
-  const serverOrigins = getServerOrigins({
+  const serverOrigins = await getServerOrigins({
     protocol,
     ip,
     port
@@ -8452,22 +8470,11 @@ const parseAndTransformJsUrls = async (urlInfo, context) => {
   } = context;
   const actions = [];
   const magicSource = createMagicSource(urlInfo.content);
-  urlInfo.data.usesImport = false;
-  urlInfo.data.usesExport = false;
-  urlInfo.data.usesImportAssertion = false;
   jsMentions.forEach(jsMention => {
-    if (jsMention.assert) {
-      urlInfo.data.usesImportAssertion = true;
-    }
-
     if (jsMention.subtype === "import_static" || jsMention.subtype === "import_dynamic") {
       urlInfo.data.usesImport = true;
     }
 
-    if (jsMention.subtype === "export") {
-      urlInfo.data.usesExport = true;
-    }
-
     const [reference] = referenceUtils.found({
       type: jsMention.type,
       subtype: jsMention.subtype,
@@ -10909,9 +10916,7 @@ const jsenvPluginNodeEsmResolution = ({
   const onFileChange = () => {
     packageScopesCache.clear();
     packageJsonsCache.clear();
-    Object.keys(urlGraph.urlInfos).forEach(url => {
-      const urlInfo = urlGraph.getUrlInfo(url);
-
+    urlGraph.urlInfoMap.forEach(urlInfo => {
       if (urlInfo.dependsOnPackageJson) {
         urlGraph.considerModified(urlInfo);
       }
@@ -19320,8 +19325,7 @@ const rollupPluginJsenv = ({
             data: {
               generatedBy: "rollup",
               bundleRelativeUrl: rollupFileInfo.fileName,
-              usesImport: rollupFileInfo.imports.length > 0 || rollupFileInfo.dynamicImports.length > 0,
-              usesExport: rollupFileInfo.exports.length > 0
+              usesImport: rollupFileInfo.imports.length > 0 || rollupFileInfo.dynamicImports.length > 0
             },
             contentType: "text/javascript",
             content: rollupFileInfo.code,
@@ -20320,8 +20324,6 @@ const jsenvPluginDevSSEServer = ({
   };
 
   const propagateUpdate = firstUrlInfo => {
-    const urlInfos = urlGraph.urlInfos;
-
     const iterate = (urlInfo, trace) => {
       if (urlInfo.data.hotAcceptSelf) {
         return {
@@ -20341,7 +20343,7 @@ const jsenvPluginDevSSEServer = ({
       const instructions = [];
 
       for (const dependentUrl of dependents) {
-        const dependentUrlInfo = urlInfos[dependentUrl];
+        const dependentUrlInfo = urlGraph.getUrlInfo(dependentUrl);
 
         if (dependentUrlInfo.data.hotDecline) {
           return {
@@ -20704,15 +20706,15 @@ const createUrlGraph = ({
   clientFileChangeCallbackList,
   clientFilesPruneCallbackList
 } = {}) => {
-  const urlInfos = {};
+  const urlInfoMap = new Map();
 
-  const getUrlInfo = url => urlInfos[url];
+  const getUrlInfo = url => urlInfoMap.get(url);
 
   const deleteUrlInfo = url => {
-    const urlInfo = urlInfos[url];
+    const urlInfo = urlInfoMap.get(url);
 
     if (urlInfo) {
-      delete urlInfos[url];
+      urlInfoMap.delete(url);
 
       if (urlInfo.sourcemapReference) {
         deleteUrlInfo(urlInfo.sourcemapReference.url);
@@ -20721,15 +20723,15 @@ const createUrlGraph = ({
   };
 
   const reuseOrCreateUrlInfo = url => {
-    const existingUrlInfo = urlInfos[url];
+    const existingUrlInfo = getUrlInfo(url);
     if (existingUrlInfo) return existingUrlInfo;
     const urlInfo = createUrlInfo(url);
-    urlInfos[url] = urlInfo;
+    urlInfoMap.set(url, urlInfo);
     return urlInfo;
   };
 
   const inferReference = (specifier, parentUrl) => {
-    const parentUrlInfo = urlInfos[parentUrl];
+    const parentUrlInfo = getUrlInfo(parentUrl);
 
     if (!parentUrlInfo) {
       return null;
@@ -20742,7 +20744,7 @@ const createUrlGraph = ({
   };
 
   const findDependent = (url, predicate) => {
-    const urlInfo = urlInfos[url];
+    const urlInfo = getUrlInfo(url);
 
     if (!urlInfo) {
       return null;
@@ -20750,7 +20752,7 @@ const createUrlGraph = ({
 
     const visitDependents = urlInfo => {
       for (const dependentUrl of urlInfo.dependents) {
-        const dependent = urlInfos[dependentUrl];
+        const dependent = getUrlInfo(dependentUrl);
 
         if (predicate(dependent)) {
           return dependent;
@@ -20800,7 +20802,7 @@ const createUrlGraph = ({
     const removeDependencies = (urlInfo, urlsToPrune) => {
       urlsToPrune.forEach(urlToPrune => {
         urlInfo.dependencies.delete(urlToPrune);
-        const dependency = urlInfos[urlToPrune];
+        const dependency = getUrlInfo(urlToPrune);
 
         if (!dependency) {
           return;
@@ -20840,7 +20842,7 @@ const createUrlGraph = ({
     clientFileChangeCallbackList.push(({
       url
     }) => {
-      const urlInfo = urlInfos[url];
+      const urlInfo = getUrlInfo(url);
 
       if (urlInfo) {
         considerModified(urlInfo, Date.now());
@@ -20860,7 +20862,7 @@ const createUrlGraph = ({
       urlInfo.modifiedTimestamp = modifiedTimestamp;
       urlInfo.contentEtag = undefined;
       urlInfo.dependents.forEach(dependentUrl => {
-        const dependentUrlInfo = urlInfos[dependentUrl];
+        const dependentUrlInfo = getUrlInfo(dependentUrl);
         const {
           hotAcceptDependencies = []
         } = dependentUrlInfo.data;
@@ -20890,7 +20892,7 @@ const createUrlGraph = ({
   };
 
   return {
-    urlInfos,
+    urlInfoMap,
     reuseOrCreateUrlInfo,
     getUrlInfo,
     deleteUrlInfo,
@@ -20899,13 +20901,20 @@ const createUrlGraph = ({
     updateReferences,
     considerModified,
     getRelatedUrlInfos,
+    toObject: () => {
+      const data = {};
+      urlInfoMap.forEach(urlInfo => {
+        data[urlInfo.url] = urlInfo;
+      });
+      return data;
+    },
     toJSON: rootDirectoryUrl => {
       const data = {};
-      Object.keys(urlInfos).forEach(url => {
-        const dependencyUrls = Array.from(urlInfos[url].dependencies);
+      urlInfoMap.forEach(urlInfo => {
+        const dependencyUrls = Array.from(urlInfo.dependencies);
 
         if (dependencyUrls.length) {
-          const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+          const relativeUrl = urlToRelativeUrl(urlInfo.url, rootDirectoryUrl);
           data[relativeUrl] = dependencyUrls.map(dependencyUrl => urlToRelativeUrl(dependencyUrl, rootDirectoryUrl));
         }
       });
@@ -23985,7 +23994,7 @@ const reportToCoverage = async (report, {
       // coverDescription will generate empty coverage for files
       // that were suppose to be coverage but were not.
       if (executionResult.status === "completed" && executionResult.type === "node" && coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
-        logger.warn(`No "coverageFileUrl" from execution named "${executionName}" of ${file}`);
+        logger.warn(`"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`);
       }
     }
   });
@@ -24066,17 +24075,22 @@ const getCoverageFromReport = async ({
         const {
           coverageFileUrl
         } = executionResultForFileOnRuntime;
+        let executionCoverage;
 
-        if (!coverageFileUrl) {
-          onMissing({
-            executionName,
-            file,
-            executionResult: executionResultForFileOnRuntime
-          });
-          return;
-        }
+        try {
+          executionCoverage = JSON.parse(String(readFileSync$1(new URL(coverageFileUrl))));
+        } catch (e) {
+          if (e.code === "ENOENT" || e.name === "SyntaxError") {
+            onMissing({
+              executionName,
+              file,
+              executionResult: executionResultForFileOnRuntime
+            });
+            return;
+          }
 
-        const executionCoverage = JSON.parse(String(readFileSync$1(new URL(coverageFileUrl))));
+          throw e;
+        }
 
         if (isV8Coverage(executionCoverage)) {
           v8Coverage = v8Coverage ? composeTwoV8Coverages(v8Coverage, executionCoverage) : executionCoverage;
@@ -24109,7 +24123,7 @@ const run = async ({
   runtime,
   runtimeParams
 }) => {
-  let result = {};
+  const result = {};
   const callbacks = [];
   const onConsoleRef = {
     current: () => {}
@@ -24127,18 +24141,14 @@ const run = async ({
     const timeoutAbortSource = runOperation.timeout(allocatedMs);
     callbacks.push(() => {
       if (result.status === "errored" && Abort.isAbortError(result.error) && timeoutAbortSource.signal.aborted) {
-        result = {
-          status: "timedout"
-        };
+        result.status = "timedout";
       }
     });
   }
 
   callbacks.push(() => {
     if (result.status === "errored" && Abort.isAbortError(result.error)) {
-      result = {
-        status: "aborted"
-      };
+      result.status = "aborted";
     }
   });
   const consoleCalls = [];
@@ -24167,6 +24177,22 @@ const run = async ({
     callbacks.push(() => {
       result.consoleCalls = consoleCalls;
     });
+  } // we do not keep coverage in memory, it can grow very big
+  // instead we store it on the filesystem
+  // and they can be read later at "coverageFileUrl"
+
+
+  let coverageFileUrl;
+
+  if (coverageEnabled) {
+    coverageFileUrl = new URL(`./${runtime.name}/${cuid()}.json`, coverageTempDirectoryUrl).href;
+    await ensureParentDirectories(coverageFileUrl);
+
+    if (coverageEnabled) {
+      result.coverageFileUrl = coverageFileUrl; // written within the child_process/worker_thread or during runtime.run()
+      // for browsers
+      // (because it takes time to serialize and transfer the coverage object)
+    }
   }
 
   const startMs = Date.now();
@@ -24191,7 +24217,9 @@ const run = async ({
               signal: runOperation.signal,
               logger,
               ...runtimeParams,
+              collectConsole,
               collectPerformance,
+              coverageFileUrl,
               keepRunning,
               stopSignal,
               onConsole: log => onConsoleRef.current(log)
@@ -24216,8 +24244,7 @@ const run = async ({
       status,
       namespace,
       error,
-      performance,
-      coverage
+      performance
     } = winner.data;
     result.status = status;
 
@@ -24231,27 +24258,13 @@ const run = async ({
       result.performance = performance;
     }
 
-    if (coverageEnabled) {
-      if (coverage) {
-        // we do not keep coverage in memory, it can grow very big
-        // instead we store it on the filesystem
-        // and they can be read later at "coverageFileUrl"
-        const coverageFileUrl = new URL(`./${runtime.name}/${cuid()}.json`, coverageTempDirectoryUrl);
-        writeFileSync(coverageFileUrl, JSON.stringify(coverage, null, "  "));
-        result.coverageFileUrl = coverageFileUrl.href;
-      } else {// will eventually log a warning in report_to_coverage.js
-      }
-    }
-
     callbacks.forEach(callback => {
       callback();
     });
     return result;
   } catch (e) {
-    result = {
-      status: "errored",
-      error: e
-    };
+    result.status = "errored";
+    result.error = e;
     callbacks.forEach(callback => {
       callback();
     });
@@ -24749,7 +24762,7 @@ const executePlan = async (plan, {
       } else {
         coverageMethodForNodeJs = "Profiler";
         logger.warn(createDetailedMessage$1(`process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`, {
-          "suggestion": `Preprend NODE_V8_COVERAGE=.coverage/node to the command executing this process`,
+          "suggestion": `set process.env.NODE_V8_COVERAGE`,
           "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`
         }));
       }
@@ -24827,7 +24840,7 @@ const executePlan = async (plan, {
             getCustomBabelPlugins: ({
               clientRuntimeCompat
             }) => {
-              if (coverageEnabled && Object.keys(clientRuntimeCompat)[0] !== "chrome") {
+              if (coverageEnabled && (coverageMethodForBrowsers !== "playwright_api" || Object.keys(clientRuntimeCompat)[0] !== "chrome")) {
                 return {
                   "transform-instrument": [babelPluginInstrument, {
                     rootDirectoryUrl,
@@ -25251,8 +25264,7 @@ const executeTestPlan = async ({
   },
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
-  coverageMethodForNodeJs = "NODE_V8_COVERAGE",
-  // "Profiler" also accepted
+  coverageMethodForNodeJs = process.env.NODE_V8_COVERAGE ? "NODE_V8_COVERAGE" : "Profiler",
   coverageMethodForBrowsers = "playwright_api",
   // "istanbul" also accepted
   coverageV8ConflictWarning = true,
@@ -25490,6 +25502,7 @@ const createRuntimeFromPlaywright = ({
     coverageEnabled = false,
     coverageConfig,
     coverageMethodForBrowsers,
+    coverageFileUrl,
     stopAfterAllSignal,
     stopSignal,
     keepRunning,
@@ -25572,13 +25585,14 @@ const createRuntimeFromPlaywright = ({
       }
     };
 
-    let resultTransformer = result => result;
+    const result = {};
+    const callbacks = [];
 
     if (coverageEnabled) {
       if (coveragePlaywrightAPIAvailable && coverageMethodForBrowsers === "playwright_api") {
         await page.coverage.startJSCoverage({// reportAnonymousScripts: true,
         });
-        resultTransformer = composeTransformer(resultTransformer, async result => {
+        callbacks.push(async () => {
           const v8CoveragesWithWebUrls = await page.coverage.stopJSCoverage(); // we convert urls starting with http:// to file:// because we later
           // convert the url to filesystem path in istanbulCoverageFromV8Coverage function
 
@@ -25599,23 +25613,20 @@ const createRuntimeFromPlaywright = ({
             rootDirectoryUrl,
             coverageConfig
           });
-          return { ...result,
-            coverage
-          };
+          writeFileSync$1(new URL(coverageFileUrl), JSON.stringify(coverage, null, "  "));
         });
       } else {
-        resultTransformer = composeTransformer(resultTransformer, async result => {
+        callbacks.push(() => {
           const scriptExecutionResults = result.namespace;
 
           if (scriptExecutionResults) {
-            result.coverage = generateCoverageForPage(scriptExecutionResults);
+            const coverage = generateCoverageForPage(scriptExecutionResults) || {};
+            writeFileSync$1(new URL(coverageFileUrl), JSON.stringify(coverage, null, "  "));
           }
-
-          return result;
         });
       }
     } else {
-      resultTransformer = composeTransformer(resultTransformer, result => {
+      callbacks.push(() => {
         const scriptExecutionResults = result.namespace;
 
         if (scriptExecutionResults) {
@@ -25623,13 +25634,11 @@ const createRuntimeFromPlaywright = ({
             delete scriptExecutionResults[fileRelativeUrl].coverage;
           });
         }
-
-        return result;
       });
     }
 
     if (collectPerformance) {
-      resultTransformer = composeTransformer(resultTransformer, async result => {
+      callbacks.push(async () => {
         const performance = await page.evaluate(
         /* eslint-disable no-undef */
 
@@ -25658,7 +25667,6 @@ const createRuntimeFromPlaywright = ({
         /* eslint-enable no-undef */
         );
         result.performance = performance;
-        return result;
       });
     }
 
@@ -25752,7 +25760,7 @@ const createRuntimeFromPlaywright = ({
             await page.goto(fileClientUrl, {
               timeout: 0
             });
-            const result = await page.evaluate(
+            const returnValue = await page.evaluate(
             /* eslint-disable no-undef */
 
             /* istanbul ignore next */
@@ -25768,12 +25776,12 @@ const createRuntimeFromPlaywright = ({
             const {
               status,
               scriptExecutionResults
-            } = result;
+            } = returnValue;
 
             if (status === "errored") {
               const {
                 exceptionSource
-              } = result;
+              } = returnValue;
               const error = evalException(exceptionSource, {
                 rootDirectoryUrl,
                 server,
@@ -25824,16 +25832,32 @@ const createRuntimeFromPlaywright = ({
       return winner.data;
     };
 
-    let result;
-
     try {
-      result = await getResult();
-      result = await resultTransformer(result);
+      const {
+        status,
+        error,
+        namespace,
+        performance
+      } = await getResult();
+      result.status = status;
+
+      if (status === "errored") {
+        result.error = error;
+      } else {
+        result.namespace = namespace;
+      }
+
+      if (collectPerformance) {
+        result.performance = performance;
+      }
+
+      await callbacks.reduce(async (previous, callback) => {
+        await previous;
+        await callback();
+      }, Promise.resolve());
     } catch (e) {
-      result = {
-        status: "errored",
-        error: e
-      };
+      result.status = "errored";
+      result.error = e;
     }
 
     if (keepRunning) {
@@ -25951,13 +25975,6 @@ const isTargetClosedError = error => {
   return false;
 };
 
-const composeTransformer = (previousTransformer, transformer) => {
-  return async value => {
-    const transformedValue = await previousTransformer(value);
-    return transformer(transformedValue);
-  };
-};
-
 const extractTextFromConsoleMessage = consoleMessage => {
   return consoleMessage.text(); // ensure we use a string so that istanbul won't try
   // to put any coverage statement inside it
@@ -26367,6 +26384,7 @@ nodeChildProcess.run = async ({
   coverageEnabled = false,
   coverageConfig,
   coverageMethodForNodeJs,
+  coverageFileUrl,
   collectPerformance,
   env,
   debugPort,
@@ -26530,6 +26548,7 @@ nodeChildProcess.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true
         }
       }
@@ -26710,10 +26729,12 @@ nodeWorkerThread.run = async ({
   keepRunning,
   stopSignal,
   onConsole,
+  collectConsole = false,
+  collectPerformance,
+  coverageEnabled = false,
   coverageConfig,
   coverageMethodForNodeJs,
-  coverageEnabled = false,
-  collectPerformance,
+  coverageFileUrl,
   env,
   debugPort,
   debugMode,
@@ -26777,6 +26798,16 @@ nodeWorkerThread.run = async ({
     onceWorkerThreadMessage(workerThread, "ready", resolve);
   });
   const stop = memoize(async () => {
+    // read all stdout before terminating
+    // (no need for stderr because it's sync)
+    if (collectConsole) {
+      while (workerThread.stdout.read() !== null) {}
+
+      await new Promise(resolve => {
+        setTimeout(resolve, 50);
+      });
+    }
+
     await workerThread.terminate();
   });
   const winnerPromise = new Promise(resolve => {
@@ -26816,6 +26847,7 @@ nodeWorkerThread.run = async ({
           coverageEnabled,
           coverageConfig,
           coverageMethodForNodeJs,
+          coverageFileUrl,
           exitAfterAction: true
         }
       }
@@ -27073,9 +27105,6 @@ ${createRepartitionMessage(graphReport)}
 };
 
 const createUrlGraphReport = urlGraph => {
-  const {
-    urlInfos
-  } = urlGraph;
   const countGroups = {
     sourcemaps: 0,
     html: 0,
@@ -27094,15 +27123,14 @@ const createUrlGraphReport = urlGraph => {
     other: 0,
     total: 0
   };
-  Object.keys(urlInfos).forEach(url => {
-    if (url.startsWith("data:")) {
+  urlGraph.urlInfoMap.forEach(urlInfo => {
+    if (urlInfo.url.startsWith("data:")) {
       return;
-    }
-
-    const urlInfo = urlInfos[url]; // ignore:
+    } // ignore:
     // - inline files: they are already taken into account in the file where they appear
     // - ignored files: we don't know their content
 
+
     if (urlInfo.isInline || !urlInfo.shouldHandle) {
       return;
     } // file loaded via import assertion are already inside the graph
@@ -27280,20 +27308,18 @@ const createRepartitionMessage = ({
 
 const GRAPH = {
   map: (graph, callback) => {
-    return Object.keys(graph.urlInfos).map(url => {
-      return callback(graph.urlInfos[url]);
+    const array = [];
+    graph.urlInfoMap.forEach(urlInfo => {
+      array.push(callback(urlInfo));
     });
+    return array;
   },
   forEach: (graph, callback) => {
-    Object.keys(graph.urlInfos).forEach(url => {
-      callback(graph.urlInfos[url], url);
-    });
+    graph.urlInfoMap.forEach(callback);
   },
   filter: (graph, callback) => {
     const urlInfos = [];
-    Object.keys(graph.urlInfos).forEach(url => {
-      const urlInfo = graph.urlInfos[url];
-
+    graph.urlInfoMap.forEach(urlInfo => {
       if (callback(urlInfo)) {
         urlInfos.push(urlInfo);
       }
@@ -27301,10 +27327,16 @@ const GRAPH = {
     return urlInfos;
   },
   find: (graph, callback) => {
-    const urlFound = Object.keys(graph.urlInfos).find(url => {
-      return callback(graph.urlInfos[url]);
-    });
-    return graph.urlInfos[urlFound];
+    let found = null;
+
+    for (const urlInfo of graph.urlInfoMap.values()) {
+      if (callback(urlInfo)) {
+        found = urlInfo;
+        break;
+      }
+    }
+
+    return found;
   }
 };
 
@@ -28450,7 +28482,7 @@ build ${entryPointKeys.length} entry points`);
 
     buildTask.done();
     logger.debug(`graph urls pre-versioning:
-${Object.keys(finalGraph.urlInfos).join("\n")}`);
+${Array.from(finalGraph.urlInfoMap.keys()).join("\n")}`);
 
     if (versioning) {
       await applyUrlVersioning({
@@ -28706,7 +28738,7 @@ const applyUrlVersioning = async ({
   });
 
   try {
-    const urlsSorted = sortByDependencies(finalGraph.urlInfos);
+    const urlsSorted = sortByDependencies(finalGraph.toObject());
     urlsSorted.forEach(url => {
       if (url.startsWith("data:")) {
         return;