@jsenv/core 23.2.2 → 23.4.2

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

@@ -0,0 +1,90 @@
+import { urlToFileSystemPath } from "@jsenv/filesystem"
+
+import { require } from "@jsenv/core/src/internal/require.js"
+
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
+
+export const v8CoverageToIstanbul = async (v8Coverage) => {
+  const v8ToIstanbul = require("v8-to-istanbul")
+  const sourcemapCache = v8Coverage["source-map-cache"]
+  let istanbulCoverageComposed = null
+  await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+    await previous
+
+    const { source } = fileV8Coverage
+    let sources
+    // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
+    if (typeof source === "string") {
+      sources = { source }
+    }
+    // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
+    else if (sourcemapCache) {
+      sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache)
+    }
+    const path = urlToFileSystemPath(fileV8Coverage.url)
+
+    const converter = v8ToIstanbul(
+      path,
+      // wrapperLength is undefined we don't need it
+      // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
+      undefined,
+      sources,
+    )
+    await converter.load()
+
+    converter.applyCoverage(fileV8Coverage.functions)
+    const istanbulCoverage = converter.toIstanbul()
+
+    istanbulCoverageComposed = istanbulCoverageComposed
+      ? composeTwoFileByFileIstanbulCoverages(
+          istanbulCoverageComposed,
+          istanbulCoverage,
+        )
+      : istanbulCoverage
+  }, Promise.resolve())
+
+  if (!istanbulCoverageComposed) {
+    return {}
+  }
+  istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
+  return istanbulCoverageComposed
+}
+
+const markAsConvertedFromV8 = (fileByFileCoverage) => {
+  const fileByFileMarked = {}
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
+    fileByFileMarked[key] = {
+      ...fileCoverage,
+      fromV8: true,
+    }
+  })
+  return fileByFileMarked
+}
+
+const sourcesFromSourceMapCache = (url, sourceMapCache) => {
+  const sourceMapAndLineLengths = sourceMapCache[url]
+  if (!sourceMapAndLineLengths) {
+    return {}
+  }
+
+  const { data, lineLengths } = sourceMapAndLineLengths
+  // See: https://github.com/nodejs/node/pull/34305
+  if (!data) {
+    return undefined
+  }
+
+  const sources = {
+    sourcemap: data,
+    ...(lineLengths ? { source: sourcesFromLineLengths(lineLengths) } : {}),
+  }
+  return sources
+}
+
+const sourcesFromLineLengths = (lineLengths) => {
+  let source = ""
+  lineLengths.forEach((length) => {
+    source += `${"".padEnd(length, ".")}\n`
+  })
+  return source
+}

package/src/internal/executing/createSummaryLog.js

@@ -1,4 +1,5 @@
-import { setANSIColor } from "../logs/log_style.js"
+import { ANSI } from "@jsenv/log"
+
 import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 
