@jsenv/core 23.2.1 → 23.4.1

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,
 }