@jsenv/core 23.3.0 → 23.5.0

package/src/internal/executing/{coverage → coverage_missing}/relativeUrlToEmptyCoverage.js

@@ -1,30 +1,32 @@
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
 } from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-import { babelPluginInstrument } from "./babel_plugin_instrument.js"
+import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
 import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
-  { multipleExecutionsOperation, projectDirectoryUrl, babelPluginMap },
+  { signal, projectDirectoryUrl, babelPluginMap },
 ) => {
-  const { transformAsync } = await import("@babel/core")
-
-  const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  multipleExecutionsOperation.throwIfAborted()
-  const source = await readFile(fileUrl)
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
 
   try {
+    const { transformAsync } = await import("@babel/core")
+    const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
+    const source = await readFile(fileUrl)
+
     babelPluginMap = {
       ...getMinimalBabelPluginMap(),
       ...babelPluginMap,
       "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
     }
 
-    multipleExecutionsOperation.throwIfAborted()
+    operation.throwIfAborted()
     const { metadata } = await transformAsync(source, {
       filename: urlToFileSystemPath(fileUrl),
       filenameRelative: relativeUrl,
@@ -55,5 +57,7 @@ export const relativeUrlToEmptyCoverage = async (
       return createEmptyCoverage(relativeUrl)
     }
     throw e
+  } finally {
+    await operation.end()
   }
 }

package/src/internal/executing/{coverage/generateCoverageHtmlDirectory.js → coverage_reporter/coverage_reporter_html_directory.js}

@@ -1,13 +1,17 @@
-import { readFileSync } from "fs"
+import { readFileSync } from "node:fs"
 import { resolveUrl, urlToFileSystemPath } from "@jsenv/filesystem"
 
 import { require } from "../../require.js"
-
 import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
 
 export const generateCoverageHtmlDirectory = async (
   coverage,
-  { projectDirectoryUrl, coverageHtmlDirectoryRelativeUrl, coverageSkipEmpty, coverageSkipFull },
+  {
+    projectDirectoryUrl,
+    coverageHtmlDirectoryRelativeUrl,
+    coverageSkipEmpty,
+    coverageSkipFull,
+  },
 ) => {
   const libReport = require("istanbul-lib-report")
   const reports = require("istanbul-reports")
@@ -16,7 +20,10 @@ export const generateCoverageHtmlDirectory = async (
     dir: urlToFileSystemPath(projectDirectoryUrl),
     coverageMap: istanbulCoverageMapFromCoverage(coverage),
     sourceFinder: (path) => {
-      return readFileSync(urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)), "utf8")
+      return readFileSync(
+        urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)),
+        "utf8",
+      )
     },
   })
 

package/src/internal/executing/{coverage/generateCoverageTextLog.js → coverage_reporter/coverage_reporter_text_log.js}

@@ -1,8 +1,10 @@
 import { require } from "../../require.js"
-
 import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
 