@@ -20,7 +21,9 @@ const createSummaryMessage = ({
     return `no execution`
   }
 
-  return `${executionCount} execution: ${createSummaryDetails({
+  const executionLabel =
+    executionCount === 1 ? `1 execution` : `${executionCount} executions`
+  return `${executionLabel}: ${createSummaryDetails({
     executionCount,
     abortedCount,
     timedoutCount,
@@ -39,19 +42,19 @@ export const createSummaryDetails = ({
   cancelledCount,
 }) => {
   if (abortedCount === executionCount) {
-    return `all ${setANSIColor(`aborted`, EXECUTION_COLORS.aborted)}`
+    return `all ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`
   }
   if (timedoutCount === executionCount) {
-    return `all ${setANSIColor(`timed out`, EXECUTION_COLORS.timedout)}`
+    return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`
   }
   if (erroredCount === executionCount) {
-    return `all ${setANSIColor(`errored`, EXECUTION_COLORS.errored)}`
+    return `all ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`
   }
   if (completedCount === executionCount) {
-    return `all ${setANSIColor(`completed`, EXECUTION_COLORS.completed)}`
+    return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`
   }
   if (cancelledCount === executionCount) {
-    return `all ${setANSIColor(`cancelled`, EXECUTION_COLORS.cancelled)}`
+    return `all ${ANSI.color(`cancelled`, EXECUTION_COLORS.cancelled)}`
   }
 
   return createMixedDetails({
@@ -75,22 +78,19 @@ const createMixedDetails = ({
 
   if (timedoutCount) {
     parts.push(
-      `${timedoutCount} ${setANSIColor(
-        `timed out`,
-        EXECUTION_COLORS.timedout,
-      )}`,
+      `${timedoutCount} ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`,
     )
   }
 
   if (erroredCount) {
     parts.push(
-      `${erroredCount} ${setANSIColor(`errored`, EXECUTION_COLORS.errored)}`,
+      `${erroredCount} ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`,
     )
   }
 
   if (completedCount) {
     parts.push(
-      `${completedCount} ${setANSIColor(
+      `${completedCount} ${ANSI.color(
         `completed`,
         EXECUTION_COLORS.completed,
       )}`,
@@ -99,13 +99,13 @@ const createMixedDetails = ({
 
   if (abortedCount) {
     parts.push(
-      `${abortedCount} ${setANSIColor(`aborted`, EXECUTION_COLORS.aborted)}`,
+      `${abortedCount} ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`,
     )
   }
 
   if (cancelledCount) {
     parts.push(
-      `${cancelledCount} ${setANSIColor(
+      `${cancelledCount} ${ANSI.color(
         `cancelled`,
         EXECUTION_COLORS.cancelled,
       )}`,

package/src/internal/executing/executeConcurrently.js

@@ -1,11 +1,20 @@
 import { stat } from "node:fs"
 import wrapAnsi from "wrap-ansi"
+import cuid from "cuid"
 import { loggerToLevels, createDetailedMessage } from "@jsenv/logger"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
+import {
+  urlToFileSystemPath,
+  resolveUrl,
+  writeDirectory,
+  ensureEmptyDirectory,
+  normalizeStructuredMetaMap,
+  urlToMeta,
+} from "@jsenv/filesystem"
+import { createLog } from "@jsenv/log"
+import { Abort } from "@jsenv/abort"
 
 import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
-import { writeLog } from "./writeLog.js"
 import { createExecutionResultLog } from "./executionLogs.js"
 import { createSummaryLog } from "./createSummaryLog.js"
 
@@ -33,7 +42,9 @@ export const executeConcurrently = async (
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
+    runtimeSupport,
 
     mainFileNotFoundCallback = ({ fileRelativeUrl }) => {
       logger.error(
@@ -55,6 +66,73 @@ export const executeConcurrently = async (
   const report = {}
   const executionCount = executionSteps.length
 
+  let transformReturnValue = (value) => value
+
+  const coverageTempDirectoryUrl = resolveUrl(
+    coverageTempDirectoryRelativeUrl,
+    projectDirectoryUrl,
+  )
+
+  const structuredMetaMapForCover = normalizeStructuredMetaMap(
+    {
+      cover: coverageConfig,
+    },
+    projectDirectoryUrl,
+  )
+  const coverageIgnorePredicate = (url) => {
+    return !urlToMeta({
+      url: resolveUrl(url, projectDirectoryUrl),
+      structuredMetaMap: structuredMetaMapForCover,
+    }).cover
+  }
+
+  if (coverage) {
+    // in case runned multiple times, we don't want to keep writing lot of files in this directory
+    if (!process.env.NODE_V8_COVERAGE) {
+      await ensureEmptyDirectory(coverageTempDirectoryUrl)
+    }
+
+    if (runtimeSupport.node) {
+      // v8 coverage is written in a directoy and auto propagate to subprocesses
+      // through process.env.NODE_V8_COVERAGE.
+      if (!coverageForceIstanbul && !process.env.NODE_V8_COVERAGE) {
+        const v8CoverageDirectory = resolveUrl(
+          `./node_v8/${cuid()}`,
+          coverageTempDirectoryUrl,
+        )
+        await writeDirectory(v8CoverageDirectory, { allowUseless: true })
+        process.env.NODE_V8_COVERAGE = urlToFileSystemPath(v8CoverageDirectory)
+      }
+    }
+
+    transformReturnValue = async (value) => {
+      if (multipleExecutionsOperation.signal.aborted) {
+        // don't try to do the coverage stuff
+        return value
+      }
+
+      try {
+        value.coverage = await reportToCoverage(value.report, {
+          multipleExecutionsOperation,
+          logger,
+          projectDirectoryUrl,
+          babelPluginMap,
+          coverageConfig,
+          coverageIncludeMissing,
+          coverageForceIstanbul,
+          coverageIgnorePredicate,
+          coverageV8ConflictWarning,
+        })
+      } catch (e) {
+        if (Abort.isAbortError(e)) {
+          return value
+        }
+        throw e
+      }
+      return value
+    }
+  }
+
   let previousExecutionResult
   let previousExecutionLog
   let abortedCount = 0
@@ -116,12 +194,13 @@ export const executeConcurrently = async (
 
         ...executionParams,
         collectCoverage: coverage,
+        coverageTempDirectoryUrl,
         runtimeParams: {
           projectDirectoryUrl,
           compileServerOrigin,
           outDirectoryRelativeUrl,
           collectCoverage: coverage,
-          coverageConfig,
+          coverageIgnorePredicate,
           coverageForceIstanbul,
           ...executionParams.runtimeParams,
         },
@@ -129,7 +208,7 @@ export const executeConcurrently = async (
           fileRelativeUrl,
           ...executionParams.executeParams,
         },
-        coverageV8MergeConflictIsExpected,
+        coverageV8ConflictWarning,
       })
       const afterExecutionInfo = {
         ...beforeExecutionInfo,
@@ -173,11 +252,13 @@ export const executeConcurrently = async (
             : true) &&
           executionResult.status === "completed"
         ) {
-          previousExecutionLog = previousExecutionLog.update(log)
+          previousExecutionLog.write(log)
         } else {
-          previousExecutionLog = writeLog(log, {
-            mightUpdate: completedExecutionLogMerging,
-          })
+          if (previousExecutionLog) {
+            previousExecutionLog.destroy()
+          }
+          previousExecutionLog = createLog()
+          previousExecutionLog.write(log)
         }
       }
 
@@ -206,31 +287,10 @@ export const executeConcurrently = async (
     logger.info(createSummaryLog(summary))
   }
 
-  if (multipleExecutionsOperation.signal.aborted) {
-    // don't try to do the coverage stuff
-    return {
-      summary,
-      report,
-    }
-  }
-
-  return {
+  return transformReturnValue({
     summary,
     report,
-    ...(coverage
-      ? {
-          coverage: await reportToCoverage(report, {
-            multipleExecutionsOperation,
-            logger,
-            projectDirectoryUrl,
-            babelPluginMap,
-            coverageConfig,
-            coverageIncludeMissing,
-            coverageV8MergeConflictIsExpected,
-          }),
-        }
-      : {}),
-  }
+  })
 }
 
 const executeInParallel = async ({

package/src/internal/executing/executePlan.js

@@ -1,7 +1,5 @@
-import {
-  Abortable,
-  raceProcessTeardownEvents,
-} from "@jsenv/core/src/abort/main.js"
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
+
 import { mergeRuntimeSupport } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { startCompileServer } from "../compiling/startCompileServer.js"
 import { babelPluginInstrument } from "./coverage/babel_plugin_instrument.js"
@@ -36,7 +34,8 @@ export const executePlan = async (
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
 
     compileServerProtocol,
     compileServerPrivateKey,
@@ -74,97 +73,101 @@ export const executePlan = async (
     })
   })
 
-  const multipleExecutionsOperation = Abortable.fromSignal(signal)
+  const multipleExecutionsOperation = Abort.startOperation()
+  multipleExecutionsOperation.addAbortSignal(signal)
   if (handleSIGINT) {
-    Abortable.effect(multipleExecutionsOperation, (cb) =>
-      raceProcessTeardownEvents(
+    multipleExecutionsOperation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
         {
           SIGINT: true,
         },
         () => {
           logger.info("Aborting execution (SIGINT)")
-          cb()
+          abort()
         },
-      ),
-    )
+      )
+    })
   }
 
-  const compileServer = await startCompileServer({
-    signal: multipleExecutionsOperation.signal,
-    compileServerLogLevel,
-
-    projectDirectoryUrl,
-    jsenvDirectoryRelativeUrl,
-    jsenvDirectoryClean,
-    outDirectoryName: "out-dev",
-
-    importResolutionMethod,
-    importDefaultExtension,
-
-    compileServerProtocol,
-    compileServerPrivateKey,
-    compileServerCertificate,
-    compileServerIp,
-    compileServerPort,
-    compileServerCanReadFromFilesystem,
-    compileServerCanWriteOnFilesystem,
-    keepProcessAlive: true, // to be sure it stays alive
-    babelPluginMap,
-    babelConfigFileUrl,
-    customCompilers,
-    runtimeSupport,
-  })
-
-  multipleExecutionsOperation.cleaner.addCallback(async () => {
-    await compileServer.stop()
-  })
-
-  const executionSteps = await generateExecutionSteps(
-    {
-      ...plan,
-      [compileServer.outDirectoryRelativeUrl]: null,
-    },
-    {
+  try {
+    const compileServer = await startCompileServer({
       signal: multipleExecutionsOperation.signal,
-      projectDirectoryUrl,
-    },
-  )
-
-  const result = await executeConcurrently(executionSteps, {
-    multipleExecutionsOperation,
-    logger,
-    launchAndExecuteLogLevel,
+      compileServerLogLevel,
 
-    projectDirectoryUrl,
-    compileServerOrigin: compileServer.origin,
-    outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
-
-    // not sure we actually have to pass import params to executeConcurrently
-    importResolutionMethod,
-    importDefaultExtension,
+      projectDirectoryUrl,
+      jsenvDirectoryRelativeUrl,
+      jsenvDirectoryClean,
+      outDirectoryName: "out-dev",
+
+      importResolutionMethod,
+      importDefaultExtension,
+
+      compileServerProtocol,
+      compileServerPrivateKey,
+      compileServerCertificate,
+      compileServerIp,
+      compileServerPort,
+      compileServerCanReadFromFilesystem,
+      compileServerCanWriteOnFilesystem,
+      keepProcessAlive: true, // to be sure it stays alive
+      babelPluginMap,
+      babelConfigFileUrl,
+      customCompilers,
+      runtimeSupport,
+    })
 
-    babelPluginMap: compileServer.babelPluginMap,
+    multipleExecutionsOperation.addEndCallback(async () => {
+      await compileServer.stop()
+    })
 
-    defaultMsAllocatedPerExecution,
-    maxExecutionsInParallel,
-    completedExecutionLogMerging,
-    completedExecutionLogAbbreviation,
-    logSummary,
-    measureGlobalDuration,
+    const executionSteps = await generateExecutionSteps(
+      {
+        ...plan,
+        [compileServer.outDirectoryRelativeUrl]: null,
+      },
+      {
+        signal: multipleExecutionsOperation.signal,
+        projectDirectoryUrl,
+      },
+    )
 
-    coverage,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
-  })
+    const result = await executeConcurrently(executionSteps, {
+      multipleExecutionsOperation,
+      logger,
+      launchAndExecuteLogLevel,
 
-  // (used to stop potential chrome browser still opened to be reused)
-  multipleExecutionsOperation.cleaner.clean("all execution done")
+      projectDirectoryUrl,
+      compileServerOrigin: compileServer.origin,
+      outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
+
+      // not sure we actually have to pass import params to executeConcurrently
+      importResolutionMethod,
+      importDefaultExtension,
+
+      babelPluginMap: compileServer.babelPluginMap,
+
+      defaultMsAllocatedPerExecution,
+      maxExecutionsInParallel,
+      completedExecutionLogMerging,
+      completedExecutionLogAbbreviation,
+      logSummary,
+      measureGlobalDuration,
+
+      coverage,
+      coverageConfig,
+      coverageIncludeMissing,
+      coverageForceIstanbul,
+      coverageV8ConflictWarning,
+      coverageTempDirectoryRelativeUrl,
+      runtimeSupport,
+    })
 
-  return {
-    planSummary: result.summary,
-    planReport: result.report,
-    planCoverage: result.coverage,
+    return {
+      planSummary: result.summary,
+      planReport: result.report,
+      planCoverage: result.coverage,
+    }
+  } finally {
+    await multipleExecutionsOperation.end()
   }
 }

package/src/internal/executing/executionLogs.js

@@ -1,9 +1,5 @@
-import {
-  failureSignColorLess,
-  okSignColorLess,
-  setANSIColor,
-  ANSI_GREY,
-} from "../logs/log_style.js"
+import { ANSI, UNICODE } from "@jsenv/log"
+
 import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 import { createSummaryDetails } from "./createSummaryLog.js"
@@ -56,32 +52,32 @@ runtime: ${runtime}${appendDuration({
 
 const descriptionFormatters = {
   aborted: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} aborted`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} aborted`,
       EXECUTION_COLORS.aborted,
     )
   },
   timedout: ({ executionNumber, allocatedMs, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} timeout after ${allocatedMs}ms`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} timeout after ${allocatedMs}ms`,
       EXECUTION_COLORS.timedout,
     )
   },
   errored: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} error`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} error`,
       EXECUTION_COLORS.errored,
     )
   },
   completed: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${okSignColorLess} execution ${executionNumber} of ${executionCount} completed`,
+    return ANSI.color(
+      `${UNICODE.OK_RAW} execution ${executionNumber} of ${executionCount} completed`,
       EXECUTION_COLORS.completed,
     )
   },
   cancelled: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} cancelled`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} cancelled`,
       EXECUTION_COLORS.cancelled,
     )
   },
@@ -105,9 +101,9 @@ const appendConsole = (consoleCalls) => {
   if (consoleOutputTrimmed === "") return ""
 
   return `
-${setANSIColor(`-------- console --------`, ANSI_GREY)}
+${ANSI.color(`-------- console --------`, ANSI.GREY)}
 ${consoleOutputTrimmed}
-${setANSIColor(`-------------------------`, ANSI_GREY)}`
+${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
 const appendError = (error) => {

package/src/internal/executing/execution_colors.js

@@ -1,15 +1,9 @@
-import {
-  ANSI_GREY,
-  ANSI_YELLOW,
-  ANSI_RED,
-  ANSI_GREEN,
-  ANSI_MAGENTA,
-} from "../logs/log_style.js"
+import { ANSI } from "@jsenv/log"
 
 export const EXECUTION_COLORS = {
-  aborted: ANSI_MAGENTA,
-  timedout: ANSI_YELLOW,
-  errored: ANSI_RED,
-  completed: ANSI_GREEN,
-  cancelled: ANSI_GREY,
+  aborted: ANSI.MAGENTA,
+  timedout: ANSI.YELLOW,
+  errored: ANSI.RED,
+  completed: ANSI.GREEN,
+  cancelled: ANSI.GREY,
 }