-export const generateCoverageTextLog = (coverage, { coverageSkipEmpty, coverageSkipFull }) => {
+export const generateCoverageTextLog = (
+  coverage,
+  { coverageSkipEmpty, coverageSkipFull },
+) => {
   const libReport = require("istanbul-lib-report")
   const reports = require("istanbul-reports")
 

package/src/internal/executing/{coverage/normalizeIstanbulCoverage.js → coverage_utils/file_by_file_coverage.js}

@@ -5,22 +5,24 @@ import {
   resolveUrl,
 } from "@jsenv/filesystem"
 
-export const normalizeIstanbulCoverage = (istanbulCoverage, projectDirectoryUrl) => {
-  const istanbulCoverageNormalized = {}
+export const normalizeFileByFileCoveragePaths = (
+  fileByFileCoverage,
+  projectDirectoryUrl,
+) => {
+  const fileByFileNormalized = {}
 
-  Object.keys(istanbulCoverage).forEach((key) => {
-    const fileCoverage = istanbulCoverage[key]
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
     const { path } = fileCoverage
     const url = isFileSystemPath(path)
       ? fileSystemPathToUrl(path)
       : resolveUrl(path, projectDirectoryUrl)
     const relativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
-
-    istanbulCoverageNormalized[`./${relativeUrl}`] = {
+    fileByFileNormalized[`./${relativeUrl}`] = {
       ...fileCoverage,
       path: `./${relativeUrl}`,
     }
   })
 
-  return istanbulCoverageNormalized
+  return fileByFileNormalized
 }

package/src/internal/executing/coverage_utils/istanbul_coverage_composition.js

@@ -0,0 +1,28 @@
+import { require } from "../../require.js"
+
+export const composeTwoFileByFileIstanbulCoverages = (
+  firstFileByFileIstanbulCoverage,
+  secondFileByFileIstanbulCoverage,
+) => {
+  const fileByFileIstanbulCoverage = {}
+  Object.keys(firstFileByFileIstanbulCoverage).forEach((key) => {
+    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key]
+  })
+  Object.keys(secondFileByFileIstanbulCoverage).forEach((key) => {
+    const firstCoverage = firstFileByFileIstanbulCoverage[key]
+    const secondCoverage = secondFileByFileIstanbulCoverage[key]
+    fileByFileIstanbulCoverage[key] = firstCoverage
+      ? merge(firstCoverage, secondCoverage)
+      : secondCoverage
+  })
+
+  return fileByFileIstanbulCoverage
+}
+
+const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
+  const { createFileCoverage } = require("istanbul-lib-coverage")
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
+  return istanbulCoverage
+}

package/src/internal/executing/coverage_utils/v8_and_istanbul.js

@@ -0,0 +1,38 @@
+import { createDetailedMessage } from "@jsenv/logger"
+
+export const composeV8AndIstanbul = (
+  v8FileByFileCoverage,
+  istanbulFileByFileCoverage,
+  { coverageV8ConflictWarning },
+) => {
+  const fileByFileCoverage = {}
+  const v8Files = Object.keys(v8FileByFileCoverage)
+  const istanbulFiles = Object.keys(istanbulFileByFileCoverage)
+
+  v8Files.forEach((key) => {
+    fileByFileCoverage[key] = v8FileByFileCoverage[key]
+  })
+  istanbulFiles.forEach((key) => {
+    const v8Coverage = v8FileByFileCoverage[key]
+    if (v8Coverage) {
+      if (coverageV8ConflictWarning) {
+        console.warn(
+          createDetailedMessage(
+            `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
+            {
+              "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
+              "suggestion":
+                "You can disable this warning with coverageV8ConflictWarning: false",
+              "suggestion 2": `You can force usage of istanbul to prevent this conflict with coverageForceIstanbul: true`,
+            },
+          ),
+        )
+      }
+      fileByFileCoverage[key] = v8Coverage
+    } else {
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key]
+    }
+  })
+
+  return fileByFileCoverage
+}

package/src/internal/executing/coverage_utils/v8_coverage_composition.js

@@ -0,0 +1,23 @@
+import { require } from "@jsenv/core/src/internal/require.js"
+
+export const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
+  if (secondV8Coverage.result.length === 0) {
+    return firstV8Coverage
+  }
+
+  const { mergeProcessCovs } = require("@c88/v8-coverage")
+  // "mergeProcessCovs" do not preserves source-map-cache during the merge
+  // so we store sourcemap cache now
+  const sourceMapCache = {}
+  const visit = (coverageReport) => {
+    if (coverageReport["source-map-cache"]) {
+      Object.assign(sourceMapCache, coverageReport["source-map-cache"])
+    }
+  }
+  visit(firstV8Coverage)
+  visit(secondV8Coverage)
+  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage])
+  v8Coverage["source-map-cache"] = sourceMapCache
+
+  return v8Coverage
+}

package/src/internal/executing/coverage_utils/v8_coverage_from_directory.js

@@ -0,0 +1,77 @@
+import {
+  assertAndNormalizeDirectoryUrl,
+  readDirectory,
+  readFile,
+  resolveUrl,
+} from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
+import { Abort } from "@jsenv/abort"
+
+export const visitNodeV8Directory = async ({
+  signal,
+  NODE_V8_COVERAGE,
+  onV8Coverage,
+}) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  const tryReadDirectory = async () => {
+    const dirContent = await readDirectory(NODE_V8_COVERAGE)
+    if (dirContent.length > 0) {
+      return dirContent
+    }
+    console.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
+    return dirContent
+  }
+
+  try {
+    operation.throwIfAborted()
+    const dirContent = await tryReadDirectory()
+
+    const coverageDirectoryUrl =
+      assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
+    await dirContent.reduce(async (previous, dirEntry) => {
+      operation.throwIfAborted()
+      await previous
+
+      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
+      const tryReadJsonFile = async () => {
+        const fileContent = await readFile(dirEntryUrl, { as: "string" })
+        if (fileContent === "") {
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
+          return null
+        }
+
+        try {
+          const fileAsJson = JSON.parse(fileContent)
+          return fileAsJson
+        } catch (e) {
+          console.warn(
+            createDetailedMessage(`Error while reading coverage file`, {
+              "error stack": e.stack,
+              "file": dirEntryUrl,
+            }),
+          )
+          return null
+        }
+      }
+
+      const fileContent = await tryReadJsonFile()
+      if (fileContent) {
+        onV8Coverage(fileContent)
+      }
+    }, Promise.resolve())
+  } finally {
+    await operation.end()
+  }
+}
+
+export const filterV8Coverage = (v8Coverage, { coverageIgnorePredicate }) => {
+  const v8CoverageFiltered = {
+    ...v8Coverage,
+    result: v8Coverage.result.filter((fileReport) => {
+      return !coverageIgnorePredicate(fileReport.url)
+    }),
+  }
+  return v8CoverageFiltered
+}

package/src/internal/executing/{coverage/istanbulCoverageFromV8Coverage.js → coverage_utils/v8_coverage_to_istanbul.js}

@@ -1,14 +1,23 @@
 import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import { require } from "@jsenv/core/src/internal/require.js"
 
-import { composeIstanbulCoverages } from "./composeIstanbulCoverages.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
+
+export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  try {
+    const v8ToIstanbul = require("v8-to-istanbul")
+    const sourcemapCache = v8Coverage["source-map-cache"]
+    let istanbulCoverageComposed = null
+
+    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+      operation.throwIfAborted()
+      await previous
 
-export const istanbulCoverageFromV8Coverage = async (v8Coverage) => {
-  const v8ToIstanbul = require("v8-to-istanbul")
-  const sourcemapCache = v8Coverage["source-map-cache"]
-  const istanbulCoverages = await Promise.all(
-    v8Coverage.result.map(async (fileV8Coverage) => {
       const { source } = fileV8Coverage
       let sources
       // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
@@ -32,23 +41,35 @@ export const istanbulCoverageFromV8Coverage = async (v8Coverage) => {
 
       converter.applyCoverage(fileV8Coverage.functions)
       const istanbulCoverage = converter.toIstanbul()
-      return istanbulCoverage
-    }),
-  )
 
-  const istanbulCoverageComposed = composeIstanbulCoverages(istanbulCoverages)
-  return markCoverageAsConverted(istanbulCoverageComposed)
+      istanbulCoverageComposed = istanbulCoverageComposed
+        ? composeTwoFileByFileIstanbulCoverages(
+            istanbulCoverageComposed,
+            istanbulCoverage,
+          )
+        : istanbulCoverage
+    }, Promise.resolve())
+
+    if (!istanbulCoverageComposed) {
+      return {}
+    }
+    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
+    return istanbulCoverageComposed
+  } finally {
+    await operation.end()
+  }
 }
 
-const markCoverageAsConverted = (istanbulCoverage) => {
-  const istanbulCoverageMarked = {}
-  Object.keys(istanbulCoverage).forEach((key) => {
-    istanbulCoverageMarked[key] = {
-      ...istanbulCoverage[key],
+const markAsConvertedFromV8 = (fileByFileCoverage) => {
+  const fileByFileMarked = {}
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
+    fileByFileMarked[key] = {
+      ...fileCoverage,
       fromV8: true,
     }
   })
-  return istanbulCoverageMarked
+  return fileByFileMarked
 }
 
 const sourcesFromSourceMapCache = (url, sourceMapCache) => {

package/src/internal/executing/createSummaryLog.js

@@ -5,7 +5,8 @@ import { EXECUTION_COLORS } from "./execution_colors.js"
 
 export const createSummaryLog = (summary) => `
 -------------- summary -----------------
-${createSummaryMessage(summary)}${createTotalDurationMessage(summary)}
+${createSummaryMessage(summary)}
+total duration: ${msAsDuration(summary.duration)}
 ----------------------------------------
 `
 
@@ -21,7 +22,9 @@ const createSummaryMessage = ({
     return `no execution`
   }
 
-  return `${executionCount} execution: ${createSummaryDetails({
+  const executionLabel =
+    executionCount === 1 ? `1 execution` : `${executionCount} executions`
+  return `${executionLabel}: ${createSummaryDetails({
     executionCount,
     abortedCount,
     timedoutCount,
@@ -112,10 +115,3 @@ const createMixedDetails = ({
 
   return `${parts.join(", ")}`
 }
-
-const createTotalDurationMessage = ({ startMs, endMs }) => {
-  if (!endMs) return ""
-
-  return `
-total duration: ${msAsDuration(endMs - startMs)}`
-}